#line 1 "all-std.cxx"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\concepts"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#pragma once


#line 16 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"

#line 18 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"
#line 19 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


#pragma once


#line 32 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"

#line 34 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"
#line 35 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


#line 39 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


#line 49 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"
        

        #line 54 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"
    #line 55 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"
#line 56 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"


#pragma once


#line 151 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"


#line 155 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"


#line 185 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"


#line 188 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"

#line 190 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"


#line 196 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"


#line 200 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"


#line 207 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"


#line 219 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"


#line 228 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"
#line 229 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"


#pragma region Input Buffer SAL 1 compatibility macros


#pragma endregion Input Buffer SAL 1 compatibility macros


#line 1555 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"


#line 1586 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"


#line 1611 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"


#line 1624 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"


#line 1663 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"


#line 1775 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"


#line 1878 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"


#line 2047 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"


#line 2149 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"


#line 2361 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"
extern "C" {


#line 2367 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"


#line 2595 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"
    
    
#line 2634 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"


#line 2868 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"


#line 2878 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"


#line 2884 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"
    
#line 2886 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"
#line 2887 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"


#line 2894 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"
#line 2895 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"


#line 2902 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"
#line 2903 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"


#line 2915 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"


#line 2949 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"


}
#line 2973 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\concurrencysal.h"


#pragma once


extern "C" {
#line 24 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\concurrencysal.h"


#line 292 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\concurrencysal.h"


#line 296 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\concurrencysal.h"


#line 345 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\concurrencysal.h"


#line 389 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\concurrencysal.h"


}
#line 393 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\concurrencysal.h"

#line 395 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\concurrencysal.h"
#line 2975 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sal.h"
#line 58 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vadefs.h"


#pragma once


#pragma pack(push, 8)


    #line 24 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vadefs.h"
#line 25 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vadefs.h"


    #line 34 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vadefs.h"
#line 35 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vadefs.h"


#line 40 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vadefs.h"


#line 46 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vadefs.h"

#pragma warning(push)
#pragma warning(disable:   4514 4820 )


extern "C" {
#line 53 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vadefs.h"


#line 57 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vadefs.h"


        typedef unsigned int uintptr_t;
    #line 65 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vadefs.h"
#line 66 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vadefs.h"


        typedef char* va_list;
    #line 74 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vadefs.h"
#line 75 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vadefs.h"


#line 81 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vadefs.h"


#line 87 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vadefs.h"


#line 91 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vadefs.h"
    
    
#line 94 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vadefs.h"


#line 106 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vadefs.h"

    
#line 165 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vadefs.h"


} 
#line 169 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vadefs.h"


    extern "C++"
    {
        template <typename _Ty>
        struct __vcrt_va_list_is_reference
        {
            enum : bool { __the_value = false };
        };

        template <typename _Ty>
        struct __vcrt_va_list_is_reference<_Ty&>
        {
            enum : bool { __the_value = true };
        };

        template <typename _Ty>
        struct __vcrt_va_list_is_reference<_Ty&&>
        {
            enum : bool { __the_value = true };
        };

        template <typename _Ty>
        struct __vcrt_assert_va_start_is_not_reference
        {
            static_assert(!__vcrt_va_list_is_reference<_Ty>::__the_value,
                "va_start argument must not have reference type and must not be parenthesized");
        };
    } 

    
#line 206 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vadefs.h"

#pragma warning(pop) 
#pragma pack(pop)
#line 59 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"

#pragma warning(push)
#pragma warning(disable:   4514 4820 )


#line 95 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"

__pragma(pack(push, 8)) extern "C" {


    #line 106 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"
#line 107 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


#line 126 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"

#line 128 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"
        
    #line 130 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"
#line 131 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


#line 136 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"
        
    #line 138 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"
#line 139 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


#line 145 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"
    
    
#line 148 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


#line 154 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


#line 166 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


#line 170 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"
    
#line 172 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


#line 178 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


#line 186 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"
#line 187 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


    typedef unsigned int     size_t;
    typedef int              ptrdiff_t;
    typedef int              intptr_t;
#line 201 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


    typedef bool  __vcrt_bool;


#line 211 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


#line 216 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


#line 220 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


#line 224 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


#line 237 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"
#line 238 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


#line 242 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"
    
#line 244 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


#line 248 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


    extern "C++"
    {
        template <typename _CountofType, size_t _SizeOfArray>
        char (*__countof_helper( _CountofType (&_Array)[_SizeOfArray]))[_SizeOfArray];

        
    }


#line 260 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


#line 264 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


#line 271 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


#line 274 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


#line 281 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"
#line 282 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


#line 289 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"
#line 290 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


#line 297 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"
#line 298 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


#line 304 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


#line 308 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


#line 318 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"
#line 319 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


#line 325 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


#line 332 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


    #line 343 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"
#line 344 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


#line 348 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


#line 356 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"
#line 357 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"


    void __cdecl __security_init_cookie(void);

    
        void __fastcall __security_check_cookie(  uintptr_t _StackCookie);
        __declspec(noreturn) void __cdecl __report_gsfailure(void);
    

#line 371 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"
#line 372 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"

extern uintptr_t __security_cookie;


#line 380 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"

} __pragma(pack(pop))

#pragma warning(pop) 

#line 386 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime.h"
#line 401 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#pragma once


#line 33 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 39 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 45 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 51 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 57 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 63 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 69 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 75 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 81 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 87 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 93 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 99 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 105 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 111 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 117 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 123 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 129 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 135 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 141 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 147 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 153 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 159 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 165 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 171 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 177 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 183 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 189 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 195 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 201 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 207 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 213 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 219 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 225 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 231 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 237 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 243 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 249 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 255 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 261 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 267 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 273 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 279 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 285 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 291 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 297 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 304 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 310 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 316 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 322 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 328 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 334 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 340 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 346 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 352 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 358 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 364 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 370 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 376 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 382 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 388 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 394 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 400 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 406 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 412 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 418 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 424 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 430 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 436 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 442 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 448 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 454 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 460 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 466 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 472 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 478 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 484 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 490 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 496 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 502 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 508 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 514 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 521 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 527 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 533 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 539 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 546 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 552 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 558 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 566 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 572 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 578 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 584 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"


#line 588 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"

#line 590 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"
#line 591 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xkeycheck.h"
#line 402 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 407 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"

#line 409 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"
#line 410 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 414 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 418 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 429 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 433 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"

#line 435 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 443 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 447 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 457 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"
#line 458 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 466 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 471 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"

#line 473 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 478 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"

#line 480 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 484 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 523 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 546 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"
#line 547 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 554 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"
#line 555 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 567 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 571 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"
#line 572 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 580 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"

#line 582 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"
#line 583 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 596 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"

#line 598 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 602 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 605 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 608 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"
#line 609 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 613 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 617 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 627 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 634 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 641 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 646 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 651 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 656 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 661 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 669 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 674 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 689 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 696 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 707 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 718 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 724 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 733 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"
#line 734 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 750 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 761 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 774 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 788 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 801 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 816 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 829 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 841 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 853 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 866 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 883 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 895 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 913 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 930 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 947 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 961 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 973 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 986 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1000 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1013 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1024 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1037 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1049 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1061 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1072 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1083 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1095 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1107 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1114 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1118 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1122 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1126 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1130 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1134 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1138 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1142 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1146 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1150 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1157 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1162 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1168 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1173 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1178 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1197 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1228 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1246 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1253 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1260 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1278 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1282 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1302 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1313 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"
#line 1314 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1321 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"
#line 1322 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1332 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1341 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1350 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1356 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1364 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1375 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1383 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1390 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1398 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1405 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"
#line 1406 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1414 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1420 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1426 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1464 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1468 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1472 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1485 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1488 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1491 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"
#line 1492 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1498 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1504 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"


#line 1510 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"

#line 1512 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"
#line 1513 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals_core.h"
#line 10 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\concepts"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cstdint"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stdint.h"


#pragma once


#pragma warning(push)
#pragma warning(disable:   4514 4820 )

typedef signed char        int8_t;
typedef short              int16_t;
typedef int                int32_t;
typedef long long          int64_t;
typedef unsigned char      uint8_t;
typedef unsigned short     uint16_t;
typedef unsigned int       uint32_t;
typedef unsigned long long uint64_t;

typedef signed char        int_least8_t;
typedef short              int_least16_t;
typedef int                int_least32_t;
typedef long long          int_least64_t;
typedef unsigned char      uint_least8_t;
typedef unsigned short     uint_least16_t;
typedef unsigned int       uint_least32_t;
typedef unsigned long long uint_least64_t;

typedef signed char        int_fast8_t;
typedef int                int_fast16_t;
typedef int                int_fast32_t;
typedef long long          int_fast64_t;
typedef unsigned char      uint_fast8_t;
typedef unsigned int       uint_fast16_t;
typedef unsigned int       uint_fast32_t;
typedef unsigned long long uint_fast64_t;

typedef long long          intmax_t;
typedef unsigned long long uintmax_t;


#line 97 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stdint.h"


    #line 112 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stdint.h"
#line 113 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stdint.h"


#pragma warning(pop) 

#line 139 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stdint.h"
#line 13 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cstdint"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
using :: int8_t;
using :: int16_t;
using :: int32_t;
using :: int64_t;
using :: uint8_t;
using :: uint16_t;
using :: uint32_t;
using :: uint64_t;

using :: int_least8_t;
using :: int_least16_t;
using :: int_least32_t;
using :: int_least64_t;
using :: uint_least8_t;
using :: uint_least16_t;
using :: uint_least32_t;
using :: uint_least64_t;

using :: int_fast8_t;
using :: int_fast16_t;
using :: int_fast32_t;
using :: int_fast64_t;
using :: uint_fast8_t;
using :: uint_fast16_t;
using :: uint_fast32_t;
using :: uint_fast64_t;

using :: intmax_t;
using :: intptr_t;
using :: uintmax_t;
using :: uintptr_t;


#line 89 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cstdint"
}


#pragma warning(pop)
#pragma pack(pop)

#line 97 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cstdint"
#line 98 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cstdint"
#line 12 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstddef"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cstddef"


#pragma once


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stddef.h"


#pragma once


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#pragma once


    #line 26 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
#line 27 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 32 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 47 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


    #line 63 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
#line 64 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


    #line 71 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
#line 72 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"

#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


#line 88 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"

#line 90 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
        
    #line 92 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
#line 93 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 99 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 104 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"

#line 106 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
        
    #line 108 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
#line 109 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 113 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
    
#line 115 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 121 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 127 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
    
#line 129 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 136 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 140 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
    
#line 142 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 153 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


    #line 171 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
#line 172 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 176 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
    
#line 178 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 182 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
    
#line 184 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 188 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
    
#line 190 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


extern "C++"
{
    template<bool _Enable, typename _Ty>
    struct _CrtEnableIf;

    template<typename _Ty>
    struct _CrtEnableIf<true, _Ty>
    {
        typedef _Ty _Type;
    };
}
#line 211 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


    typedef bool  __crt_bool;


#line 221 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


    #line 234 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 243 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 265 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
        
    #line 267 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
#line 268 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 272 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 276 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 284 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
 

#line 291 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
#line 292 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


    #line 319 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
#line 320 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 324 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 331 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
#line 332 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


 void __cdecl _invalid_parameter_noinfo(void);
 __declspec(noreturn) void __cdecl _invalid_parameter_noinfo_noreturn(void);

__declspec(noreturn)
 void __cdecl _invoke_watson(
      wchar_t const* _Expression,
      wchar_t const* _FunctionName,
      wchar_t const* _FileName,
            unsigned int _LineNo,
            uintptr_t _Reserved);


    #line 387 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
#line 388 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 405 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 409 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


    #line 418 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
#line 419 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


    #line 437 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
#line 438 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


    #line 445 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
#line 446 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 450 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 464 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 480 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 487 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 491 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 496 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
#line 497 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


        #line 507 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
    #line 508 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
#line 509 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 513 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 519 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


    #line 529 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
#line 530 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 539 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"

    
#line 549 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"

    
#line 556 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
    

#line 561 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"

    
#line 569 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"

    
#line 577 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
#line 578 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 582 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


typedef int                           errno_t;
typedef unsigned short                wint_t;
typedef unsigned short                wctype_t;
typedef long                          __time32_t;
typedef __int64                       __time64_t;

typedef struct __crt_locale_data_public
{
      unsigned short const* _locale_pctype;
      int _locale_mb_cur_max;
               unsigned int _locale_lc_codepage;
} __crt_locale_data_public;

typedef struct __crt_locale_pointers
{
    struct __crt_locale_data*    locinfo;
    struct __crt_multibyte_data* mbcinfo;
} __crt_locale_pointers;

typedef __crt_locale_pointers* _locale_t;

typedef struct _Mbstatet
{ 
    unsigned long _Wchar;
    unsigned short _Byte, _State;
} _Mbstatet;

typedef _Mbstatet mbstate_t;


#line 622 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 626 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


        typedef __time64_t time_t;
    #line 633 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
#line 634 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 639 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


    typedef size_t rsize_t;
#line 643 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 813 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
#line 814 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"


#line 1865 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"

        
#line 2055 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
    #line 2056 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"
#line 2057 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt.h"

} __pragma(pack(pop))


#pragma warning(pop) 
#line 13 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stddef.h"

#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


    namespace std
    {
        typedef decltype(__nullptr) nullptr_t;
    }

    using ::std::nullptr_t;
#line 30 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stddef.h"


     int* __cdecl _errno(void);
    

     errno_t __cdecl _set_errno(  int _Value);
     errno_t __cdecl _get_errno(  int* _Value);

#line 42 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stddef.h"


#line 52 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stddef.h"
    
#line 54 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stddef.h"

 extern unsigned long  __cdecl __threadid(void);

 extern uintptr_t __cdecl __threadhandle(void);


} __pragma(pack(pop))

#pragma warning(pop) 
#line 65 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stddef.h"
#line 13 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cstddef"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtr1common"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
template <class _Ty, _Ty _Val>
struct integral_constant {
    static constexpr _Ty value = _Val;

    using value_type = _Ty;
    using type       = integral_constant;

    constexpr operator value_type() const noexcept {
        return value;
    }

    [[nodiscard]] constexpr value_type operator()() const noexcept {
        return value;
    }
};

template <bool _Val>
using bool_constant = integral_constant<bool, _Val>;

using true_type  = bool_constant<true>;
using false_type = bool_constant<false>;

template <bool _Test, class _Ty = void>
struct enable_if {}; 

template <class _Ty>
struct enable_if<true, _Ty> { 
    using type = _Ty;
};

template <bool _Test, class _Ty = void>
using enable_if_t = typename enable_if<_Test, _Ty>::type;

template <bool _Test, class _Ty1, class _Ty2>
struct conditional { 
    using type = _Ty1;
};

template <class _Ty1, class _Ty2>
struct conditional<false, _Ty1, _Ty2> {
    using type = _Ty2;
};

template <bool _Test, class _Ty1, class _Ty2>
using conditional_t = typename conditional<_Test, _Ty1, _Ty2>::type;


template <class, class>
inline constexpr bool is_same_v = false; 
template <class _Ty>
inline constexpr bool is_same_v<_Ty, _Ty> = true;

template <class _Ty1, class _Ty2>
struct is_same : bool_constant<is_same_v<_Ty1, _Ty2>> {};
#line 81 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtr1common"

template <class _Ty>
struct remove_const { 
    using type = _Ty;
};

template <class _Ty>
struct remove_const<const _Ty> {
    using type = _Ty;
};

template <class _Ty>
using remove_const_t = typename remove_const<_Ty>::type;

template <class _Ty>
struct remove_volatile { 
    using type = _Ty;
};

template <class _Ty>
struct remove_volatile<volatile _Ty> {
    using type = _Ty;
};

template <class _Ty>
using remove_volatile_t = typename remove_volatile<_Ty>::type;

template <class _Ty>
struct remove_cv { 
    using type = _Ty;

    template <template <class> class _Fn>
    using _Apply = _Fn<_Ty>; 
};

template <class _Ty>
struct remove_cv<const _Ty> {
    using type = _Ty;

    template <template <class> class _Fn>
    using _Apply = const _Fn<_Ty>;
};

template <class _Ty>
struct remove_cv<volatile _Ty> {
    using type = _Ty;

    template <template <class> class _Fn>
    using _Apply = volatile _Fn<_Ty>;
};

template <class _Ty>
struct remove_cv<const volatile _Ty> {
    using type = _Ty;

    template <template <class> class _Fn>
    using _Apply = const volatile _Fn<_Ty>;
};

template <class _Ty>
using remove_cv_t = typename remove_cv<_Ty>::type;

template <bool _First_value, class _First, class... _Rest>
struct _Disjunction { 
    using type = _First;
};

template <class _False, class _Next, class... _Rest>
struct _Disjunction<false, _False, _Next, _Rest...> { 
    using type = typename _Disjunction<_Next::value, _Next, _Rest...>::type;
};

template <class... _Traits>
struct disjunction : false_type {}; 

template <class _First, class... _Rest>
struct disjunction<_First, _Rest...> : _Disjunction<_First::value, _First, _Rest...>::type {
    
};

template <class... _Traits>
inline constexpr bool disjunction_v = disjunction<_Traits...>::value;

template <class _Ty, class... _Types>
inline constexpr bool _Is_any_of_v = 
    disjunction_v<is_same<_Ty, _Types>...>;


[[nodiscard]] constexpr bool is_constant_evaluated() noexcept {
    return __builtin_is_constant_evaluated();
}
#line 173 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtr1common"

template <class _Ty>
inline constexpr bool is_integral_v = _Is_any_of_v<remove_cv_t<_Ty>, bool, char, signed char, unsigned char,
    wchar_t,

    char8_t,
#line 180 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtr1common"
    char16_t, char32_t, short, unsigned short, int, unsigned int, long, unsigned long, long long, unsigned long long>;

template <class _Ty>
struct is_integral : bool_constant<is_integral_v<_Ty>> {};

template <class _Ty>
inline constexpr bool is_floating_point_v = _Is_any_of_v<remove_cv_t<_Ty>, float, double, long double>;

template <class _Ty>
struct is_floating_point : bool_constant<is_floating_point_v<_Ty>> {};

template <class _Ty>
inline constexpr bool is_arithmetic_v = 
    is_integral_v<_Ty> || is_floating_point_v<_Ty>;

template <class _Ty>
struct is_arithmetic : bool_constant<is_arithmetic_v<_Ty>> {};

template <class _Ty>
struct remove_reference {
    using type                 = _Ty;
    using _Const_thru_ref_type = const _Ty;
};

template <class _Ty>
struct remove_reference<_Ty&> {
    using type                 = _Ty;
    using _Const_thru_ref_type = const _Ty&;
};

template <class _Ty>
struct remove_reference<_Ty&&> {
    using type                 = _Ty;
    using _Const_thru_ref_type = const _Ty&&;
};

template <class _Ty>
using remove_reference_t = typename remove_reference<_Ty>::type;

template <class _Ty>
using _Const_thru_ref = typename remove_reference<_Ty>::_Const_thru_ref_type;

template <class _Ty>
using _Remove_cvref_t [[msvc::known_semantics]] = remove_cv_t<remove_reference_t<_Ty>>;


template <class _Ty>
using remove_cvref_t = _Remove_cvref_t<_Ty>;

template <class _Ty>
struct remove_cvref {
    using type = remove_cvref_t<_Ty>;
};
#line 234 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtr1common"

}


#pragma warning(pop)
#pragma pack(pop)
#line 241 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtr1common"
#line 242 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtr1common"
#line 14 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cstddef"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
using :: ptrdiff_t;
using :: size_t;
using max_align_t = double; 


enum class byte : unsigned char {};

template <class _IntType, enable_if_t<is_integral_v<_IntType>, int> = 0>
[[nodiscard]] constexpr byte operator<<(
    const byte _Arg, const _IntType _Shift) noexcept { 
    return static_cast<byte>(static_cast<unsigned char>(static_cast<unsigned int>(_Arg) << _Shift));
}

template <class _IntType, enable_if_t<is_integral_v<_IntType>, int> = 0>
[[nodiscard]] constexpr byte operator>>(
    const byte _Arg, const _IntType _Shift) noexcept { 
    return static_cast<byte>(static_cast<unsigned char>(static_cast<unsigned int>(_Arg) >> _Shift));
}

[[nodiscard]] constexpr byte operator|(
    const byte _Left, const byte _Right) noexcept { 
    return static_cast<byte>(
        static_cast<unsigned char>(static_cast<unsigned int>(_Left) | static_cast<unsigned int>(_Right)));
}

[[nodiscard]] constexpr byte operator&(
    const byte _Left, const byte _Right) noexcept { 
    return static_cast<byte>(
        static_cast<unsigned char>(static_cast<unsigned int>(_Left) & static_cast<unsigned int>(_Right)));
}

[[nodiscard]] constexpr byte operator^(
    const byte _Left, const byte _Right) noexcept { 
    return static_cast<byte>(
        static_cast<unsigned char>(static_cast<unsigned int>(_Left) ^ static_cast<unsigned int>(_Right)));
}

[[nodiscard]] constexpr byte operator~(const byte _Arg) noexcept { 
    return static_cast<byte>(static_cast<unsigned char>(~static_cast<unsigned int>(_Arg)));
}

template <class _IntType, enable_if_t<is_integral_v<_IntType>, int> = 0>
constexpr byte& operator<<=(byte& _Arg, const _IntType _Shift) noexcept { 
    return _Arg = _Arg << _Shift;
}

template <class _IntType, enable_if_t<is_integral_v<_IntType>, int> = 0>
constexpr byte& operator>>=(byte& _Arg, const _IntType _Shift) noexcept { 
    return _Arg = _Arg >> _Shift;
}

constexpr byte& operator|=(byte& _Left, const byte _Right) noexcept { 
    return _Left = _Left | _Right;
}

constexpr byte& operator&=(byte& _Left, const byte _Right) noexcept { 
    return _Left = _Left & _Right;
}

constexpr byte& operator^=(byte& _Left, const byte _Right) noexcept { 
    return _Left = _Left ^ _Right;
}

template <class _IntType, enable_if_t<is_integral_v<_IntType>, int> = 0>
[[nodiscard]] constexpr _IntType to_integer(const byte _Arg) noexcept { 
    return static_cast<_IntType>(_Arg);
}
#line 91 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cstddef"

}

using ::std:: max_align_t; 


#pragma warning(pop)
#pragma pack(pop)

#line 102 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cstddef"
#line 103 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cstddef"
#line 12 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstddef"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cstdlib"


#pragma once


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\math.h"


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_math.h"


#pragma once


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


    struct _exception
    {
        int    type;   
        char*  name;   
        double arg1;   
        double arg2;   
        double retval; 
    };

    
        struct _complex
        {
            double x, y; 
        };

        
#line 46 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_math.h"
    #line 47 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_math.h"
#line 48 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_math.h"


#line 59 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_math.h"
    typedef float  float_t;
    typedef double double_t;
#line 62 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_math.h"


        extern double const _HUGE;
    

#line 82 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_math.h"
#line 83 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_math.h"


#line 87 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_math.h"


void __cdecl _fperrraise(  int _Except);

   short __cdecl _dclass(  double _X);
   short __cdecl _ldclass(  long double _X);
   short __cdecl _fdclass(  float _X);

   int __cdecl _dsign(  double _X);
   int __cdecl _ldsign(  long double _X);
   int __cdecl _fdsign(  float _X);

   int __cdecl _dpcomp(  double _X,   double _Y);
   int __cdecl _ldpcomp(  long double _X,   long double _Y);
   int __cdecl _fdpcomp(  float _X,   float _Y);

   short __cdecl _dtest(  double* _Px);
   short __cdecl _ldtest(  long double* _Px);
   short __cdecl _fdtest(  float* _Px);

 short __cdecl _d_int(  double* _Px,   short _Xexp);
 short __cdecl _ld_int(  long double* _Px,   short _Xexp);
 short __cdecl _fd_int(  float* _Px,   short _Xexp);

 short __cdecl _dscale(  double* _Px,   long _Lexp);
 short __cdecl _ldscale(  long double* _Px,   long _Lexp);
 short __cdecl _fdscale(  float* _Px,   long _Lexp);

 short __cdecl _dunscale(  short* _Pex,   double* _Px);
 short __cdecl _ldunscale(  short* _Pex,   long double* _Px);
 short __cdecl _fdunscale(  short* _Pex,   float* _Px);

   short __cdecl _dexp(  double* _Px,   double _Y,   long _Eoff);
   short __cdecl _ldexp(  long double* _Px,   long double _Y,   long _Eoff);
   short __cdecl _fdexp(  float* _Px,   float _Y,   long _Eoff);

   short __cdecl _dnorm(  unsigned short* _Ps);
   short __cdecl _fdnorm(  unsigned short* _Ps);

   double __cdecl _dpoly(  double _X,   double const* _Tab,   int _N);
   long double __cdecl _ldpoly(  long double _X,   long double const* _Tab,   int _N);
   float __cdecl _fdpoly(  float _X,   float const* _Tab,   int _N);

   double __cdecl _dlog(  double _X,   int _Baseflag);
   long double __cdecl _ldlog(  long double _X,   int _Baseflag);
   float __cdecl _fdlog(  float _X,   int _Baseflag);

   double __cdecl _dsin(  double _X,   unsigned int _Qoff);
   long double __cdecl _ldsin(  long double _X,   unsigned int _Qoff);
   float __cdecl _fdsin(  float _X,   unsigned int _Qoff);


typedef union
{   
    unsigned short _Sh[4];
    double _Val;
} _double_val;


typedef union
{   
    unsigned short _Sh[2];
    float _Val;
} _float_val;


typedef union
{   
    unsigned short _Sh[4];
    long double _Val;
} _ldouble_val;

typedef union
{   
    unsigned short _Word[4];
    float _Float;
    double _Double;
    long double _Long_double;
} _float_const;

extern const _float_const _Denorm_C,  _Inf_C,  _Nan_C,  _Snan_C, _Hugeval_C;
extern const _float_const _FDenorm_C, _FInf_C, _FNan_C, _FSnan_C;
extern const _float_const _LDenorm_C, _LInf_C, _LNan_C, _LSnan_C;

extern const _float_const _Eps_C,  _Rteps_C;
extern const _float_const _FEps_C, _FRteps_C;
extern const _float_const _LEps_C, _LRteps_C;

extern const double      _Zero_C,  _Xbig_C;
extern const float       _FZero_C, _FXbig_C;
extern const long double _LZero_C, _LXbig_C;


extern "C++"
{
      inline int fpclassify(  float _X) throw()
    {
        return _fdtest(&_X);
    }

      inline int fpclassify(  double _X) throw()
    {
        return _dtest(&_X);
    }

      inline int fpclassify(  long double _X) throw()
    {
        return _ldtest(&_X);
    }

      inline bool signbit(  float _X) throw()
    {
        return _fdsign(_X) != 0;
    }

      inline bool signbit(  double _X) throw()
    {
        return _dsign(_X) != 0;
    }

      inline bool signbit(  long double _X) throw()
    {
        return _ldsign(_X) != 0;
    }

      inline int _fpcomp(  float _X,   float _Y) throw()
    {
        return _fdpcomp(_X, _Y);
    }

      inline int _fpcomp(  double _X,   double _Y) throw()
    {
        return _dpcomp(_X, _Y);
    }

      inline int _fpcomp(  long double _X,   long double _Y) throw()
    {
        return _ldpcomp(_X, _Y);
    }

    template <class _Trc, class _Tre> struct _Combined_type
    {   
        typedef float _Type;
    };

    template <> struct _Combined_type<float, double>
    {   
        typedef double _Type;
    };

    template <> struct _Combined_type<float, long double>
    {   
        typedef long double _Type;
    };

    template <class _Ty, class _T2> struct _Real_widened
    {   
        typedef long double _Type;
    };

    template <> struct _Real_widened<float, float>
    {   
        typedef float _Type;
    };

    template <> struct _Real_widened<float, double>
    {   
        typedef double _Type;
    };

    template <> struct _Real_widened<double, float>
    {   
        typedef double _Type;
    };

    template <> struct _Real_widened<double, double>
    {   
        typedef double _Type;
    };

    template <class _Ty> struct _Real_type
    {   
        typedef double _Type;   
    };

    template <> struct _Real_type<float>
    {   
        typedef float _Type;
    };

    template <> struct _Real_type<long double>
    {   
        typedef long double _Type;
    };

    template <class _T1, class _T2>
      inline int _fpcomp(  _T1 _X,   _T2 _Y) throw()
    {   
        typedef typename _Combined_type<float,
            typename _Real_widened<
            typename _Real_type<_T1>::_Type,
            typename _Real_type<_T2>::_Type>::_Type>::_Type _Tw;
        return _fpcomp((_Tw)_X, (_Tw)_Y);
    }

    template <class _Ty>
      inline bool isfinite(  _Ty _X) throw()
    {
        return fpclassify(_X) <= 0;
    }

    template <class _Ty>
      inline bool isinf(  _Ty _X) throw()
    {
        return fpclassify(_X) == 1;
    }

    template <class _Ty>
      inline bool isnan(  _Ty _X) throw()
    {
        return fpclassify(_X) == 2;
    }

    template <class _Ty>
      inline bool isnormal(  _Ty _X) throw()
    {
        return fpclassify(_X) == (-1);
    }

    template <class _Ty1, class _Ty2>
      inline bool isgreater(  _Ty1 _X,   _Ty2 _Y) throw()
    {
        return (_fpcomp(_X, _Y) & 4) != 0;
    }

    template <class _Ty1, class _Ty2>
      inline bool isgreaterequal(  _Ty1 _X,   _Ty2 _Y) throw()
    {
        return (_fpcomp(_X, _Y) & (2 | 4)) != 0;
    }

    template <class _Ty1, class _Ty2>
      inline bool isless(  _Ty1 _X,   _Ty2 _Y) throw()
    {
        return (_fpcomp(_X, _Y) & 1) != 0;
    }

    template <class _Ty1, class _Ty2>
      inline bool islessequal(  _Ty1 _X,   _Ty2 _Y) throw()
    {
        return (_fpcomp(_X, _Y) & (1 | 2)) != 0;
    }

    template <class _Ty1, class _Ty2>
      inline bool islessgreater(  _Ty1 _X,   _Ty2 _Y) throw()
    {
        return (_fpcomp(_X, _Y) & (1 | 4)) != 0;
    }

    template <class _Ty1, class _Ty2>
      inline bool isunordered(  _Ty1 _X,   _Ty2 _Y) throw()
    {
        return _fpcomp(_X, _Y) == 0;
    }
}  
#line 459 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_math.h"


      int       __cdecl abs(  int _X);
      long      __cdecl labs(  long _X);
      long long __cdecl llabs(  long long _X);

      double __cdecl acos(  double _X);
      double __cdecl asin(  double _X);
      double __cdecl atan(  double _X);
      double __cdecl atan2(  double _Y,   double _X);

      double __cdecl cos(  double _X);
      double __cdecl cosh(  double _X);
      double __cdecl exp(  double _X);
       double __cdecl fabs(  double _X);
      double __cdecl fmod(  double _X,   double _Y);
      double __cdecl log(  double _X);
      double __cdecl log10(  double _X);
      double __cdecl pow(  double _X,   double _Y);
      double __cdecl sin(  double _X);
      double __cdecl sinh(  double _X);
       double __cdecl sqrt(  double _X);
      double __cdecl tan(  double _X);
      double __cdecl tanh(  double _X);

       double    __cdecl acosh(  double _X);
       double    __cdecl asinh(  double _X);
       double    __cdecl atanh(  double _X);
        double    __cdecl atof(  char const* _String);
        double    __cdecl _atof_l(  char const* _String,   _locale_t _Locale);
       double    __cdecl _cabs(  struct _complex _Complex_value);
       double    __cdecl cbrt(  double _X);
       double    __cdecl ceil(  double _X);
       double    __cdecl _chgsign(  double _X);
       double    __cdecl copysign(  double _Number,   double _Sign);
       double    __cdecl _copysign(  double _Number,   double _Sign);
       double    __cdecl erf(  double _X);
       double    __cdecl erfc(  double _X);
       double    __cdecl exp2(  double _X);
       double    __cdecl expm1(  double _X);
       double    __cdecl fdim(  double _X,   double _Y);
       double    __cdecl floor(  double _X);
       double    __cdecl fma(  double _X,   double _Y,   double _Z);
       double    __cdecl fmax(  double _X,   double _Y);
       double    __cdecl fmin(  double _X,   double _Y);
       double    __cdecl frexp(  double _X,   int* _Y);
       double    __cdecl hypot(  double _X,   double _Y);
       double    __cdecl _hypot(  double _X,   double _Y);
       int       __cdecl ilogb(  double _X);
       double    __cdecl ldexp(  double _X,   int _Y);
       double    __cdecl lgamma(  double _X);
       long long __cdecl llrint(  double _X);
       long long __cdecl llround(  double _X);
       double    __cdecl log1p(  double _X);
       double    __cdecl log2(  double _X);
       double    __cdecl logb(  double _X);
       long      __cdecl lrint(  double _X);
       long      __cdecl lround(  double _X);

    int __cdecl _matherr(  struct _exception* _Except);

       double __cdecl modf(  double _X,   double* _Y);
       double __cdecl nan(  char const* _X);
       double __cdecl nearbyint(  double _X);
       double __cdecl nextafter(  double _X,   double _Y);
       double __cdecl nexttoward(  double _X,   long double _Y);
       double __cdecl remainder(  double _X,   double _Y);
       double __cdecl remquo(  double _X,   double _Y,   int* _Z);
       double __cdecl rint(  double _X);
       double __cdecl round(  double _X);
       double __cdecl scalbln(  double _X,   long _Y);
       double __cdecl scalbn(  double _X,   int _Y);
       double __cdecl tgamma(  double _X);
       double __cdecl trunc(  double _X);
       double __cdecl _j0(  double _X );
       double __cdecl _j1(  double _X );
       double __cdecl _jn(int _X,   double _Y);
       double __cdecl _y0(  double _X);
       double __cdecl _y1(  double _X);
       double __cdecl _yn(  int _X,   double _Y);

       float     __cdecl acoshf(  float _X);
       float     __cdecl asinhf(  float _X);
       float     __cdecl atanhf(  float _X);
       float     __cdecl cbrtf(  float _X);
       float     __cdecl _chgsignf(  float _X);
       float     __cdecl copysignf(  float _Number,   float _Sign);
       float     __cdecl _copysignf(  float _Number,   float _Sign);
       float     __cdecl erff(  float _X);
       float     __cdecl erfcf(  float _X);
       float     __cdecl expm1f(  float _X);
       float     __cdecl exp2f(  float _X);
       float     __cdecl fdimf(  float _X,   float _Y);
       float     __cdecl fmaf(  float _X,   float _Y,   float _Z);
       float     __cdecl fmaxf(  float _X,   float _Y);
       float     __cdecl fminf(  float _X,   float _Y);
       float     __cdecl _hypotf(  float _X,   float _Y);
       int       __cdecl ilogbf(  float _X);
       float     __cdecl lgammaf(  float _X);
       long long __cdecl llrintf(  float _X);
       long long __cdecl llroundf(  float _X);
       float     __cdecl log1pf(  float _X);
       float     __cdecl log2f(  float _X);
       float     __cdecl logbf(  float _X);
       long      __cdecl lrintf(  float _X);
       long      __cdecl lroundf(  float _X);
       float     __cdecl nanf(  char const* _X);
       float     __cdecl nearbyintf(  float _X);
       float     __cdecl nextafterf(  float _X,   float _Y);
       float     __cdecl nexttowardf(  float _X,   long double _Y);
       float     __cdecl remainderf(  float _X,   float _Y);
       float     __cdecl remquof(  float _X,   float _Y,   int* _Z);
       float     __cdecl rintf(  float _X);
       float     __cdecl roundf(  float _X);
       float     __cdecl scalblnf(  float _X,   long _Y);
       float     __cdecl scalbnf(  float _X,   int _Y);
       float     __cdecl tgammaf(  float _X);
       float     __cdecl truncf(  float _X);

    
           int  __cdecl _set_SSE2_enable(  int _Flag);

    #line 586 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_math.h"

    
#line 599 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_math.h"


#line 604 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_math.h"


#line 619 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_math.h"

          __inline float __cdecl acosf(  float _X)
        {
            return (float)acos(_X);
        }

          __inline float __cdecl asinf(  float _X)
        {
            return (float)asin(_X);
        }

          __inline float __cdecl atan2f(  float _Y,   float _X)
        {
            return (float)atan2(_Y, _X);
        }

          __inline float __cdecl atanf(  float _X)
        {
            return (float)atan(_X);
        }

          __inline float __cdecl ceilf(  float _X)
        {
            return (float)ceil(_X);
        }

          __inline float __cdecl cosf(  float _X)
        {
            return (float)cos(_X);
        }

          __inline float __cdecl coshf(  float _X)
        {
            return (float)cosh(_X);
        }

          __inline float __cdecl expf(  float _X)
        {
            return (float)exp(_X);
        }

    #line 661 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_math.h"

    
#line 667 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_math.h"

          __inline float __cdecl fabsf(  float _X)
        {
            return (float)fabs(_X);
        }

    #line 674 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_math.h"

    
#line 681 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_math.h"

          __inline float __cdecl floorf(  float _X)
        {
            return (float)floor(_X);
        }

          __inline float __cdecl fmodf(  float _X,   float _Y)
        {
            return (float)fmod(_X, _Y);
        }

    #line 693 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_math.h"

      __inline float __cdecl frexpf(  float _X,   int *_Y)
    {
        return (float)frexp(_X, _Y);
    }

      __inline float __cdecl hypotf(  float _X,   float _Y)
    {
        return _hypotf(_X, _Y);
    }

      __inline float __cdecl ldexpf(  float _X,   int _Y)
    {
        return (float)ldexp(_X, _Y);
    }

    
#line 722 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_math.h"

          __inline float __cdecl log10f(  float _X)
        {
            return (float)log10(_X);
        }

          __inline float __cdecl logf(  float _X)
        {
            return (float)log(_X);
        }

          __inline float __cdecl modff(  float _X,   float* _Y)
        {
            double _F, _I;
            _F = modf(_X, &_I);
            *_Y = (float)_I;
            return (float)_F;
        }

          __inline float __cdecl powf(  float _X,   float _Y)
        {
            return (float)pow(_X, _Y);
        }

          __inline float __cdecl sinf(  float _X)
        {
            return (float)sin(_X);
        }

          __inline float __cdecl sinhf(  float _X)
        {
            return (float)sinh(_X);
        }

          __inline float __cdecl sqrtf(  float _X)
        {
            return (float)sqrt(_X);
        }

          __inline float __cdecl tanf(  float _X)
        {
            return (float)tan(_X);
        }

          __inline float __cdecl tanhf(  float _X)
        {
            return (float)tanh(_X);
        }

    #line 772 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_math.h"

       long double __cdecl acoshl(  long double _X);

      __inline long double __cdecl acosl(  long double _X)
    {
        return acos((double)_X);
    }

       long double __cdecl asinhl(  long double _X);

      __inline long double __cdecl asinl(  long double _X)
    {
        return asin((double)_X);
    }

      __inline long double __cdecl atan2l(  long double _Y,   long double _X)
    {
        return atan2((double)_Y, (double)_X);
    }

       long double __cdecl atanhl(  long double _X);

      __inline long double __cdecl atanl(  long double _X)
    {
        return atan((double)_X);
    }

       long double __cdecl cbrtl(  long double _X);

      __inline long double __cdecl ceill(  long double _X)
    {
        return ceil((double)_X);
    }

      __inline long double __cdecl _chgsignl(  long double _X)
    {
        return _chgsign((double)_X);
    }

       long double __cdecl copysignl(  long double _Number,   long double _Sign);

      __inline long double __cdecl _copysignl(  long double _Number,   long double _Sign)
    {
        return _copysign((double)_Number, (double)_Sign);
    }

      __inline long double __cdecl coshl(  long double _X)
    {
        return cosh((double)_X);
    }

      __inline long double __cdecl cosl(  long double _X)
    {
        return cos((double)_X);
    }

       long double __cdecl erfl(  long double _X);
       long double __cdecl erfcl(  long double _X);

      __inline long double __cdecl expl(  long double _X)
    {
        return exp((double)_X);
    }

       long double __cdecl exp2l(  long double _X);
       long double __cdecl expm1l(  long double _X);

      __inline long double __cdecl fabsl(  long double _X)
    {
        return fabs((double)_X);
    }

       long double __cdecl fdiml(  long double _X,   long double _Y);

      __inline long double __cdecl floorl(  long double _X)
    {
        return floor((double)_X);
    }

       long double __cdecl fmal(  long double _X,   long double _Y,   long double _Z);
       long double __cdecl fmaxl(  long double _X,   long double _Y);
       long double __cdecl fminl(  long double _X,   long double _Y);

      __inline long double __cdecl fmodl(  long double _X,   long double _Y)
    {
        return fmod((double)_X, (double)_Y);
    }

      __inline long double __cdecl frexpl(  long double _X,   int *_Y)
    {
        return frexp((double)_X, _Y);
    }

       int __cdecl ilogbl(  long double _X);

      __inline long double __cdecl _hypotl(  long double _X,   long double _Y)
    {
        return _hypot((double)_X, (double)_Y);
    }

      __inline long double __cdecl hypotl(  long double _X,   long double _Y)
    {
        return _hypot((double)_X, (double)_Y);
    }

      __inline long double __cdecl ldexpl(  long double _X,   int _Y)
    {
        return ldexp((double)_X, _Y);
    }

       long double __cdecl lgammal(  long double _X);
       long long __cdecl llrintl(  long double _X);
       long long __cdecl llroundl(  long double _X);

      __inline long double __cdecl logl(  long double _X)
    {
        return log((double)_X);
    }

      __inline long double __cdecl log10l(  long double _X)
    {
        return log10((double)_X);
    }

       long double __cdecl log1pl(  long double _X);
       long double __cdecl log2l(  long double _X);
       long double __cdecl logbl(  long double _X);
       long __cdecl lrintl(  long double _X);
       long __cdecl lroundl(  long double _X);

      __inline long double __cdecl modfl(  long double _X,   long double* _Y)
    {
        double _F, _I;
        _F = modf((double)_X, &_I);
        *_Y = _I;
        return _F;
    }

       long double __cdecl nanl(  char const* _X);
       long double __cdecl nearbyintl(  long double _X);
       long double __cdecl nextafterl(  long double _X,   long double _Y);
       long double __cdecl nexttowardl(  long double _X,   long double _Y);

      __inline long double __cdecl powl(  long double _X,   long double _Y)
    {
        return pow((double)_X, (double)_Y);
    }

       long double __cdecl remainderl(  long double _X,   long double _Y);
       long double __cdecl remquol(  long double _X,   long double _Y,   int* _Z);
       long double __cdecl rintl(  long double _X);
       long double __cdecl roundl(  long double _X);
       long double __cdecl scalblnl(  long double _X,   long _Y);
       long double __cdecl scalbnl(  long double _X,   int _Y);

      __inline long double __cdecl sinhl(  long double _X)
    {
        return sinh((double)_X);
    }

      __inline long double __cdecl sinl(  long double _X)
    {
        return sin((double)_X);
    }

      __inline long double __cdecl sqrtl(  long double _X)
    {
        return sqrt((double)_X);
    }

      __inline long double __cdecl tanhl(  long double _X)
    {
        return tanh((double)_X);
    }

      __inline long double __cdecl tanl(  long double _X)
    {
        return tan((double)_X);
    }

       long double __cdecl tgammal(  long double _X);
       long double __cdecl truncl(  long double _X);

    
#line 960 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_math.h"


            extern double HUGE;
        

#line 978 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_math.h"

        __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_j0" ". See online help for details."))    double __cdecl j0(  double _X);
        __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_j1" ". See online help for details."))    double __cdecl j1(  double _X);
        __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_jn" ". See online help for details."))    double __cdecl jn(  int _X,   double _Y);
        __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_y0" ". See online help for details."))    double __cdecl y0(  double _X);
        __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_y1" ". See online help for details."))    double __cdecl y1(  double _X);
        __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_yn" ". See online help for details."))    double __cdecl yn(  int _X,   double _Y);
    #line 986 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_math.h"

#line 988 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_math.h"

} __pragma(pack(pop))

#pragma warning(pop) 
#line 993 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_math.h"
#line 12 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\math.h"


#line 13 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cstdlib"
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"


#pragma once


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_malloc.h"


#pragma once


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


#line 56 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_malloc.h"

     
 __declspec(allocator) __declspec(restrict)
void* __cdecl _calloc_base(
      size_t _Count,
      size_t _Size
    );

     
  __declspec(allocator) __declspec(restrict) 
void* __cdecl calloc(
       size_t _Count,
       size_t _Size
    );

 
 int __cdecl _callnewh(
      size_t _Size
    );

     
 __declspec(allocator) 
void* __cdecl _expand(
                void*  _Block,
       size_t _Size
    );


void __cdecl _free_base(
        void* _Block
    );

 
void __cdecl free(
        void* _Block
    );

     
 __declspec(allocator) __declspec(restrict)
void* __cdecl _malloc_base(
      size_t _Size
    );

     
 __declspec(allocator)  __declspec(restrict) 
void* __cdecl malloc(
       size_t _Size
    );

 
size_t __cdecl _msize_base(
      void* _Block
    );

 
size_t __cdecl _msize(
      void* _Block
    );

       
 __declspec(allocator) __declspec(restrict)
void* __cdecl _realloc_base(
         void*  _Block,
                                 size_t _Size
    );

       
 __declspec(allocator) __declspec(restrict) 
void* __cdecl realloc(
        void*  _Block,
              size_t _Size
    );

       
 __declspec(allocator) __declspec(restrict)
void* __cdecl _recalloc_base(
        void*  _Block,
                                size_t _Count,
                                size_t _Size
    );

       
 __declspec(allocator) __declspec(restrict)
void* __cdecl _recalloc(
        void*  _Block,
              size_t _Count,
              size_t _Size
    );


void __cdecl _aligned_free(
        void* _Block
    );

     
 __declspec(allocator) __declspec(restrict)
void* __cdecl _aligned_malloc(
       size_t _Size,
                         size_t _Alignment
    );

     
 __declspec(allocator) __declspec(restrict)
void* __cdecl _aligned_offset_malloc(
       size_t _Size,
                         size_t _Alignment,
                         size_t _Offset
    );

 
size_t __cdecl _aligned_msize(
      void*  _Block,
               size_t _Alignment,
               size_t _Offset
    );

       
 __declspec(allocator) __declspec(restrict)
void* __cdecl _aligned_offset_realloc(
        void*  _Block,
              size_t _Size,
                                size_t _Alignment,
                                size_t _Offset
    );

       
 __declspec(allocator) __declspec(restrict)
void* __cdecl _aligned_offset_recalloc(
        void*  _Block,
              size_t _Count,
              size_t _Size,
                                size_t _Alignment,
                                size_t _Offset
    );

       
 __declspec(allocator) __declspec(restrict)
void* __cdecl _aligned_realloc(
        void*  _Block,
              size_t _Size,
                                size_t _Alignment
    );

       
 __declspec(allocator) __declspec(restrict)
void* __cdecl _aligned_recalloc(
        void*  _Block,
              size_t _Count,
              size_t _Size,
                                size_t _Alignment
    );


#line 229 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_malloc.h"


} __pragma(pack(pop))

#pragma warning(pop) 
#line 14 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_search.h"


#pragma once


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


    typedef int (__cdecl* _CoreCrtSecureSearchSortCompareFunction)(void*, void const*, void const*);
    typedef int (__cdecl* _CoreCrtNonSecureSearchSortCompareFunction)(void const*, void const*);


     void* __cdecl bsearch_s(
                                                        void const* _Key,
          void const* _Base,
                                                        rsize_t     _NumOfElements,
                                                        rsize_t     _SizeOfElements,
                            _CoreCrtSecureSearchSortCompareFunction _CompareFunction,
                                                    void*       _Context
        );

     void __cdecl qsort_s(
          void*   _Base,
                                                             rsize_t _NumOfElements,
                                                             rsize_t _SizeOfElements,
                             _CoreCrtSecureSearchSortCompareFunction _CompareFunction,
                                                         void*   _Context
        );

#line 48 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_search.h"


 void* __cdecl bsearch(
                                                    void const* _Key,
      void const* _Base,
                                                    size_t      _NumOfElements,
                                                    size_t      _SizeOfElements,
                     _CoreCrtNonSecureSearchSortCompareFunction _CompareFunction
    );

 void __cdecl qsort(
      void*  _Base,
                                                         size_t _NumOfElements,
                                                         size_t _SizeOfElements,
                     _CoreCrtNonSecureSearchSortCompareFunction _CompareFunction
    );

 
 void* __cdecl _lfind_s(
                                                       void const*   _Key,
      void const*   _Base,
                                                    unsigned int* _NumOfElements,
                                                       size_t        _SizeOfElements,
                             _CoreCrtSecureSearchSortCompareFunction _CompareFunction,
                                                       void*         _Context
    );

 
 void* __cdecl _lfind(
                                                       void const*   _Key,
      void const*   _Base,
                                                    unsigned int* _NumOfElements,
                                                       unsigned int  _SizeOfElements,
                          _CoreCrtNonSecureSearchSortCompareFunction _CompareFunction
    );

 
 void* __cdecl _lsearch_s(
                                                             void const*   _Key,
      void*         _Base,
                                                          unsigned int* _NumOfElements,
                                                             size_t        _SizeOfElements,
                                   _CoreCrtSecureSearchSortCompareFunction _CompareFunction,
                                                             void*         _Context
    );

 
 void* __cdecl _lsearch(
                                                             void const*   _Key,
      void*         _Base,
                                                          unsigned int* _NumOfElements,
                                                             unsigned int  _SizeOfElements,
                                _CoreCrtNonSecureSearchSortCompareFunction _CompareFunction
    );


#line 189 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_search.h"


      __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_lfind" ". See online help for details."))
     void* __cdecl lfind(
                                                           void const*   _Key,
          void const*   _Base,
                                                        unsigned int* _NumOfElements,
                                                           unsigned int  _SizeOfElements,
                              _CoreCrtNonSecureSearchSortCompareFunction _CompareFunction
        );

      __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_lsearch" ". See online help for details."))
     void* __cdecl lsearch(
                                                                void const*   _Key,
          void*         _Base,
                                                             unsigned int* _NumOfElements,
                                                                unsigned int  _SizeOfElements,
                                   _CoreCrtNonSecureSearchSortCompareFunction _CompareFunction
        );

#line 213 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_search.h"


} __pragma(pack(pop))

#pragma warning(pop) 
#line 15 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdlib.h"


#pragma once


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


     errno_t __cdecl _itow_s(
                                  int      _Value,
          wchar_t* _Buffer,
                                  size_t   _BufferCount,
                                  int      _Radix
        );

    extern "C++" { template <size_t _Size> inline errno_t __cdecl _itow_s(  int _Value, wchar_t (&_Buffer)[_Size],   int _Radix) throw() { return _itow_s(_Value, _Buffer, _Size, _Radix); } }
#line 67 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdlib.h"

    __declspec(deprecated("This function or variable may be unsafe. Consider using " "_itow_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  wchar_t* __cdecl _itow( int _Value,   wchar_t *_Buffer,  int _Radix);
#line 74 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdlib.h"

     
     errno_t __cdecl _ltow_s(
                                  long     _Value,
          wchar_t* _Buffer,
                                  size_t   _BufferCount,
                                  int      _Radix
        );

    extern "C++" { template <size_t _Size> inline errno_t __cdecl _ltow_s(  long _Value, wchar_t (&_Buffer)[_Size],   int _Radix) throw() { return _ltow_s(_Value, _Buffer, _Size, _Radix); } }
#line 90 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdlib.h"

    __declspec(deprecated("This function or variable may be unsafe. Consider using " "_ltow_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  wchar_t* __cdecl _ltow( long _Value,   wchar_t *_Buffer,  int _Radix);
#line 97 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdlib.h"

    
     errno_t __cdecl _ultow_s(
                                  unsigned long _Value,
          wchar_t*      _Buffer,
                                  size_t        _BufferCount,
                                  int           _Radix
        );

    extern "C++" { template <size_t _Size> inline errno_t __cdecl _ultow_s(  unsigned long _Value, wchar_t (&_Buffer)[_Size],   int _Radix) throw() { return _ultow_s(_Value, _Buffer, _Size, _Radix); } }
#line 112 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdlib.h"

    __declspec(deprecated("This function or variable may be unsafe. Consider using " "_ultow_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  wchar_t* __cdecl _ultow( unsigned long _Value,   wchar_t *_Buffer,  int _Radix);
#line 119 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdlib.h"

     
     double __cdecl wcstod(
                            wchar_t const* _String,
            wchar_t**      _EndPtr
        );

     
     double __cdecl _wcstod_l(
                            wchar_t const* _String,
            wchar_t**      _EndPtr,
                          _locale_t      _Locale
        );

     
     long __cdecl wcstol(
                            wchar_t const* _String,
            wchar_t**      _EndPtr,
                              int            _Radix
        );

     
     long __cdecl _wcstol_l(
                            wchar_t const* _String,
            wchar_t**      _EndPtr,
                              int            _Radix,
                          _locale_t      _Locale
        );

     
     long long __cdecl wcstoll(
                            wchar_t const* _String,
            wchar_t**      _EndPtr,
                              int            _Radix
        );

     
     long long __cdecl _wcstoll_l(
                            wchar_t const* _String,
            wchar_t**      _EndPtr,
                              int            _Radix,
                          _locale_t      _Locale
        );

     
     unsigned long __cdecl wcstoul(
                            wchar_t const* _String,
            wchar_t**      _EndPtr,
                              int            _Radix
        );

     
     unsigned long __cdecl _wcstoul_l(
                            wchar_t const* _String,
            wchar_t**      _EndPtr,
                              int            _Radix,
                          _locale_t      _Locale
        );

     
     unsigned long long __cdecl wcstoull(
                            wchar_t const* _String,
            wchar_t**      _EndPtr,
                              int            _Radix
        );

     
     unsigned long long __cdecl _wcstoull_l(
                            wchar_t const* _String,
            wchar_t**      _EndPtr,
                              int            _Radix,
                          _locale_t      _Locale
        );

     
     long double __cdecl wcstold(
                            wchar_t const* _String,
            wchar_t**      _EndPtr
        );

     
     long double __cdecl _wcstold_l(
                            wchar_t const* _String,
            wchar_t**      _EndPtr,
                          _locale_t      _Locale
        );

     
     float __cdecl wcstof(
                            wchar_t const* _String,
            wchar_t**      _EndPtr
        );

     
     float __cdecl _wcstof_l(
                            wchar_t const* _String,
            wchar_t**      _EndPtr,
                          _locale_t      _Locale
        );

     
     double __cdecl _wtof(
          wchar_t const* _String
        );

     
     double __cdecl _wtof_l(
            wchar_t const* _String,
          _locale_t      _Locale
        );

     
     int __cdecl _wtoi(
          wchar_t const* _String
        );

     
     int __cdecl _wtoi_l(
            wchar_t const* _String,
          _locale_t      _Locale
        );

     
     long __cdecl _wtol(
          wchar_t const* _String
        );

     
     long __cdecl _wtol_l(
            wchar_t const* _String,
          _locale_t      _Locale
        );

     
     long long __cdecl _wtoll(
          wchar_t const* _String
        );

     
     long long __cdecl _wtoll_l(
            wchar_t const* _String,
          _locale_t      _Locale
        );

    
     errno_t __cdecl _i64tow_s(
                                  __int64  _Value,
          wchar_t* _Buffer,
                                  size_t   _BufferCount,
                                  int      _Radix
        );

    __declspec(deprecated("This function or variable may be unsafe. Consider using " "_i64tow_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
     wchar_t* __cdecl _i64tow(
                            __int64  _Value,
            wchar_t* _Buffer,
                            int      _Radix
        );

    
     errno_t __cdecl _ui64tow_s(
                                  unsigned __int64 _Value,
          wchar_t*         _Buffer,
                                  size_t           _BufferCount,
                                  int              _Radix
        );

    __declspec(deprecated("This function or variable may be unsafe. Consider using " "_ui64tow_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
     wchar_t* __cdecl _ui64tow(
                            unsigned __int64 _Value,
            wchar_t*         _Buffer,
                            int              _Radix
        );

     
     __int64 __cdecl _wtoi64(
          wchar_t const* _String
        );

     
     __int64 __cdecl _wtoi64_l(
            wchar_t const* _String,
          _locale_t      _Locale
        );

     
     __int64 __cdecl _wcstoi64(
                            wchar_t const* _String,
            wchar_t**      _EndPtr,
                              int            _Radix
        );

     
     __int64 __cdecl _wcstoi64_l(
                            wchar_t const* _String,
            wchar_t**      _EndPtr,
                              int            _Radix,
                          _locale_t      _Locale
        );

     
     unsigned __int64 __cdecl _wcstoui64(
                            wchar_t const* _String,
            wchar_t**      _EndPtr,
                              int            _Radix
        );

     
     unsigned __int64 __cdecl _wcstoui64_l(
                            wchar_t const* _String,
            wchar_t**      _EndPtr,
                              int            _Radix,
                          _locale_t      _Locale
        );

    
     __declspec(allocator) wchar_t* __cdecl _wfullpath(
          wchar_t*       _Buffer,
                                    wchar_t const* _Path,
                                      size_t         _BufferCount
        );

    
     errno_t __cdecl _wmakepath_s(
          wchar_t*       _Buffer,
                                  size_t         _BufferCount,
                            wchar_t const* _Drive,
                            wchar_t const* _Dir,
                            wchar_t const* _Filename,
                            wchar_t const* _Ext
        );

    extern "C++" { template <size_t _Size> inline errno_t __cdecl _wmakepath_s(wchar_t (&_Buffer)[_Size],   wchar_t const* _Drive,   wchar_t const* _Dir,   wchar_t const* _Filename,   wchar_t const* _Ext) throw() { return _wmakepath_s(_Buffer, _Size, _Drive, _Dir, _Filename, _Ext); } }
#line 365 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdlib.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wmakepath_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  void __cdecl _wmakepath(  wchar_t *_Buffer,  wchar_t const* _Drive,  wchar_t const* _Dir,  wchar_t const* _Filename,  wchar_t const* _Ext);
#line 374 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdlib.h"

     void __cdecl _wperror(
          wchar_t const* _ErrorMessage
        );

    __declspec(deprecated("This function or variable may be unsafe. Consider using " "_wsplitpath_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
     void __cdecl _wsplitpath(
                            wchar_t const* _FullPath,
            wchar_t*       _Drive,
            wchar_t*       _Dir,
            wchar_t*       _Filename,
            wchar_t*       _Ext
        );

     errno_t __cdecl _wsplitpath_s(
                                      wchar_t const* _FullPath,
             wchar_t*       _Drive,
                                        size_t         _DriveCount,
               wchar_t*       _Dir,
                                        size_t         _DirCount,
          wchar_t*       _Filename,
                                        size_t         _FilenameCount,
               wchar_t*       _Ext,
                                        size_t         _ExtCount
        );

    extern "C++" { template <size_t _DriveSize, size_t _DirSize, size_t _NameSize, size_t _ExtSize> inline errno_t __cdecl _wsplitpath_s(   wchar_t const* _Path,   wchar_t (&_Drive)[_DriveSize],   wchar_t (&_Dir)[_DirSize],   wchar_t (&_Name)[_NameSize],   wchar_t (&_Ext)[_ExtSize] ) throw() { return _wsplitpath_s(_Path, _Drive, _DriveSize, _Dir, _DirSize, _Name, _NameSize, _Ext, _ExtSize); } }
#line 404 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdlib.h"

        
         errno_t __cdecl _wdupenv_s(
                wchar_t**      _Buffer,
                                                                                size_t*        _BufferCount,
                                                                                   wchar_t const* _VarName
            );

        
          __declspec(deprecated("This function or variable may be unsafe. Consider using " "_wdupenv_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
         wchar_t* __cdecl _wgetenv(
              wchar_t const* _VarName
            );

         
         errno_t __cdecl _wgetenv_s(
                                         size_t*        _RequiredCount,
              wchar_t*       _Buffer,
                                          size_t         _BufferCount,
                                        wchar_t const* _VarName
            );

        extern "C++" { template <size_t _Size> inline   errno_t __cdecl _wgetenv_s(  size_t* _RequiredCount, wchar_t (&_Buffer)[_Size],   wchar_t const* _VarName) throw() { return _wgetenv_s(_RequiredCount, _Buffer, _Size, _VarName); } }
#line 438 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdlib.h"

         
         int __cdecl _wputenv(
              wchar_t const* _EnvString
            );

        
         errno_t __cdecl _wputenv_s(
              wchar_t const* _Name,
              wchar_t const* _Value
            );

         errno_t __cdecl _wsearchenv_s(
                                    wchar_t const* _Filename,
                                    wchar_t const* _VarName,
              wchar_t*       _Buffer,
                                      size_t         _BufferCount
            );

        extern "C++" { template <size_t _Size> inline errno_t __cdecl _wsearchenv_s(  wchar_t const* _Filename,   wchar_t const* _VarName, wchar_t (&_ResultPath)[_Size]) throw() { return _wsearchenv_s(_Filename, _VarName, _ResultPath, _Size); } }
#line 463 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdlib.h"

        __declspec(deprecated("This function or variable may be unsafe. Consider using " "_wsearchenv_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  void __cdecl _wsearchenv( wchar_t const* _Filename,  wchar_t const* _VarName,   wchar_t *_ResultPath);
#line 470 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdlib.h"

         int __cdecl _wsystem(
              wchar_t const* _Command
            );

#line 476 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdlib.h"


} __pragma(pack(pop))

#pragma warning(pop) 
#line 16 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits.h"


#pragma once


#pragma warning(push)
#pragma warning(disable:   4514 4820 )

__pragma(pack(push, 8)) extern "C" {


#line 30 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits.h"


    #line 74 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits.h"
#line 75 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits.h"

} __pragma(pack(pop))

#pragma warning(pop) 
#line 17 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"

#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


#line 29 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"


 void __cdecl _swab(
        char* _Buf1,
        char* _Buf2,
                                                                  int   _SizeInBytes
    );


     __declspec(noreturn) void __cdecl exit(  int _Code);
     __declspec(noreturn) void __cdecl _exit(  int _Code);
     __declspec(noreturn) void __cdecl _Exit(  int _Code);
     __declspec(noreturn) void __cdecl quick_exit(  int _Code);
     __declspec(noreturn) void __cdecl abort(void);
#line 62 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"


 unsigned int __cdecl _set_abort_behavior(
      unsigned int _Flags,
      unsigned int _Mask
    );


    typedef int (__cdecl* _onexit_t)(void);
    

#line 82 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"


#line 87 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"


    int       __cdecl atexit(void (__cdecl*)(void));
    _onexit_t __cdecl _onexit(  _onexit_t _Func);
#line 147 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"

int __cdecl at_quick_exit(void (__cdecl*)(void));


    typedef void (__cdecl* _purecall_handler)(void);

    
    typedef void (__cdecl* _invalid_parameter_handler)(
        wchar_t const*,
        wchar_t const*,
        wchar_t const*,
        unsigned int,
        uintptr_t
        );

    
     _purecall_handler __cdecl _set_purecall_handler(
          _purecall_handler _Handler
        );

     _purecall_handler __cdecl _get_purecall_handler(void);

    
     _invalid_parameter_handler __cdecl _set_invalid_parameter_handler(
          _invalid_parameter_handler _Handler
        );

     _invalid_parameter_handler __cdecl _get_invalid_parameter_handler(void);

     _invalid_parameter_handler __cdecl _set_thread_local_invalid_parameter_handler(
          _invalid_parameter_handler _Handler
        );

     _invalid_parameter_handler __cdecl _get_thread_local_invalid_parameter_handler(void);
#line 190 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"


#line 203 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"


  int __cdecl _set_error_mode(  int _Mode);


     int* __cdecl _errno(void);
    

     errno_t __cdecl _set_errno(  int _Value);
     errno_t __cdecl _get_errno(  int* _Value);

     unsigned long* __cdecl __doserrno(void);
    

     errno_t __cdecl _set_doserrno(  unsigned long _Value);
     errno_t __cdecl _get_doserrno(  unsigned long * _Value);

    
     __declspec(deprecated("This function or variable may be unsafe. Consider using " "strerror" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) char** __cdecl __sys_errlist(void);
    

     __declspec(deprecated("This function or variable may be unsafe. Consider using " "strerror" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) int * __cdecl __sys_nerr(void);
    

     void __cdecl perror(  char const* _ErrMsg);
#line 238 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"


__declspec(deprecated("This function or variable may be unsafe. Consider using " "_get_pgmptr" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  char**    __cdecl __p__pgmptr (void);
__declspec(deprecated("This function or variable may be unsafe. Consider using " "_get_wpgmptr" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  wchar_t** __cdecl __p__wpgmptr(void);
__declspec(deprecated("This function or variable may be unsafe. Consider using " "_get_fmode" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  int*      __cdecl __p__fmode  (void);


#line 257 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"

 
 errno_t __cdecl _get_pgmptr (  char**    _Value);

 
 errno_t __cdecl _get_wpgmptr(  wchar_t** _Value);

 errno_t __cdecl _set_fmode  (               int       _Mode );

 errno_t __cdecl _get_fmode  (              int*      _PMode);


typedef struct _div_t
{
    int quot;
    int rem;
} div_t;

typedef struct _ldiv_t
{
    long quot;
    long rem;
} ldiv_t;

typedef struct _lldiv_t
{
    long long quot;
    long long rem;
} lldiv_t;

  int       __cdecl abs   (  int       _Number);
  long      __cdecl labs  (  long      _Number);
  long long __cdecl llabs (  long long _Number);
  __int64   __cdecl _abs64(  __int64   _Number);

  unsigned short   __cdecl _byteswap_ushort(  unsigned short   _Number);
  unsigned long    __cdecl _byteswap_ulong (  unsigned long    _Number);
  unsigned __int64 __cdecl _byteswap_uint64(  unsigned __int64 _Number);

   div_t   __cdecl div  (  int       _Numerator,   int       _Denominator);
   ldiv_t  __cdecl ldiv (  long      _Numerator,   long      _Denominator);
   lldiv_t __cdecl lldiv(  long long _Numerator,   long long _Denominator);


#pragma warning(push)
#pragma warning(disable: 6540)

unsigned int __cdecl _rotl(
      unsigned int _Value,
      int          _Shift
    );

 
unsigned long __cdecl _lrotl(
      unsigned long _Value,
      int           _Shift
    );

unsigned __int64 __cdecl _rotl64(
      unsigned __int64 _Value,
      int              _Shift
    );

unsigned int __cdecl _rotr(
      unsigned int _Value,
      int          _Shift
    );

 
unsigned long __cdecl _lrotr(
      unsigned long _Value,
      int           _Shift
    );

unsigned __int64 __cdecl _rotr64(
      unsigned __int64 _Value,
      int              _Shift
    );

#pragma warning(pop)


 void __cdecl srand(  unsigned int _Seed);

   int __cdecl rand(void);


#line 357 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"


extern "C++"
{
    inline long abs(long const _X) throw()
    {
        return labs(_X);
    }

    inline long long abs(long long const _X) throw()
    {
        return llabs(_X);
    }

    inline ldiv_t div(long const _A1, long const _A2) throw()
    {
        return ldiv(_A1, _A2);
    }

    inline lldiv_t div(long long const _A1, long long const _A2) throw()
    {
        return lldiv(_A1, _A2);
    }
}
#line 384 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"


    #pragma pack(push, 4)
    typedef struct
    {
        unsigned char ld[10];
    } _LDOUBLE;
    #pragma pack(pop)

    
#line 414 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"

typedef struct
{
    double x;
} _CRT_DOUBLE;

typedef struct
{
    float f;
} _CRT_FLOAT;


typedef struct
{
    long double x;
} _LONGDOUBLE;


#pragma pack(push, 4)
typedef struct
{
    unsigned char ld12[12];
} _LDBL12;
#pragma pack(pop)


                      double    __cdecl atof   (  char const* _String);
    int       __cdecl atoi   (  char const* _String);
                      long      __cdecl atol   (  char const* _String);
                      long long __cdecl atoll  (  char const* _String);
                      __int64   __cdecl _atoi64(  char const* _String);

   double    __cdecl _atof_l  (  char const* _String,   _locale_t _Locale);
   int       __cdecl _atoi_l  (  char const* _String,   _locale_t _Locale);
   long      __cdecl _atol_l  (  char const* _String,   _locale_t _Locale);
   long long __cdecl _atoll_l (  char const* _String,   _locale_t _Locale);
   __int64   __cdecl _atoi64_l(  char const* _String,   _locale_t _Locale);

   int __cdecl _atoflt (  _CRT_FLOAT*  _Result,   char const* _String);
   int __cdecl _atodbl (  _CRT_DOUBLE* _Result,   char*       _String);
   int __cdecl _atoldbl(  _LDOUBLE*    _Result,   char*       _String);

 
 int __cdecl _atoflt_l(
         _CRT_FLOAT* _Result,
        char const* _String,
      _locale_t   _Locale
    );

 
 int __cdecl _atodbl_l(
         _CRT_DOUBLE* _Result,
        char*        _String,
      _locale_t    _Locale
    );


 int __cdecl _atoldbl_l(
         _LDOUBLE* _Result,
        char*     _String,
      _locale_t _Locale
    );

 
 float __cdecl strtof(
                        char const* _String,
        char**      _EndPtr
    );

 
 float __cdecl _strtof_l(
                        char const* _String,
        char**      _EndPtr,
                      _locale_t   _Locale
    );

 
 double __cdecl strtod(
                        char const* _String,
        char**      _EndPtr
    );

 
 double __cdecl _strtod_l(
                        char const* _String,
        char**      _EndPtr,
                      _locale_t   _Locale
    );

 
 long double __cdecl strtold(
                        char const* _String,
        char**      _EndPtr
    );

 
 long double __cdecl _strtold_l(
                        char const* _String,
        char**      _EndPtr,
                      _locale_t   _Locale
    );

 
 long __cdecl strtol(
                        char const* _String,
        char**      _EndPtr,
                          int         _Radix
    );

 
 long __cdecl _strtol_l(
                        char const* _String,
        char**      _EndPtr,
                          int         _Radix,
                      _locale_t   _Locale
    );

 
 long long __cdecl strtoll(
                        char const* _String,
        char**      _EndPtr,
                          int         _Radix
    );

 
 long long __cdecl _strtoll_l(
                        char const* _String,
        char**      _EndPtr,
                          int         _Radix,
                      _locale_t   _Locale
    );

 
 unsigned long __cdecl strtoul(
                        char const* _String,
        char**      _EndPtr,
                          int         _Radix
    );

 
 unsigned long __cdecl _strtoul_l(
                        char const* _String,
        char**      _EndPtr,
                          int         _Radix,
                      _locale_t   _Locale
    );

 
 unsigned long long __cdecl strtoull(
                        char const* _String,
        char**      _EndPtr,
                          int         _Radix
    );

 
 unsigned long long __cdecl _strtoull_l(
                        char const* _String,
        char**      _EndPtr,
                          int         _Radix,
                      _locale_t   _Locale
    );

 
 __int64 __cdecl _strtoi64(
                        char const* _String,
        char**      _EndPtr,
                          int         _Radix
    );

 
 __int64 __cdecl _strtoi64_l(
                        char const* _String,
        char**      _EndPtr,
                          int         _Radix,
                      _locale_t   _Locale
    );

 
 unsigned __int64 __cdecl _strtoui64(
                        char const* _String,
        char**      _EndPtr,
                          int         _Radix
    );

 
 unsigned __int64 __cdecl _strtoui64_l(
                        char const* _String,
        char**      _EndPtr,
                          int         _Radix,
                      _locale_t   _Locale
    );


 errno_t __cdecl _itoa_s(
                              int    _Value,
      char*  _Buffer,
                              size_t _BufferCount,
                              int    _Radix
    );

extern "C++" { template <size_t _Size> inline   errno_t __cdecl _itoa_s(  int _Value, char (&_Buffer)[_Size],   int _Radix) throw() { return _itoa_s(_Value, _Buffer, _Size, _Radix); } }
#line 640 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "_itoa_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  char* __cdecl _itoa( int _Value,   char *_Buffer,  int _Radix);
#line 647 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"

 
 errno_t __cdecl _ltoa_s(
                              long   _Value,
      char*  _Buffer,
                              size_t _BufferCount,
                              int    _Radix
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl _ltoa_s(  long _Value, char (&_Buffer)[_Size],   int _Radix) throw() { return _ltoa_s(_Value, _Buffer, _Size, _Radix); } }
#line 663 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "_ltoa_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  char* __cdecl _ltoa( long _Value,   char *_Buffer,  int _Radix);
#line 670 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"

 
 errno_t __cdecl _ultoa_s(
                              unsigned long _Value,
      char*         _Buffer,
                              size_t        _BufferCount,
                              int           _Radix
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl _ultoa_s(  unsigned long _Value, char (&_Buffer)[_Size],   int _Radix) throw() { return _ultoa_s(_Value, _Buffer, _Size, _Radix); } }
#line 686 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "_ultoa_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  char* __cdecl _ultoa( unsigned long _Value,   char *_Buffer,  int _Radix);
#line 693 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"

 
 errno_t __cdecl _i64toa_s(
                              __int64 _Value,
      char*   _Buffer,
                              size_t  _BufferCount,
                              int     _Radix
    );

 
__declspec(deprecated("This function or variable may be unsafe. Consider using " "_i64toa_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
 char* __cdecl _i64toa(
                        __int64 _Value,
        char*   _Buffer,
                        int     _Radix
    );

 
 errno_t __cdecl _ui64toa_s(
                              unsigned __int64 _Value,
      char*            _Buffer,
                              size_t           _BufferCount,
                              int              _Radix
    );

__declspec(deprecated("This function or variable may be unsafe. Consider using " "_ui64toa_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
 char* __cdecl _ui64toa(
                        unsigned __int64 _Value,
        char*            _Buffer,
                        int              _Radix
    );


 errno_t __cdecl _ecvt_s(
      char* _Buffer,
       size_t                       _BufferCount,
       double                       _Value,
       int                          _DigitCount,
      int*                         _PtDec,
      int*                         _PtSign
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl _ecvt_s(char (&_Buffer)[_Size],   double _Value,   int _DigitCount,   int* _PtDec,   int* _PtSign) throw() { return _ecvt_s(_Buffer, _Size, _Value, _DigitCount, _PtDec, _PtSign); } }
#line 758 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"

  __declspec(deprecated("This function or variable may be unsafe. Consider using " "_ecvt_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
 char* __cdecl _ecvt(
       double _Value,
       int    _DigitCount,
      int*   _PtDec,
      int*   _PtSign
    );

 
 errno_t __cdecl _fcvt_s(
      char*  _Buffer,
                              size_t _BufferCount,
                              double _Value,
                              int    _FractionalDigitCount,
                             int*   _PtDec,
                             int*   _PtSign
    );

extern "C++" { template <size_t _Size> inline   errno_t __cdecl _fcvt_s(char (&_Buffer)[_Size],   double _Value,   int _FractionalDigitCount,   int* _PtDec,   int* _PtSign) throw() { return _fcvt_s(_Buffer, _Size, _Value, _FractionalDigitCount, _PtDec, _PtSign); } }
#line 787 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"

 
  __declspec(deprecated("This function or variable may be unsafe. Consider using " "_fcvt_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
 char* __cdecl _fcvt(
       double _Value,
       int    _FractionalDigitCount,
      int*   _PtDec,
      int*   _PtSign
    );

 
 errno_t __cdecl _gcvt_s(
      char*  _Buffer,
                              size_t _BufferCount,
                              double _Value,
                              int    _DigitCount
    );

extern "C++" { template <size_t _Size> inline   errno_t __cdecl _gcvt_s(char (&_Buffer)[_Size],   double _Value,   int _DigitCount) throw() { return _gcvt_s(_Buffer, _Size, _Value, _DigitCount); } }
#line 812 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "_gcvt_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
 char* __cdecl _gcvt(
                        double _Value,
                        int    _DigitCount,
        char*  _Buffer
    );


#line 833 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"
        
    #line 835 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"

    
    #line 841 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"

     
     int __cdecl ___mb_cur_max_func(void);

     
     int __cdecl ___mb_cur_max_l_func(_locale_t _Locale);
#line 848 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"


 int __cdecl mblen(
        char const* _Ch,
                                             size_t      _MaxCount
    );

 
 int __cdecl _mblen_l(
        char const* _Ch,
                                             size_t      _MaxCount,
                                         _locale_t   _Locale
    );

 
 size_t __cdecl _mbstrlen(
      char const* _String
    );

 
 size_t __cdecl _mbstrlen_l(
        char const* _String,
      _locale_t   _Locale
    );

 
 size_t __cdecl _mbstrnlen(
      char const* _String,
        size_t      _MaxCount
    );

 
 size_t __cdecl _mbstrnlen_l(
        char const* _String,
          size_t      _MaxCount,
      _locale_t   _Locale
    );

 
 int __cdecl mbtowc(
                      wchar_t*    _DstCh,
      char const* _SrcCh,
                                      size_t      _SrcSizeInBytes
    );

 
 int __cdecl _mbtowc_l(
                      wchar_t*    _DstCh,
      char const* _SrcCh,
                                      size_t      _SrcSizeInBytes,
                                  _locale_t   _Locale
    );


 errno_t __cdecl mbstowcs_s(
                                                      size_t*     _PtNumOfCharConverted,
      wchar_t*    _DstBuf,
                                                           size_t      _SizeInWords,
                                     char const* _SrcBuf,
                                                           size_t      _MaxCount
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl mbstowcs_s(  size_t* _PtNumOfCharConverted,   wchar_t (&_Dest)[_Size],   char const* _Source,   size_t _MaxCount) throw() { return mbstowcs_s(_PtNumOfCharConverted, _Dest, _Size, _Source, _MaxCount); } }
#line 923 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "mbstowcs_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  size_t __cdecl mbstowcs( wchar_t *_Dest,  char const* _Source,  size_t _MaxCount);
#line 930 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"


 errno_t __cdecl _mbstowcs_s_l(
                                                      size_t*     _PtNumOfCharConverted,
      wchar_t*    _DstBuf,
                                                           size_t      _SizeInWords,
                                     char const* _SrcBuf,
                                                           size_t      _MaxCount,
                                                       _locale_t   _Locale
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl _mbstowcs_s_l(  size_t* _PtNumOfCharConverted,   wchar_t (&_Dest)[_Size],   char const* _Source,   size_t _MaxCount,   _locale_t _Locale) throw() { return _mbstowcs_s_l(_PtNumOfCharConverted, _Dest, _Size, _Source, _MaxCount, _Locale); } }
#line 949 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "_mbstowcs_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  size_t __cdecl _mbstowcs_l(  wchar_t *_Dest,   char const* _Source,   size_t _MaxCount,   _locale_t _Locale);
#line 958 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"


__declspec(deprecated("This function or variable may be unsafe. Consider using " "wctomb_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
 int __cdecl wctomb(
      char*   _MbCh,
                                wchar_t _WCh
    );

__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wctomb_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
 int __cdecl _wctomb_l(
        char*     _MbCh,
                          wchar_t   _WCh,
                      _locale_t _Locale
    );


     errno_t __cdecl wctomb_s(
                                                         int*    _SizeConverted,
          char*   _MbCh,
                                                              rsize_t _SizeInBytes,
                                                              wchar_t _WCh
        );

#line 986 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"


 errno_t __cdecl _wctomb_s_l(
                             int*     _SizeConverted,
      char*     _MbCh,
                                  size_t    _SizeInBytes,
                                  wchar_t   _WCh,
                              _locale_t _Locale);


 errno_t __cdecl wcstombs_s(
                                                               size_t*        _PtNumOfCharConverted,
      char*          _Dst,
                                                                    size_t         _DstSizeInBytes,
                                                                  wchar_t const* _Src,
                                                                    size_t         _MaxCountInBytes
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl wcstombs_s(  size_t* _PtNumOfCharConverted,   char (&_Dest)[_Size],   wchar_t const* _Source,   size_t _MaxCount) throw() { return wcstombs_s(_PtNumOfCharConverted, _Dest, _Size, _Source, _MaxCount); } }
#line 1011 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "wcstombs_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  size_t __cdecl wcstombs( char *_Dest,  wchar_t const* _Source,  size_t _MaxCount);
#line 1018 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"


 errno_t __cdecl _wcstombs_s_l(
                                                               size_t*        _PtNumOfCharConverted,
      char*          _Dst,
                                                                    size_t         _DstSizeInBytes,
                                                                  wchar_t const* _Src,
                                                                    size_t         _MaxCountInBytes,
                                                                _locale_t      _Locale
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl _wcstombs_s_l(  size_t* _PtNumOfCharConverted,   char (&_Dest)[_Size],   wchar_t const* _Source,   size_t _MaxCount,   _locale_t _Locale) throw() { return _wcstombs_s_l(_PtNumOfCharConverted, _Dest, _Size, _Source, _MaxCount, _Locale); } }
#line 1037 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wcstombs_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  size_t __cdecl _wcstombs_l(  char *_Dest,   wchar_t const* _Source,   size_t _MaxCount,   _locale_t _Locale);
#line 1046 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"


 __declspec(allocator) char* __cdecl _fullpath(
      char*       _Buffer,
                                char const* _Path,
                                  size_t      _BufferCount
    );


 errno_t __cdecl _makepath_s(
      char*       _Buffer,
                              size_t      _BufferCount,
                        char const* _Drive,
                        char const* _Dir,
                        char const* _Filename,
                        char const* _Ext
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl _makepath_s(char (&_Buffer)[_Size],   char const* _Drive,   char const* _Dir,   char const* _Filename,   char const* _Ext) throw() { return _makepath_s(_Buffer, _Size, _Drive, _Dir, _Filename, _Ext); } }
#line 1094 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "_makepath_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  void __cdecl _makepath(  char *_Buffer,  char const* _Drive,  char const* _Dir,  char const* _Filename,  char const* _Ext);
#line 1103 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "_splitpath_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
 void __cdecl _splitpath(
                        char const* _FullPath,
        char*       _Drive,
        char*       _Dir,
        char*       _Filename,
        char*       _Ext
    );


 errno_t __cdecl _splitpath_s(
                                  char const* _FullPath,
         char*       _Drive,
                                    size_t      _DriveCount,
           char*       _Dir,
                                    size_t      _DirCount,
      char*       _Filename,
                                    size_t      _FilenameCount,
           char*       _Ext,
                                    size_t      _ExtCount
    );

extern "C++" { template <size_t _DriveSize, size_t _DirSize, size_t _NameSize, size_t _ExtSize> inline errno_t __cdecl _splitpath_s(   char const* _Dest,   char (&_Drive)[_DriveSize],   char (&_Dir)[_DirSize],   char (&_Name)[_NameSize],   char (&_Ext)[_ExtSize] ) throw() { return _splitpath_s(_Dest, _Drive, _DriveSize, _Dir, _DirSize, _Name, _NameSize, _Ext, _ExtSize); } }


 errno_t __cdecl getenv_s(
                                 size_t*     _RequiredCount,
      char*       _Buffer,
                                  rsize_t     _BufferCount,
                                char const* _VarName
    );

#line 1140 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"


 int*       __cdecl __p___argc (void);
 char***    __cdecl __p___argv (void);
 wchar_t*** __cdecl __p___wargv(void);


#line 1157 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"

 char***    __cdecl __p__environ (void);
 wchar_t*** __cdecl __p__wenviron(void);


#line 1164 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"


#line 1174 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"


      __declspec(deprecated("This function or variable may be unsafe. Consider using " "_dupenv_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
     char* __cdecl getenv(
          char const* _VarName
        );

    extern "C++" { template <size_t _Size> inline errno_t __cdecl getenv_s(  size_t* _RequiredCount, char (&_Buffer)[_Size],   char const* _VarName) throw() { return getenv_s(_RequiredCount, _Buffer, _Size, _VarName); } }
#line 1194 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"

    
#line 1199 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"

    
     errno_t __cdecl _dupenv_s(
            char**      _Buffer,
                                                                            size_t*     _BufferCount,
                                                                               char const* _VarName
        );

    
#line 1210 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"

     int __cdecl system(
          char const* _Command
        );

    
    #pragma warning(push)
    #pragma warning(disable: 6540)

     
     int __cdecl _putenv(
          char const* _EnvString
        );

    
     errno_t __cdecl _putenv_s(
          char const* _Name,
          char const* _Value
        );

    #pragma warning(pop)

     errno_t __cdecl _searchenv_s(
                                char const* _Filename,
                                char const* _VarName,
          char*       _Buffer,
                                  size_t      _BufferCount
        );

    extern "C++" { template <size_t _Size> inline errno_t __cdecl _searchenv_s(  char const* _Filename,   char const* _VarName, char (&_Buffer)[_Size]) throw() { return _searchenv_s(_Filename, _VarName, _Buffer, _Size); } }
#line 1246 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"

    __declspec(deprecated("This function or variable may be unsafe. Consider using " "_searchenv_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  void __cdecl _searchenv( char const* _Filename,  char const* _VarName,   char *_Buffer);
#line 1253 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"

    
    __declspec(deprecated("This function or variable has been superceded by newer library " "or operating system functionality. Consider using " "SetErrorMode" " " "instead. See online help for details."))
     void __cdecl _seterrormode(
          int _Mode
        );

    __declspec(deprecated("This function or variable has been superceded by newer library " "or operating system functionality. Consider using " "Beep" " " "instead. See online help for details."))
     void __cdecl _beep(
          unsigned _Frequency,
          unsigned _Duration
        );

    __declspec(deprecated("This function or variable has been superceded by newer library " "or operating system functionality. Consider using " "Sleep" " " "instead. See online help for details."))
     void __cdecl _sleep(
          unsigned long _Duration
        );

#line 1272 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"


    #pragma warning(push)
    #pragma warning(disable: 4141) 

      __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_ecvt" ". See online help for details.")) __declspec(deprecated("This function or variable may be unsafe. Consider using " "_ecvt_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
     char* __cdecl ecvt(
           double _Value,
           int    _DigitCount,
          int*   _PtDec,
          int*   _PtSign
        );

      __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_fcvt" ". See online help for details.")) __declspec(deprecated("This function or variable may be unsafe. Consider using " "_fcvt_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
     char* __cdecl fcvt(
           double _Value,
           int    _FractionalDigitCount,
          int*   _PtDec,
          int*   _PtSign
        );

    __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_gcvt" ". See online help for details.")) __declspec(deprecated("This function or variable may be unsafe. Consider using " "_fcvt_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
     char* __cdecl gcvt(
                            double _Value,
                            int    _DigitCount,
            char*  _DstBuf
        );

    __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_itoa" ". See online help for details.")) __declspec(deprecated("This function or variable may be unsafe. Consider using " "_itoa_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
     char* __cdecl itoa(
                            int   _Value,
            char* _Buffer,
                            int   _Radix
        );

    __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_ltoa" ". See online help for details.")) __declspec(deprecated("This function or variable may be unsafe. Consider using " "_ltoa_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
     char* __cdecl ltoa(
                            long  _Value,
            char* _Buffer,
                            int   _Radix
        );


    __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_swab" ". See online help for details."))
     void __cdecl swab(
          char* _Buf1,
          char* _Buf2,
                                     int   _SizeInBytes
        );

    __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_ultoa" ". See online help for details.")) __declspec(deprecated("This function or variable may be unsafe. Consider using " "_ultoa_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
     char* __cdecl ultoa(
                            unsigned long _Value,
            char*         _Buffer,
                            int           _Radix
        );

    
      __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_putenv" ". See online help for details."))
     int __cdecl putenv(
          char const* _EnvString
        );

    #pragma warning(pop)

    _onexit_t __cdecl onexit(  _onexit_t _Func);

#line 1356 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"


} __pragma(pack(pop))

#pragma warning(pop) 
#line 1363 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdlib.h"
#line 14 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cstdlib"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


[[nodiscard]]   inline double abs(  double _Xx) noexcept  {
    return :: fabs(_Xx);
}

[[nodiscard]]   inline float abs(  float _Xx) noexcept  {
    return :: fabsf(_Xx);
}

[[nodiscard]]   inline long double abs(  long double _Xx) noexcept  {
    return :: fabsl(_Xx);
}

namespace std {
using :: size_t;
using :: div_t;
using :: ldiv_t;
using :: abort;
using :: abs;
using :: atexit;
using :: atof;
using :: atoi;
using :: atol;
using :: bsearch;
using :: calloc;
using :: div;
using :: exit;
using :: free;
using :: labs;
using :: ldiv;
using :: malloc;
using :: mblen;
using :: mbstowcs;
using :: mbtowc;
using :: qsort;
using :: rand;
using :: realloc;
using :: srand;
using :: strtod;
using :: strtol;
using :: strtoul;
using :: wcstombs;
using :: wctomb;

using :: lldiv_t;


using :: getenv;
using :: system;
#line 72 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cstdlib"

using :: atoll;
using :: llabs;
using :: lldiv;
using :: strtof;
using :: strtold;
using :: strtoll;
using :: strtoull;

using :: _Exit;
using :: at_quick_exit;
using :: quick_exit;
}


#pragma warning(pop)
#pragma pack(pop)

#line 92 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cstdlib"
#line 93 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cstdlib"
#line 13 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstddef"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\initializer_list"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
template <class _Elem>
class initializer_list {
public:
    using value_type      = _Elem;
    using reference       = const _Elem&;
    using const_reference = const _Elem&;
    using size_type       = size_t;

    using iterator       = const _Elem*;
    using const_iterator = const _Elem*;

    constexpr initializer_list() noexcept : _First(nullptr), _Last(nullptr) {}

    constexpr initializer_list(const _Elem* _First_arg, const _Elem* _Last_arg) noexcept
        : _First(_First_arg), _Last(_Last_arg) {}

    [[nodiscard]] constexpr const _Elem* begin() const noexcept {
        return _First;
    }

    [[nodiscard]] constexpr const _Elem* end() const noexcept {
        return _Last;
    }

    [[nodiscard]] constexpr size_t size() const noexcept {
        return static_cast<size_t>(_Last - _First);
    }

private:
    const _Elem* _First;
    const _Elem* _Last;
};

template <class _Elem>
[[nodiscard]] constexpr const _Elem* begin(initializer_list<_Elem> _Ilist) noexcept {
    return _Ilist.begin();
}

template <class _Elem>
[[nodiscard]] constexpr const _Elem* end(initializer_list<_Elem> _Ilist) noexcept {
    return _Ilist.end();
}
}


#pragma warning(pop)
#pragma pack(pop)
#line 69 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\initializer_list"
#line 70 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\initializer_list"
#line 14 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstddef"


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
template <class>

inline constexpr bool _Always_false = false;


#line 43 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstddef"

template <class _Ty = void>
struct plus {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_first_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_second_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_result;

    [[nodiscard]] constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left + _Right;
    }
};

template <class _Ty = void>
struct minus {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_first_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_second_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_result;

    [[nodiscard]] constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left - _Right;
    }
};

template <class _Ty = void>
struct multiplies {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_first_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_second_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_result;

    [[nodiscard]] constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left * _Right;
    }
};

template <class _Ty = void>
struct equal_to {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_first_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_second_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef bool _Unnameable_result;

    [[nodiscard]] constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left == _Right;
    }
};

template <class _Ty = void>
struct not_equal_to {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_first_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_second_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef bool _Unnameable_result;

    [[nodiscard]] constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left != _Right;
    }
};

template <class _Ty = void>
struct greater {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_first_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_second_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef bool _Unnameable_result;

    [[nodiscard]] constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left > _Right;
    }
};

template <class _Ty = void>
struct less {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_first_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_second_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef bool _Unnameable_result;

    [[nodiscard]] constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left < _Right;
    }
};

template <class _Ty = void>
struct greater_equal {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_first_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_second_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef bool _Unnameable_result;

    [[nodiscard]] constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left >= _Right;
    }
};

template <class _Ty = void>
struct less_equal {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_first_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_second_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef bool _Unnameable_result;

    [[nodiscard]] constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left <= _Right;
    }
};

template <>
struct plus<void> {
    template <class _Ty1, class _Ty2>
    [[nodiscard]] constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
        noexcept(noexcept(static_cast<_Ty1&&>(_Left) + static_cast<_Ty2&&>(_Right))) 
        -> decltype(static_cast<_Ty1&&>(_Left) + static_cast<_Ty2&&>(_Right)) {
        return static_cast<_Ty1&&>(_Left) + static_cast<_Ty2&&>(_Right);
    }

    using is_transparent = int;
};

template <>
struct minus<void> {
    template <class _Ty1, class _Ty2>
    [[nodiscard]] constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
        noexcept(noexcept(static_cast<_Ty1&&>(_Left) - static_cast<_Ty2&&>(_Right))) 
        -> decltype(static_cast<_Ty1&&>(_Left) - static_cast<_Ty2&&>(_Right)) {
        return static_cast<_Ty1&&>(_Left) - static_cast<_Ty2&&>(_Right);
    }

    using is_transparent = int;
};

template <>
struct multiplies<void> {
    template <class _Ty1, class _Ty2>
    [[nodiscard]] constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
        noexcept(noexcept(static_cast<_Ty1&&>(_Left) * static_cast<_Ty2&&>(_Right))) 
        -> decltype(static_cast<_Ty1&&>(_Left) * static_cast<_Ty2&&>(_Right)) {
        return static_cast<_Ty1&&>(_Left) * static_cast<_Ty2&&>(_Right);
    }

    using is_transparent = int;
};

template <>
struct equal_to<void> {
    template <class _Ty1, class _Ty2>
    [[nodiscard]] constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
        noexcept(noexcept(static_cast<_Ty1&&>(_Left) == static_cast<_Ty2&&>(_Right))) 
        -> decltype(static_cast<_Ty1&&>(_Left) == static_cast<_Ty2&&>(_Right)) {
        return static_cast<_Ty1&&>(_Left) == static_cast<_Ty2&&>(_Right);
    }

    using is_transparent = int;
};

template <>
struct not_equal_to<void> {
    template <class _Ty1, class _Ty2>
    [[nodiscard]] constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
        noexcept(noexcept(static_cast<_Ty1&&>(_Left) != static_cast<_Ty2&&>(_Right))) 
        -> decltype(static_cast<_Ty1&&>(_Left) != static_cast<_Ty2&&>(_Right)) {
        return static_cast<_Ty1&&>(_Left) != static_cast<_Ty2&&>(_Right);
    }

    using is_transparent = int;
};

template <>
struct greater<void> {
    template <class _Ty1, class _Ty2>
    [[nodiscard]] constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
        noexcept(noexcept(static_cast<_Ty1&&>(_Left) > static_cast<_Ty2&&>(_Right))) 
        -> decltype(static_cast<_Ty1&&>(_Left) > static_cast<_Ty2&&>(_Right)) {
        return static_cast<_Ty1&&>(_Left) > static_cast<_Ty2&&>(_Right);
    }

    using is_transparent = int;
};

template <>
struct less<void> {
    template <class _Ty1, class _Ty2>
    [[nodiscard]] constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
        noexcept(noexcept(static_cast<_Ty1&&>(_Left) < static_cast<_Ty2&&>(_Right))) 
        -> decltype(static_cast<_Ty1&&>(_Left) < static_cast<_Ty2&&>(_Right)) {
        return static_cast<_Ty1&&>(_Left) < static_cast<_Ty2&&>(_Right);
    }

    using is_transparent = int;
};

template <>
struct greater_equal<void> {
    template <class _Ty1, class _Ty2>
    [[nodiscard]] constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
        noexcept(noexcept(static_cast<_Ty1&&>(_Left) >= static_cast<_Ty2&&>(_Right))) 
        -> decltype(static_cast<_Ty1&&>(_Left) >= static_cast<_Ty2&&>(_Right)) {
        return static_cast<_Ty1&&>(_Left) >= static_cast<_Ty2&&>(_Right);
    }

    using is_transparent = int;
};

template <>
struct less_equal<void> {
    template <class _Ty1, class _Ty2>
    [[nodiscard]] constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
        noexcept(noexcept(static_cast<_Ty1&&>(_Left) <= static_cast<_Ty2&&>(_Right))) 
        -> decltype(static_cast<_Ty1&&>(_Left) <= static_cast<_Ty2&&>(_Right)) {
        return static_cast<_Ty1&&>(_Left) <= static_cast<_Ty2&&>(_Right);
    }

    using is_transparent = int;
};

template <class _Ty>
[[nodiscard]] constexpr _Ty* addressof(_Ty& _Val) noexcept {
    return __builtin_addressof(_Val);
}

template <class _Ty>
const _Ty* addressof(const _Ty&&) = delete;

template <class _Ptrty>
[[nodiscard]] constexpr auto _Unfancy(_Ptrty _Ptr) noexcept { 
    return ::std:: addressof(*_Ptr);
}

template <class _Ty>
[[nodiscard]] constexpr _Ty* _Unfancy(_Ty* _Ptr) noexcept { 
    return _Ptr;
}
}


#line 278 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstddef"


#line 285 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstddef"


#line 294 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstddef"


#line 301 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstddef"


#line 327 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstddef"


#line 354 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstddef"


#line 396 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstddef"


#pragma warning(pop)
#pragma pack(pop)
#line 402 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstddef"
#line 403 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstddef"
#line 13 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
template <class _Ty, _Ty... _Vals>
struct integer_sequence { 
    static_assert(is_integral_v<_Ty>, "integer_sequence<T, I...> requires T to be an integral type.");

    using value_type = _Ty;

    [[nodiscard]] static constexpr size_t size() noexcept {
        return sizeof...(_Vals);
    }
};

template <class _Ty, _Ty _Size>
using make_integer_sequence = __make_integer_seq<integer_sequence, _Ty, _Size>;

template <size_t... _Vals>
using index_sequence = integer_sequence<size_t, _Vals...>;

template <size_t _Size>
using make_index_sequence = make_integer_sequence<size_t, _Size>;

template <class... _Types>
using index_sequence_for = make_index_sequence<sizeof...(_Types)>;

template <bool _First_value, class _First, class... _Rest>
struct _Conjunction { 
    using type = _First;
};

template <class _True, class _Next, class... _Rest>
struct _Conjunction<true, _True, _Next, _Rest...> { 
    using type = typename _Conjunction<_Next::value, _Next, _Rest...>::type;
};

template <class... _Traits>
struct conjunction : true_type {}; 

template <class _First, class... _Rest>
struct conjunction<_First, _Rest...> : _Conjunction<_First::value, _First, _Rest...>::type {
    
};

template <class... _Traits>
inline constexpr bool conjunction_v = conjunction<_Traits...>::value;

template <class _Trait>
struct negation : bool_constant<!static_cast<bool>(_Trait::value)> {}; 

template <class _Trait>
inline constexpr bool negation_v = negation<_Trait>::value;

template <class _Ty>
inline constexpr bool is_void_v = is_same_v<remove_cv_t<_Ty>, void>;

template <class _Ty>
struct is_void : bool_constant<is_void_v<_Ty>> {};

template <class... _Types>
using void_t = void;


template <class _Ty>
struct add_const { 
    using type = const _Ty;
};

template <class _Ty>
using add_const_t = typename add_const<_Ty>::type;

template <class _Ty>
struct add_volatile { 
    using type = volatile _Ty;
};

template <class _Ty>
using add_volatile_t = typename add_volatile<_Ty>::type;

template <class _Ty>
struct add_cv { 
    using type = const volatile _Ty;
};

template <class _Ty>
using add_cv_t = typename add_cv<_Ty>::type;

template <class _Ty, class = void>
struct _Add_reference { 
    using _Lvalue = _Ty;
    using _Rvalue = _Ty;
};

template <class _Ty>
struct _Add_reference<_Ty, void_t<_Ty&>> { 
    using _Lvalue = _Ty&;
    using _Rvalue = _Ty&&;
};

template <class _Ty>
struct add_lvalue_reference {
    using type = typename _Add_reference<_Ty>::_Lvalue;
};

template <class _Ty>
using add_lvalue_reference_t = typename _Add_reference<_Ty>::_Lvalue;

template <class _Ty>
struct add_rvalue_reference {
    using type = typename _Add_reference<_Ty>::_Rvalue;
};

template <class _Ty>
using add_rvalue_reference_t = typename _Add_reference<_Ty>::_Rvalue;

template <class _Ty>
add_rvalue_reference_t<_Ty> declval() noexcept {
    static_assert(_Always_false<_Ty>, "Calling declval is ill-formed, see N4892 [declval]/2.");
}

template <class _Ty>
struct remove_extent { 
    using type = _Ty;
};

template <class _Ty, size_t _Ix>
struct remove_extent<_Ty[_Ix]> {
    using type = _Ty;
};

template <class _Ty>
struct remove_extent<_Ty[]> {
    using type = _Ty;
};

template <class _Ty>
using remove_extent_t = typename remove_extent<_Ty>::type;

template <class _Ty>
struct remove_all_extents { 
    using type = _Ty;
};

template <class _Ty, size_t _Ix>
struct remove_all_extents<_Ty[_Ix]> {
    using type = typename remove_all_extents<_Ty>::type;
};

template <class _Ty>
struct remove_all_extents<_Ty[]> {
    using type = typename remove_all_extents<_Ty>::type;
};

template <class _Ty>
using remove_all_extents_t = typename remove_all_extents<_Ty>::type;

template <class _Ty>
struct remove_pointer {
    using type = _Ty;
};

template <class _Ty>
struct remove_pointer<_Ty*> {
    using type = _Ty;
};

template <class _Ty>
struct remove_pointer<_Ty* const> {
    using type = _Ty;
};

template <class _Ty>
struct remove_pointer<_Ty* volatile> {
    using type = _Ty;
};

template <class _Ty>
struct remove_pointer<_Ty* const volatile> {
    using type = _Ty;
};

template <class _Ty>
using remove_pointer_t = typename remove_pointer<_Ty>::type;

template <class _Ty, class = void>
struct _Add_pointer { 
    using type = _Ty;
};

template <class _Ty>
struct _Add_pointer<_Ty, void_t<remove_reference_t<_Ty>*>> { 
    using type = remove_reference_t<_Ty>*;
};

template <class _Ty>
struct add_pointer {
    using type = typename _Add_pointer<_Ty>::type;
};

template <class _Ty>
using add_pointer_t = typename _Add_pointer<_Ty>::type;

template <class>
inline constexpr bool is_array_v = false; 

template <class _Ty, size_t _Nx>
inline constexpr bool is_array_v<_Ty[_Nx]> = true;

template <class _Ty>
inline constexpr bool is_array_v<_Ty[]> = true;

template <class _Ty>
struct is_array : bool_constant<is_array_v<_Ty>> {};


template <class>
inline constexpr bool is_bounded_array_v = false;

template <class _Ty, size_t _Nx>
inline constexpr bool is_bounded_array_v<_Ty[_Nx]> = true;

template <class _Ty>
struct is_bounded_array : bool_constant<is_bounded_array_v<_Ty>> {};

template <class>
inline constexpr bool is_unbounded_array_v = false;

template <class _Ty>
inline constexpr bool is_unbounded_array_v<_Ty[]> = true;

template <class _Ty>
struct is_unbounded_array : bool_constant<is_unbounded_array_v<_Ty>> {};
#line 252 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"

template <class>
inline constexpr bool is_lvalue_reference_v = false; 

template <class _Ty>
inline constexpr bool is_lvalue_reference_v<_Ty&> = true;

template <class _Ty>
struct is_lvalue_reference : bool_constant<is_lvalue_reference_v<_Ty>> {};

template <class>
inline constexpr bool is_rvalue_reference_v = false; 

template <class _Ty>
inline constexpr bool is_rvalue_reference_v<_Ty&&> = true;

template <class _Ty>
struct is_rvalue_reference : bool_constant<is_rvalue_reference_v<_Ty>> {};

template <class>
inline constexpr bool is_reference_v = false; 

template <class _Ty>
inline constexpr bool is_reference_v<_Ty&> = true;

template <class _Ty>
inline constexpr bool is_reference_v<_Ty&&> = true;

template <class _Ty>
struct is_reference : bool_constant<is_reference_v<_Ty>> {};

template <class>
inline constexpr bool is_pointer_v = false; 

template <class _Ty>
inline constexpr bool is_pointer_v<_Ty*> = true;

template <class _Ty>
inline constexpr bool is_pointer_v<_Ty* const> = true;

template <class _Ty>
inline constexpr bool is_pointer_v<_Ty* volatile> = true;

template <class _Ty>
inline constexpr bool is_pointer_v<_Ty* const volatile> = true;

template <class _Ty>
struct is_pointer : bool_constant<is_pointer_v<_Ty>> {};

template <class _Ty>
inline constexpr bool is_null_pointer_v =
    is_same_v<remove_cv_t<_Ty>, nullptr_t>; 

template <class _Ty>
struct is_null_pointer : bool_constant<is_null_pointer_v<_Ty>> {};

template <class _Ty>
struct is_union : bool_constant<__is_union(_Ty)> {}; 

template <class _Ty>
inline constexpr bool is_union_v = __is_union(_Ty);

template <class _Ty>
struct is_class : bool_constant<__is_class(_Ty)> {}; 

template <class _Ty>
inline constexpr bool is_class_v = __is_class(_Ty);

template <class _Ty>
inline constexpr bool is_fundamental_v = is_arithmetic_v<_Ty> || is_void_v<_Ty> || is_null_pointer_v<_Ty>;

template <class _Ty>
struct is_fundamental : bool_constant<is_fundamental_v<_Ty>> {}; 

template <class _From, class _To>
struct is_convertible : bool_constant<__is_convertible_to(_From, _To)> {
    
};

template <class _From, class _To>
inline constexpr bool is_convertible_v = __is_convertible_to(_From, _To);

template <class _Ty>
struct is_enum : bool_constant<__is_enum(_Ty)> {}; 

template <class _Ty>
inline constexpr bool is_enum_v = __is_enum(_Ty);


template <class _Ty>
inline constexpr bool is_scoped_enum_v = conjunction_v<is_enum<_Ty>, negation<is_convertible<_Ty, int>>>;

template <class _Ty>
struct is_scoped_enum : bool_constant<is_scoped_enum_v<_Ty>> {};
#line 347 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"

template <class _Ty>
struct is_compound : bool_constant<!is_fundamental_v<_Ty>> {}; 

template <class _Ty>
inline constexpr bool is_compound_v = !is_fundamental_v<_Ty>;

template <class... _Types>
struct _Arg_types {}; 

template <class _Ty1>
struct _Arg_types<_Ty1> {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty1 _Unnameable_argument;
};

template <class _Ty1, class _Ty2>
struct _Arg_types<_Ty1, _Ty2> {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty1 _Unnameable_first_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty2 _Unnameable_second_argument;
};

template <class _Ty>
struct _Is_memfunptr { 
    using _Bool_type = false_type; 
};


template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__cdecl _Arg0::*)(_Types...)   > : _Arg_types< _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; };  template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__fastcall _Arg0::*)(_Types...)   > : _Arg_types< _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__stdcall _Arg0::*)(_Types...)   > : _Arg_types< _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__thiscall _Arg0::*)(_Types...)   > : _Arg_types< _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__vectorcall _Arg0::*)(_Types...)   > : _Arg_types< _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__cdecl _Arg0::*)(_Types...) const  > : _Arg_types<const _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; };  template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__fastcall _Arg0::*)(_Types...) const  > : _Arg_types<const _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__stdcall _Arg0::*)(_Types...) const  > : _Arg_types<const _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__thiscall _Arg0::*)(_Types...) const  > : _Arg_types<const _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__vectorcall _Arg0::*)(_Types...) const  > : _Arg_types<const _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__cdecl _Arg0::*)(_Types...) volatile  > : _Arg_types<volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; };  template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__fastcall _Arg0::*)(_Types...) volatile  > : _Arg_types<volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__stdcall _Arg0::*)(_Types...) volatile  > : _Arg_types<volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__thiscall _Arg0::*)(_Types...) volatile  > : _Arg_types<volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__vectorcall _Arg0::*)(_Types...) volatile  > : _Arg_types<volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__cdecl _Arg0::*)(_Types...) const volatile  > : _Arg_types<const volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; };  template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__fastcall _Arg0::*)(_Types...) const volatile  > : _Arg_types<const volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__stdcall _Arg0::*)(_Types...) const volatile  > : _Arg_types<const volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__thiscall _Arg0::*)(_Types...) const volatile  > : _Arg_types<const volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__vectorcall _Arg0::*)(_Types...) const volatile  > : _Arg_types<const volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__cdecl _Arg0::*)(_Types...)  & > : _Arg_types< _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; };  template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__fastcall _Arg0::*)(_Types...)  & > : _Arg_types< _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__stdcall _Arg0::*)(_Types...)  & > : _Arg_types< _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__thiscall _Arg0::*)(_Types...)  & > : _Arg_types< _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__vectorcall _Arg0::*)(_Types...)  & > : _Arg_types< _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__cdecl _Arg0::*)(_Types...) const & > : _Arg_types<const _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; };  template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__fastcall _Arg0::*)(_Types...) const & > : _Arg_types<const _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__stdcall _Arg0::*)(_Types...) const & > : _Arg_types<const _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__thiscall _Arg0::*)(_Types...) const & > : _Arg_types<const _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__vectorcall _Arg0::*)(_Types...) const & > : _Arg_types<const _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__cdecl _Arg0::*)(_Types...) volatile & > : _Arg_types<volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; };  template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__fastcall _Arg0::*)(_Types...) volatile & > : _Arg_types<volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__stdcall _Arg0::*)(_Types...) volatile & > : _Arg_types<volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__thiscall _Arg0::*)(_Types...) volatile & > : _Arg_types<volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__vectorcall _Arg0::*)(_Types...) volatile & > : _Arg_types<volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__cdecl _Arg0::*)(_Types...) const volatile & > : _Arg_types<const volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; };  template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__fastcall _Arg0::*)(_Types...) const volatile & > : _Arg_types<const volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__stdcall _Arg0::*)(_Types...) const volatile & > : _Arg_types<const volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__thiscall _Arg0::*)(_Types...) const volatile & > : _Arg_types<const volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__vectorcall _Arg0::*)(_Types...) const volatile & > : _Arg_types<const volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__cdecl _Arg0::*)(_Types...)  && > : _Arg_types< _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; };  template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__fastcall _Arg0::*)(_Types...)  && > : _Arg_types< _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__stdcall _Arg0::*)(_Types...)  && > : _Arg_types< _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__thiscall _Arg0::*)(_Types...)  && > : _Arg_types< _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__vectorcall _Arg0::*)(_Types...)  && > : _Arg_types< _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__cdecl _Arg0::*)(_Types...) const && > : _Arg_types<const _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; };  template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__fastcall _Arg0::*)(_Types...) const && > : _Arg_types<const _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__stdcall _Arg0::*)(_Types...) const && > : _Arg_types<const _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__thiscall _Arg0::*)(_Types...) const && > : _Arg_types<const _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__vectorcall _Arg0::*)(_Types...) const && > : _Arg_types<const _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__cdecl _Arg0::*)(_Types...) volatile && > : _Arg_types<volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; };  template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__fastcall _Arg0::*)(_Types...) volatile && > : _Arg_types<volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__stdcall _Arg0::*)(_Types...) volatile && > : _Arg_types<volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__thiscall _Arg0::*)(_Types...) volatile && > : _Arg_types<volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__vectorcall _Arg0::*)(_Types...) volatile && > : _Arg_types<volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__cdecl _Arg0::*)(_Types...) const volatile && > : _Arg_types<const volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; };  template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__fastcall _Arg0::*)(_Types...) const volatile && > : _Arg_types<const volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__stdcall _Arg0::*)(_Types...) const volatile && > : _Arg_types<const volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__thiscall _Arg0::*)(_Types...) const volatile && > : _Arg_types<const volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__vectorcall _Arg0::*)(_Types...) const volatile && > : _Arg_types<const volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__cdecl _Arg0::*)(_Types...)   noexcept> : _Arg_types< _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; };  template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__fastcall _Arg0::*)(_Types...)   noexcept> : _Arg_types< _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__stdcall _Arg0::*)(_Types...)   noexcept> : _Arg_types< _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__thiscall _Arg0::*)(_Types...)   noexcept> : _Arg_types< _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__vectorcall _Arg0::*)(_Types...)   noexcept> : _Arg_types< _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__cdecl _Arg0::*)(_Types...) const  noexcept> : _Arg_types<const _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; };  template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__fastcall _Arg0::*)(_Types...) const  noexcept> : _Arg_types<const _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__stdcall _Arg0::*)(_Types...) const  noexcept> : _Arg_types<const _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__thiscall _Arg0::*)(_Types...) const  noexcept> : _Arg_types<const _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__vectorcall _Arg0::*)(_Types...) const  noexcept> : _Arg_types<const _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__cdecl _Arg0::*)(_Types...) volatile  noexcept> : _Arg_types<volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; };  template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__fastcall _Arg0::*)(_Types...) volatile  noexcept> : _Arg_types<volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__stdcall _Arg0::*)(_Types...) volatile  noexcept> : _Arg_types<volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__thiscall _Arg0::*)(_Types...) volatile  noexcept> : _Arg_types<volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__vectorcall _Arg0::*)(_Types...) volatile  noexcept> : _Arg_types<volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__cdecl _Arg0::*)(_Types...) const volatile  noexcept> : _Arg_types<const volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; };  template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__fastcall _Arg0::*)(_Types...) const volatile  noexcept> : _Arg_types<const volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__stdcall _Arg0::*)(_Types...) const volatile  noexcept> : _Arg_types<const volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__thiscall _Arg0::*)(_Types...) const volatile  noexcept> : _Arg_types<const volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__vectorcall _Arg0::*)(_Types...) const volatile  noexcept> : _Arg_types<const volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int , int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__cdecl _Arg0::*)(_Types...)  & noexcept> : _Arg_types< _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; };  template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__fastcall _Arg0::*)(_Types...)  & noexcept> : _Arg_types< _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__stdcall _Arg0::*)(_Types...)  & noexcept> : _Arg_types< _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__thiscall _Arg0::*)(_Types...)  & noexcept> : _Arg_types< _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__vectorcall _Arg0::*)(_Types...)  & noexcept> : _Arg_types< _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__cdecl _Arg0::*)(_Types...) const & noexcept> : _Arg_types<const _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; };  template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__fastcall _Arg0::*)(_Types...) const & noexcept> : _Arg_types<const _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__stdcall _Arg0::*)(_Types...) const & noexcept> : _Arg_types<const _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__thiscall _Arg0::*)(_Types...) const & noexcept> : _Arg_types<const _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__vectorcall _Arg0::*)(_Types...) const & noexcept> : _Arg_types<const _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__cdecl _Arg0::*)(_Types...) volatile & noexcept> : _Arg_types<volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; };  template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__fastcall _Arg0::*)(_Types...) volatile & noexcept> : _Arg_types<volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__stdcall _Arg0::*)(_Types...) volatile & noexcept> : _Arg_types<volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__thiscall _Arg0::*)(_Types...) volatile & noexcept> : _Arg_types<volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__vectorcall _Arg0::*)(_Types...) volatile & noexcept> : _Arg_types<volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__cdecl _Arg0::*)(_Types...) const volatile & noexcept> : _Arg_types<const volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; };  template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__fastcall _Arg0::*)(_Types...) const volatile & noexcept> : _Arg_types<const volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__stdcall _Arg0::*)(_Types...) const volatile & noexcept> : _Arg_types<const volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__thiscall _Arg0::*)(_Types...) const volatile & noexcept> : _Arg_types<const volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__vectorcall _Arg0::*)(_Types...) const volatile & noexcept> : _Arg_types<const volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__cdecl _Arg0::*)(_Types...)  && noexcept> : _Arg_types< _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; };  template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__fastcall _Arg0::*)(_Types...)  && noexcept> : _Arg_types< _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__stdcall _Arg0::*)(_Types...)  && noexcept> : _Arg_types< _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__thiscall _Arg0::*)(_Types...)  && noexcept> : _Arg_types< _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__vectorcall _Arg0::*)(_Types...)  && noexcept> : _Arg_types< _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__cdecl _Arg0::*)(_Types...) const && noexcept> : _Arg_types<const _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; };  template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__fastcall _Arg0::*)(_Types...) const && noexcept> : _Arg_types<const _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__stdcall _Arg0::*)(_Types...) const && noexcept> : _Arg_types<const _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__thiscall _Arg0::*)(_Types...) const && noexcept> : _Arg_types<const _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__vectorcall _Arg0::*)(_Types...) const && noexcept> : _Arg_types<const _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__cdecl _Arg0::*)(_Types...) volatile && noexcept> : _Arg_types<volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; };  template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__fastcall _Arg0::*)(_Types...) volatile && noexcept> : _Arg_types<volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__stdcall _Arg0::*)(_Types...) volatile && noexcept> : _Arg_types<volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__thiscall _Arg0::*)(_Types...) volatile && noexcept> : _Arg_types<volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__vectorcall _Arg0::*)(_Types...) volatile && noexcept> : _Arg_types<volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__cdecl _Arg0::*)(_Types...) const volatile && noexcept> : _Arg_types<const volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; };  template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__fastcall _Arg0::*)(_Types...) const volatile && noexcept> : _Arg_types<const volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__stdcall _Arg0::*)(_Types...) const volatile && noexcept> : _Arg_types<const volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__thiscall _Arg0::*)(_Types...) const volatile && noexcept> : _Arg_types<const volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (__vectorcall _Arg0::*)(_Types...) const volatile && noexcept> : _Arg_types<const volatile _Arg0*, _Types...> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<!is_same_v<int &&, int&&>, _Ret(_Types...)>; };


template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (_Arg0::*)(_Types..., ...) > { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<false>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (_Arg0::*)(_Types..., ...) const> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<false>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (_Arg0::*)(_Types..., ...) volatile> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<false>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (_Arg0::*)(_Types..., ...) const volatile> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<false>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (_Arg0::*)(_Types..., ...) &> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<false>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (_Arg0::*)(_Types..., ...) const&> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<false>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (_Arg0::*)(_Types..., ...) volatile&> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<false>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (_Arg0::*)(_Types..., ...) const volatile&> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<false>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (_Arg0::*)(_Types..., ...) &&> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<false>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (_Arg0::*)(_Types..., ...) const&&> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<false>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (_Arg0::*)(_Types..., ...) volatile&&> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<false>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (_Arg0::*)(_Types..., ...) const volatile&&> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<false>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (_Arg0::*)(_Types..., ...) noexcept> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<false>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (_Arg0::*)(_Types..., ...) const noexcept> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<false>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (_Arg0::*)(_Types..., ...) volatile noexcept> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<false>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (_Arg0::*)(_Types..., ...) const volatile noexcept> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<false>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (_Arg0::*)(_Types..., ...) &noexcept> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<false>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (_Arg0::*)(_Types..., ...) const& noexcept> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<false>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (_Arg0::*)(_Types..., ...) volatile& noexcept> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<false>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (_Arg0::*)(_Types..., ...) const volatile& noexcept> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<false>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (_Arg0::*)(_Types..., ...) &&noexcept> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<false>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (_Arg0::*)(_Types..., ...) const&& noexcept> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<false>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (_Arg0::*)(_Types..., ...) volatile&& noexcept> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<false>; }; template <class _Ret, class _Arg0, class... _Types> struct _Is_memfunptr<_Ret (_Arg0::*)(_Types..., ...) const volatile&& noexcept> { using _Bool_type = true_type; [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; using _Class_type = _Arg0; using _Guide_type = enable_if<false>; };


template <class _Ty>
inline constexpr bool is_member_function_pointer_v = _Is_memfunptr<remove_cv_t<_Ty>>::_Bool_type::value;
#line 406 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"

template <class _Ty>
struct is_member_function_pointer : bool_constant<is_member_function_pointer_v<_Ty>> {};

template <class>
inline constexpr bool is_const_v = false; 

template <class _Ty>
inline constexpr bool is_const_v<const _Ty> = true;

template <class _Ty>
struct is_const : bool_constant<is_const_v<_Ty>> {};

template <class>
inline constexpr bool is_volatile_v = false; 

template <class _Ty>
inline constexpr bool is_volatile_v<volatile _Ty> = true;

template <class _Ty>
struct is_volatile : bool_constant<is_volatile_v<_Ty>> {};

template <class _Ty>
inline constexpr bool is_function_v = 
    !is_const_v<const _Ty> && !is_reference_v<_Ty>;

template <class _Ty>
struct is_function : bool_constant<is_function_v<_Ty>> {};

template <class _Ty>
inline constexpr bool is_object_v = 
    is_const_v<const _Ty> && !is_void_v<_Ty>;

template <class _Ty>
struct is_object : bool_constant<is_object_v<_Ty>> {};

template <class>
struct _Is_member_object_pointer {
    static constexpr bool value = false;
};

template <class _Ty1, class _Ty2>
struct _Is_member_object_pointer<_Ty1 _Ty2::*> {
    static constexpr bool value = !is_function_v<_Ty1>;
    using _Class_type           = _Ty2;
};


template <class _Ty>
inline constexpr bool is_member_object_pointer_v = _Is_member_object_pointer<remove_cv_t<_Ty>>::value;
#line 460 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"

template <class _Ty>
struct is_member_object_pointer : bool_constant<is_member_object_pointer_v<_Ty>> {};


template <class _Ty>
inline constexpr bool is_member_pointer_v = is_member_object_pointer_v<_Ty> || is_member_function_pointer_v<_Ty>;
#line 471 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"

template <class _Ty>
struct is_member_pointer : bool_constant<is_member_pointer_v<_Ty>> {}; 

template <class _Ty>
inline constexpr bool is_scalar_v = 
    is_arithmetic_v<_Ty> || is_enum_v<_Ty> || is_pointer_v<_Ty> || is_member_pointer_v<_Ty> || is_null_pointer_v<_Ty>;

template <class _Ty>
struct is_scalar : bool_constant<is_scalar_v<_Ty>> {};

template <class _Ty>
struct [[deprecated("warning STL4025: " "std::is_pod and std::is_pod_v are deprecated in C++20. " "The std::is_trivially_copyable and/or std::is_standard_layout traits likely suit your use case. " "You can define _SILENCE_CXX20_IS_POD_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] is_pod : bool_constant<__is_pod(_Ty)> {}; 

template <class _Ty>
[[deprecated("warning STL4025: " "std::is_pod and std::is_pod_v are deprecated in C++20. " "The std::is_trivially_copyable and/or std::is_standard_layout traits likely suit your use case. " "You can define _SILENCE_CXX20_IS_POD_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] inline constexpr bool is_pod_v = __is_pod(_Ty);

template <class _Ty>
struct is_empty : bool_constant<__is_empty(_Ty)> {}; 

template <class _Ty>
inline constexpr bool is_empty_v = __is_empty(_Ty);

template <class _Ty>
struct is_polymorphic : bool_constant<__is_polymorphic(_Ty)> {}; 

template <class _Ty>
inline constexpr bool is_polymorphic_v = __is_polymorphic(_Ty);

template <class _Ty>
struct is_abstract : bool_constant<__is_abstract(_Ty)> {}; 

template <class _Ty>
inline constexpr bool is_abstract_v = __is_abstract(_Ty);

template <class _Ty>
struct is_final : bool_constant<__is_final(_Ty)> {}; 

template <class _Ty>
inline constexpr bool is_final_v = __is_final(_Ty);

template <class _Ty>
struct is_standard_layout : bool_constant<__is_standard_layout(_Ty)> {}; 

template <class _Ty>
inline constexpr bool is_standard_layout_v = __is_standard_layout(_Ty);


#line 527 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"


template <class _Ty>
struct is_trivial : bool_constant<__is_trivially_constructible(_Ty) && __is_trivially_copyable(_Ty)> {
    
};

template <class _Ty>
inline constexpr bool is_trivial_v = __is_trivially_constructible(_Ty) && __is_trivially_copyable(_Ty);


#line 543 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"

template <class _Ty>
struct is_trivially_copyable : bool_constant<__is_trivially_copyable(_Ty)> {
    
};

template <class _Ty>
inline constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Ty);

template <class _Ty>
struct has_virtual_destructor : bool_constant<__has_virtual_destructor(_Ty)> {
    
};

template <class _Ty>
inline constexpr bool has_virtual_destructor_v = __has_virtual_destructor(_Ty);


template <class _Ty>
struct has_unique_object_representations : bool_constant<__has_unique_object_representations(_Ty)> {
    
};

template <class _Ty>
inline constexpr bool has_unique_object_representations_v = __has_unique_object_representations(_Ty);

template <class _Ty>
struct is_aggregate : bool_constant<__is_aggregate(_Ty)> {}; 

template <class _Ty>
inline constexpr bool is_aggregate_v = __is_aggregate(_Ty);
#line 575 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"

template <class _Ty, class... _Args>
struct is_constructible : bool_constant<__is_constructible(_Ty, _Args...)> {
    
};

template <class _Ty, class... _Args>
inline constexpr bool is_constructible_v = __is_constructible(_Ty, _Args...);

template <class _Ty>
struct is_copy_constructible : bool_constant<__is_constructible(_Ty, add_lvalue_reference_t<const _Ty>)> {
    
};

template <class _Ty>
inline constexpr bool is_copy_constructible_v = __is_constructible(_Ty, add_lvalue_reference_t<const _Ty>);

template <class _Ty>
struct is_default_constructible : bool_constant<__is_constructible(_Ty)> {
    
};

template <class _Ty>
inline constexpr bool is_default_constructible_v = __is_constructible(_Ty);

template <class _Ty, class = void>
struct _Is_implicitly_default_constructible : false_type {
    
};

template <class _Ty>
void _Implicitly_default_construct(const _Ty&);

template <class _Ty>
struct _Is_implicitly_default_constructible<_Ty, void_t<decltype(_Implicitly_default_construct<_Ty>({}))>> : true_type {
};

template <class _Ty>
struct is_move_constructible : bool_constant<__is_constructible(_Ty, _Ty)> {
    
};

template <class _Ty>
inline constexpr bool is_move_constructible_v = __is_constructible(_Ty, _Ty);

template <class _To, class _From>
struct is_assignable : bool_constant<__is_assignable(_To, _From)> {}; 

template <class _To, class _From>
inline constexpr bool is_assignable_v = __is_assignable(_To, _From);

template <class _Ty>
struct is_copy_assignable
    : bool_constant<__is_assignable(add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>)> {
    
};

template <class _Ty>
inline constexpr bool is_copy_assignable_v = __is_assignable(
    add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>);


template <class _Ty>
struct _Is_copy_assignable_no_precondition_check
    : bool_constant<__is_assignable_no_precondition_check(
          add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>)> {};

template <class _Ty>
inline constexpr bool _Is_copy_assignable_unchecked_v = __is_assignable_no_precondition_check(
    add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>);


#line 652 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"

template <class _Ty>
struct is_move_assignable : bool_constant<__is_assignable(add_lvalue_reference_t<_Ty>, _Ty)> {
    
};

template <class _Ty>
inline constexpr bool is_move_assignable_v = __is_assignable(add_lvalue_reference_t<_Ty>, _Ty);


template <class _Ty>
struct _Is_move_assignable_no_precondition_check
    : bool_constant<__is_assignable_no_precondition_check(add_lvalue_reference_t<_Ty>, _Ty)> {};

template <class _Ty>
inline constexpr bool _Is_move_assignable_unchecked_v = __is_assignable_no_precondition_check(
    add_lvalue_reference_t<_Ty>, _Ty);


#line 676 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"

template <class _Ty>
struct is_destructible : bool_constant<__is_destructible(_Ty)> {
    
};

template <class _Ty>
inline constexpr bool is_destructible_v = __is_destructible(_Ty);

template <class _Ty, class... _Args>
struct is_trivially_constructible : bool_constant<__is_trivially_constructible(_Ty, _Args...)> {
    
};

template <class _Ty, class... _Args>
inline constexpr bool is_trivially_constructible_v = __is_trivially_constructible(_Ty, _Args...);

template <class _Ty>
struct is_trivially_copy_constructible
    : bool_constant<__is_trivially_constructible(_Ty, add_lvalue_reference_t<const _Ty>)> {
    
};

template <class _Ty>
inline constexpr bool is_trivially_copy_constructible_v = __is_trivially_constructible(
    _Ty, add_lvalue_reference_t<const _Ty>);

template <class _Ty>
struct is_trivially_default_constructible : bool_constant<__is_trivially_constructible(_Ty)> {
    
};

template <class _Ty>
inline constexpr bool is_trivially_default_constructible_v = __is_trivially_constructible(_Ty);

template <class _Ty>
struct is_trivially_move_constructible : bool_constant<__is_trivially_constructible(_Ty, _Ty)> {
    
};

template <class _Ty>
inline constexpr bool is_trivially_move_constructible_v = __is_trivially_constructible(_Ty, _Ty);

template <class _To, class _From>
struct is_trivially_assignable : bool_constant<__is_trivially_assignable(_To, _From)> {
    
};

template <class _To, class _From>
inline constexpr bool is_trivially_assignable_v = __is_trivially_assignable(_To, _From);

template <class _Ty>
struct is_trivially_copy_assignable
    : bool_constant<__is_trivially_assignable(add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>)> {
    
};

template <class _Ty>
inline constexpr bool is_trivially_copy_assignable_v = __is_trivially_assignable(
    add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>);

template <class _Ty>
struct is_trivially_move_assignable : bool_constant<__is_trivially_assignable(add_lvalue_reference_t<_Ty>, _Ty)> {
    
};

template <class _Ty>
inline constexpr bool is_trivially_move_assignable_v = __is_trivially_assignable(add_lvalue_reference_t<_Ty>, _Ty);

template <class _Ty>
struct is_trivially_destructible : bool_constant<__is_trivially_destructible(_Ty)> {
    
};

template <class _Ty>
inline constexpr bool is_trivially_destructible_v = __is_trivially_destructible(_Ty);

template <class _Ty, class... _Args>
struct is_nothrow_constructible : bool_constant<__is_nothrow_constructible(_Ty, _Args...)> {
    
};

template <class _Ty, class... _Args>
inline constexpr bool is_nothrow_constructible_v = __is_nothrow_constructible(_Ty, _Args...);

template <class _Ty>
struct is_nothrow_copy_constructible
    : bool_constant<__is_nothrow_constructible(_Ty, add_lvalue_reference_t<const _Ty>)> {
    
    
};

template <class _Ty>
inline constexpr bool is_nothrow_copy_constructible_v = __is_nothrow_constructible(
    _Ty, add_lvalue_reference_t<const _Ty>);

template <class _Ty>
struct is_nothrow_default_constructible : bool_constant<__is_nothrow_constructible(_Ty)> {
    
};

template <class _Ty>
inline constexpr bool is_nothrow_default_constructible_v = __is_nothrow_constructible(_Ty);

template <class _Ty>
struct is_nothrow_move_constructible : bool_constant<__is_nothrow_constructible(_Ty, _Ty)> {
    
};

template <class _Ty>
inline constexpr bool is_nothrow_move_constructible_v = __is_nothrow_constructible(_Ty, _Ty);

template <class _To, class _From>
struct is_nothrow_assignable : bool_constant<__is_nothrow_assignable(_To, _From)> {
    
};

template <class _To, class _From>
inline constexpr bool is_nothrow_assignable_v = __is_nothrow_assignable(_To, _From);

template <class _Ty>
struct is_nothrow_copy_assignable
    : bool_constant<__is_nothrow_assignable(add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>)> {
    
};

template <class _Ty>
inline constexpr bool is_nothrow_copy_assignable_v = __is_nothrow_assignable(
    add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>);

template <class _Ty>
struct is_nothrow_move_assignable : bool_constant<__is_nothrow_assignable(add_lvalue_reference_t<_Ty>, _Ty)> {
    
};

template <class _Ty>
inline constexpr bool is_nothrow_move_assignable_v = __is_nothrow_assignable(add_lvalue_reference_t<_Ty>, _Ty);

template <class _Ty>
struct is_nothrow_destructible : bool_constant<__is_nothrow_destructible(_Ty)> {
    
    
};

template <class _Ty>
inline constexpr bool is_nothrow_destructible_v = __is_nothrow_destructible(_Ty);

template <class _Ty, bool = is_integral_v<_Ty>>
struct _Sign_base { 
    using _Uty = remove_cv_t<_Ty>;

    static constexpr bool _Signed   = static_cast<_Uty>(-1) < static_cast<_Uty>(0);
    static constexpr bool _Unsigned = !_Signed;
};

template <class _Ty>
struct _Sign_base<_Ty, false> { 
                                
    static constexpr bool _Signed   = is_floating_point_v<_Ty>;
    static constexpr bool _Unsigned = false;
};

template <class _Ty>
struct is_signed : bool_constant<_Sign_base<_Ty>::_Signed> {}; 

template <class _Ty>
inline constexpr bool is_signed_v = _Sign_base<_Ty>::_Signed;

template <class _Ty>
struct is_unsigned : bool_constant<_Sign_base<_Ty>::_Unsigned> {}; 

template <class _Ty>
inline constexpr bool is_unsigned_v = _Sign_base<_Ty>::_Unsigned;

template <class _Ty>
inline constexpr bool _Is_nonbool_integral = is_integral_v<_Ty> && !is_same_v<remove_cv_t<_Ty>, bool>;

template <bool>
struct _Select { 
    template <class _Ty1, class>
    using _Apply = _Ty1;
};

template <>
struct _Select<false> {
    template <class, class _Ty2>
    using _Apply = _Ty2;
};

template <size_t>
struct _Make_signed2; 

template <>
struct _Make_signed2<1> {
    template <class>
    using _Apply = signed char;
};

template <>
struct _Make_signed2<2> {
    template <class>
    using _Apply = short;
};

template <>
struct _Make_signed2<4> {
    template <class _Ty>
    using _Apply = 
        typename _Select<is_same_v<_Ty, long> || is_same_v<_Ty, unsigned long>>::template _Apply<long, int>;
};

template <>
struct _Make_signed2<8> {
    template <class>
    using _Apply = long long;
};

template <class _Ty>
using _Make_signed1 = 
    typename _Make_signed2<sizeof(_Ty)>::template _Apply<_Ty>;

template <class _Ty>
struct make_signed { 
    static_assert(_Is_nonbool_integral<_Ty> || is_enum_v<_Ty>,
        "make_signed<T> requires that T shall be a (possibly cv-qualified) "
        "integral type or enumeration but not a bool type.");

    using type = typename remove_cv<_Ty>::template _Apply<_Make_signed1>;
};

template <class _Ty>
using make_signed_t = typename make_signed<_Ty>::type;

template <size_t>
struct _Make_unsigned2; 

template <>
struct _Make_unsigned2<1> {
    template <class>
    using _Apply = unsigned char;
};

template <>
struct _Make_unsigned2<2> {
    template <class>
    using _Apply = unsigned short;
};

template <>
struct _Make_unsigned2<4> {
    template <class _Ty>
    using _Apply = 
        typename _Select<is_same_v<_Ty, long> || is_same_v<_Ty, unsigned long>>::template _Apply<unsigned long,
            unsigned int>;
};

template <>
struct _Make_unsigned2<8> {
    template <class>
    using _Apply = unsigned long long;
};

template <class _Ty>
using _Make_unsigned1 = 
    typename _Make_unsigned2<sizeof(_Ty)>::template _Apply<_Ty>;

template <class _Ty>
struct make_unsigned { 
    static_assert(_Is_nonbool_integral<_Ty> || is_enum_v<_Ty>,
        "make_unsigned<T> requires that T shall be a (possibly cv-qualified) "
        "integral type or enumeration but not a bool type.");

    using type = typename remove_cv<_Ty>::template _Apply<_Make_unsigned1>;
};

template <class _Ty>
using make_unsigned_t = typename make_unsigned<_Ty>::type;

template <class _Rep>
constexpr make_unsigned_t<_Rep> _Unsigned_value(_Rep _Val) { 
    return static_cast<make_unsigned_t<_Rep>>(_Val);
}

template <class _Ty>
struct alignment_of : integral_constant<size_t, alignof(_Ty)> {}; 

template <class _Ty>
inline constexpr size_t alignment_of_v = alignof(_Ty);

template <class _Ty, size_t _Len>
union _Align_type { 
    _Ty _Val;
    char _Pad[_Len];
};

template <size_t _Len, size_t _Align, class _Ty, bool _Ok>
struct _Aligned; 

template <size_t _Len, size_t _Align, class _Ty>
struct _Aligned<_Len, _Align, _Ty, true> {
    using type = _Align_type<_Ty, _Len>;
};

template <size_t _Len, size_t _Align>
struct _Aligned<_Len, _Align, double, false> {


    static_assert(_Always_false<_Aligned>,
        "You've instantiated std::aligned_storage<Len, Align> with an extended alignment (in other "
        "words, Align > alignof(max_align_t)). Before VS 2017 15.8, the member \"type\" would "
        "non-conformingly have an alignment of only alignof(max_align_t). VS 2017 15.8 was fixed to "
        "handle this correctly, but the fix inherently changes layout and breaks binary compatibility "
        "(*only* for uses of aligned_storage with extended alignments). "
        "Please define either "
        "(1) _ENABLE_EXTENDED_ALIGNED_STORAGE to acknowledge that you understand this message and "
        "that you actually want a type with an extended alignment, or "
        "(2) _DISABLE_EXTENDED_ALIGNED_STORAGE to silence this message and get the old non-conforming "
        "behavior.");
#line 999 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"
    using type = _Align_type<max_align_t, _Len>;
#line 1001 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"
};

template <size_t _Len, size_t _Align>
struct _Aligned<_Len, _Align, int, false> {
    using _Next                 = double;
    static constexpr bool _Fits = _Align <= alignof(_Next);
    using type                  = typename _Aligned<_Len, _Align, _Next, _Fits>::type;
};

template <size_t _Len, size_t _Align>
struct _Aligned<_Len, _Align, short, false> {
    using _Next                 = int;
    static constexpr bool _Fits = _Align <= alignof(_Next);
    using type                  = typename _Aligned<_Len, _Align, _Next, _Fits>::type;
};

template <size_t _Len, size_t _Align>
struct _Aligned<_Len, _Align, char, false> {
    using _Next                 = short;
    static constexpr bool _Fits = _Align <= alignof(_Next);
    using type                  = typename _Aligned<_Len, _Align, _Next, _Fits>::type;
};

template <size_t _Len, size_t _Align = alignof(max_align_t)>
struct aligned_storage { 
    using _Next                 = char;
    static constexpr bool _Fits = _Align <= alignof(_Next);
    using type                  = typename _Aligned<_Len, _Align, _Next, _Fits>::type;
};

template <size_t _Len, size_t _Align = alignof(max_align_t)>
using aligned_storage_t = typename aligned_storage<_Len, _Align>::type;

template <size_t... _Vals>
struct _Maximum;

template <>
struct _Maximum<> : integral_constant<size_t, 0> {}; 

template <size_t _Val>
struct _Maximum<_Val> : integral_constant<size_t, _Val> {}; 

template <size_t _First, size_t _Second, size_t... _Rest>
struct _Maximum<_First, _Second, _Rest...> : _Maximum<(_First < _Second ? _Second : _First), _Rest...>::type {
    
};

template <size_t _Len, class... _Types>
struct aligned_union { 
    static constexpr size_t _Max_len        = _Maximum<_Len, sizeof(_Types)...>::value; 
    static constexpr size_t alignment_value = _Maximum<alignof(_Types)...>::value;

    using type = aligned_storage_t<_Max_len, alignment_value>;
};

template <size_t _Len, class... _Types>
using aligned_union_t = typename aligned_union<_Len, _Types...>::type;

template <class _Ty, bool = is_enum_v<_Ty>>
struct _Underlying_type {
    using type = __underlying_type(_Ty);
};

template <class _Ty>
struct _Underlying_type<_Ty, false> {};

template <class _Ty>
struct underlying_type : _Underlying_type<_Ty> {}; 

template <class _Ty>
using underlying_type_t = typename _Underlying_type<_Ty>::type;

template <class _Ty>
inline constexpr size_t rank_v = 0; 

template <class _Ty, size_t _Nx>
inline constexpr size_t rank_v<_Ty[_Nx]> = rank_v<_Ty> + 1;

template <class _Ty>
inline constexpr size_t rank_v<_Ty[]> = rank_v<_Ty> + 1;

template <class _Ty>
struct rank : integral_constant<size_t, rank_v<_Ty>> {};

template <class _Ty, unsigned int _Ix = 0>
inline constexpr size_t extent_v = 0; 

template <class _Ty, size_t _Nx>
inline constexpr size_t extent_v<_Ty[_Nx], 0> = _Nx;

template <class _Ty, unsigned int _Ix, size_t _Nx>
inline constexpr size_t extent_v<_Ty[_Nx], _Ix> = extent_v<_Ty, _Ix - 1>;

template <class _Ty, unsigned int _Ix>
inline constexpr size_t extent_v<_Ty[], _Ix> = extent_v<_Ty, _Ix - 1>;

template <class _Ty, unsigned int _Ix = 0>
struct extent : integral_constant<size_t, extent_v<_Ty, _Ix>> {};

template <class _Base, class _Derived>
struct is_base_of : bool_constant<__is_base_of(_Base, _Derived)> {
    
};

template <class _Base, class _Derived>
inline constexpr bool is_base_of_v = __is_base_of(_Base, _Derived);

template <class _Ty>
struct decay { 
    using _Ty1 = remove_reference_t<_Ty>;
    using _Ty2 = typename _Select<is_function_v<_Ty1>>::template _Apply<add_pointer<_Ty1>, remove_cv<_Ty1>>;
    using type = typename _Select<is_array_v<_Ty1>>::template _Apply<add_pointer<remove_extent_t<_Ty1>>, _Ty2>::type;
};

template <class _Ty>
using decay_t = typename decay<_Ty>::type;

template <class _Ty1, class _Ty2>
using _Conditional_type = decltype(false ? ::std:: declval<_Ty1>() : ::std:: declval<_Ty2>());


template <class _Ty1, class _Ty2, class = void>
struct _Const_lvalue_cond_oper {};


template <class _Ty1, class _Ty2>
struct _Const_lvalue_cond_oper<_Ty1, _Ty2, void_t<_Conditional_type<const _Ty1&, const _Ty2&>>> {
    using type = remove_cvref_t<_Conditional_type<const _Ty1&, const _Ty2&>>;
};

template <class _Ty1, class _Ty2, class = void>
struct _Decayed_cond_oper : _Const_lvalue_cond_oper<_Ty1, _Ty2> {};


#line 1138 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"

template <class _Ty1, class _Ty2>
struct _Decayed_cond_oper<_Ty1, _Ty2, void_t<_Conditional_type<_Ty1, _Ty2>>> {
    using type = decay_t<_Conditional_type<_Ty1, _Ty2>>;
};

template <class... _Ty>
struct common_type;

template <class... _Ty>
using common_type_t = typename common_type<_Ty...>::type;

template <>
struct common_type<> {};

template <class _Ty1>
struct common_type<_Ty1> : common_type<_Ty1, _Ty1> {};

template <class _Ty1, class _Ty2, class _Decayed1 = decay_t<_Ty1>, class _Decayed2 = decay_t<_Ty2>>
struct _Common_type2 : common_type<_Decayed1, _Decayed2> {};

template <class _Ty1, class _Ty2>
struct _Common_type2<_Ty1, _Ty2, _Ty1, _Ty2> : _Decayed_cond_oper<_Ty1, _Ty2> {};

template <class _Ty1, class _Ty2>
struct common_type<_Ty1, _Ty2> : _Common_type2<_Ty1, _Ty2> {};

template <class _Void, class _Ty1, class _Ty2, class... _Rest>
struct _Common_type3 {};

template <class _Ty1, class _Ty2, class... _Rest>
struct _Common_type3<void_t<common_type_t<_Ty1, _Ty2>>, _Ty1, _Ty2, _Rest...>
    : common_type<common_type_t<_Ty1, _Ty2>, _Rest...> {};

template <class _Ty1, class _Ty2, class... _Rest>
struct common_type<_Ty1, _Ty2, _Rest...> : _Common_type3<void, _Ty1, _Ty2, _Rest...> {};


template <class, class, template <class> class, template <class> class>
struct basic_common_reference {};

template <class _Ty>
_Ty _Returns_exactly() noexcept; 

template <class _Ty1, class _Ty2>
using _Cond_res = 
    decltype(false ? _Returns_exactly<_Ty1>() : _Returns_exactly<_Ty2>());

template <class _From>
struct _Copy_cv_impl {
    template <class _To>
    using _Apply = _To;
};
template <class _From>
struct _Copy_cv_impl<const _From> {
    template <class _To>
    using _Apply = const _To;
};
template <class _From>
struct _Copy_cv_impl<volatile _From> {
    template <class _To>
    using _Apply = volatile _To;
};
template <class _From>
struct _Copy_cv_impl<const volatile _From> {
    template <class _To>
    using _Apply = const volatile _To;
};
template <class _From, class _To>
using _Copy_cv = 
    typename _Copy_cv_impl<_From>::template _Apply<_To>;

template <class _Ty1>
struct _Add_qualifiers { 
    template <class _Ty2>
    using _Apply = _Copy_cv<_Ty1, _Ty2>;
};
template <class _Ty1>
struct _Add_qualifiers<_Ty1&> {
    template <class _Ty2>
    using _Apply = add_lvalue_reference_t<_Copy_cv<_Ty1, _Ty2>>;
};
template <class _Ty1>
struct _Add_qualifiers<_Ty1&&> {
    template <class _Ty2>
    using _Apply = add_rvalue_reference_t<_Copy_cv<_Ty1, _Ty2>>;
};

template <class...>
struct common_reference;

template <class... _Types>
using common_reference_t = typename common_reference<_Types...>::type;


template <>
struct common_reference<> {};


template <class _Ty>
struct common_reference<_Ty> {
    using type = _Ty;
};


template <class _Ty1, class _Ty2, class = void>
struct _Common_reference2C : common_type<_Ty1, _Ty2> {};


template <class _Ty1, class _Ty2>
struct _Common_reference2C<_Ty1, _Ty2, void_t<_Cond_res<_Ty1, _Ty2>>> {
    using type = _Cond_res<_Ty1, _Ty2>;
};


template <class _Ty1, class _Ty2>
using _Basic_specialization = typename basic_common_reference<remove_cvref_t<_Ty1>, remove_cvref_t<_Ty2>,
    _Add_qualifiers<_Ty1>::template _Apply, _Add_qualifiers<_Ty2>::template _Apply>::type;

template <class _Ty1, class _Ty2, class = void>
struct _Common_reference2B : _Common_reference2C<_Ty1, _Ty2> {};

template <class _Ty1, class _Ty2>
struct _Common_reference2B<_Ty1, _Ty2, void_t<_Basic_specialization<_Ty1, _Ty2>>> {
    using type = _Basic_specialization<_Ty1, _Ty2>;
};


template <class _Ty1, class _Ty2, class = void>
struct _Common_reference2A : _Common_reference2B<_Ty1, _Ty2> {};

template <class _Ty1, class _Ty2, class _Result = _Cond_res<_Copy_cv<_Ty1, _Ty2>&, _Copy_cv<_Ty2, _Ty1>&>,
    enable_if_t<is_lvalue_reference_v<_Result>, int> = 0>
using _LL_common_ref = _Result;

template <class _Ty1, class _Ty2>
struct _Common_reference2A<_Ty1&, _Ty2&, void_t<_LL_common_ref<_Ty1, _Ty2>>> {
    using type = _LL_common_ref<_Ty1, _Ty2>; 
};

template <class _Ty1, class _Ty2>
struct _Common_reference2A<_Ty1&&, _Ty2&, enable_if_t<is_convertible_v<_Ty1&&, _LL_common_ref<const _Ty1, _Ty2>>>> {
    using type = _LL_common_ref<const _Ty1, _Ty2>; 
};

template <class _Ty1, class _Ty2>
struct _Common_reference2A<_Ty1&, _Ty2&&, enable_if_t<is_convertible_v<_Ty2&&, _LL_common_ref<const _Ty2, _Ty1>>>> {
    using type = _LL_common_ref<const _Ty2, _Ty1>; 
};

template <class _Ty1, class _Ty2>
using _RR_common_ref = remove_reference_t<_LL_common_ref<_Ty1, _Ty2>>&&;

template <class _Ty1, class _Ty2>
struct _Common_reference2A<_Ty1&&, _Ty2&&,
    enable_if_t<
        is_convertible_v<_Ty1&&, _RR_common_ref<_Ty1, _Ty2>> && is_convertible_v<_Ty2&&, _RR_common_ref<_Ty1, _Ty2>>>> {
    using type = _RR_common_ref<_Ty1, _Ty2>; 
};

template <class _Ty1, class _Ty2>
struct common_reference<_Ty1, _Ty2> : _Common_reference2A<_Ty1, _Ty2> {};


template <class _Void, class _Ty1, class _Ty2, class... _Types>
struct _Fold_common_reference {};
template <class _Ty1, class _Ty2, class... _Types>
struct _Fold_common_reference<void_t<common_reference_t<_Ty1, _Ty2>>, _Ty1, _Ty2, _Types...>
    : common_reference<common_reference_t<_Ty1, _Ty2>, _Types...> {};

template <class _Ty1, class _Ty2, class _Ty3, class... _Rest>
struct common_reference<_Ty1, _Ty2, _Ty3, _Rest...> : _Fold_common_reference<void, _Ty1, _Ty2, _Ty3, _Rest...> {};
#line 1314 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"

template <class _Ty>
struct _Identity {
    using type = _Ty;
};
template <class _Ty>
using _Identity_t [[msvc::known_semantics]] = typename _Identity<_Ty>::type;


template <class _Ty>
struct type_identity {
    using type = _Ty;
};
template <class _Ty>
using type_identity_t = typename type_identity<_Ty>::type;
#line 1330 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"

template <class _Type, template <class...> class _Template>
inline constexpr bool _Is_specialization_v = false; 
template <template <class...> class _Template, class... _Types>
inline constexpr bool _Is_specialization_v<_Template<_Types...>, _Template> = true;

template <class _Type, template <class...> class _Template>
struct _Is_specialization : bool_constant<_Is_specialization_v<_Type, _Template>> {};

template <class _Ty>
[[nodiscard]] constexpr _Ty&& forward(
    remove_reference_t<_Ty>& _Arg) noexcept { 
    return static_cast<_Ty&&>(_Arg);
}

template <class _Ty>
[[nodiscard]] constexpr _Ty&& forward(remove_reference_t<_Ty>&& _Arg) noexcept { 
    static_assert(!is_lvalue_reference_v<_Ty>, "bad forward call");
    return static_cast<_Ty&&>(_Arg);
}

template <class _Ty>
[[nodiscard]] constexpr remove_reference_t<_Ty>&& move(_Ty&& _Arg) noexcept { 
    return static_cast<remove_reference_t<_Ty>&&>(_Arg);
}

template <class _Ty>
[[nodiscard]] constexpr conditional_t<!is_nothrow_move_constructible_v<_Ty> && is_copy_constructible_v<_Ty>, const _Ty&,
    _Ty&&>
    move_if_noexcept(_Ty& _Arg) noexcept { 
    return ::std:: move(_Arg);
}

template <class _Ty>
class reference_wrapper;


enum class _Invoker_strategy {
    _Functor,
    _Pmf_object,
    _Pmf_refwrap,
    _Pmf_pointer,
    _Pmd_object,
    _Pmd_refwrap,
    _Pmd_pointer
};

struct _Invoker_functor {
    static constexpr _Invoker_strategy _Strategy = _Invoker_strategy::_Functor;

    template <class _Callable, class... _Types>
    static constexpr auto _Call(_Callable&& _Obj, _Types&&... _Args) noexcept(
        noexcept(static_cast<_Callable&&>(_Obj)(static_cast<_Types&&>(_Args)...)))
        -> decltype(static_cast<_Callable&&>(_Obj)(static_cast<_Types&&>(_Args)...)) {
        return static_cast<_Callable&&>(_Obj)(static_cast<_Types&&>(_Args)...);
    }
};

struct _Invoker_pmf_object {
    static constexpr _Invoker_strategy _Strategy = _Invoker_strategy::_Pmf_object;

    template <class _Decayed, class _Ty1, class... _Types2>
    static constexpr auto _Call(_Decayed _Pmf, _Ty1&& _Arg1, _Types2&&... _Args2) noexcept(
        noexcept((static_cast<_Ty1&&>(_Arg1).*_Pmf)(static_cast<_Types2&&>(_Args2)...)))
        -> decltype((static_cast<_Ty1&&>(_Arg1).*_Pmf)(static_cast<_Types2&&>(_Args2)...)) {
        return (static_cast<_Ty1&&>(_Arg1).*_Pmf)(static_cast<_Types2&&>(_Args2)...);
    }
};

struct _Invoker_pmf_refwrap {
    static constexpr _Invoker_strategy _Strategy = _Invoker_strategy::_Pmf_refwrap;

    template <class _Decayed, class _Refwrap, class... _Types2>
    static constexpr auto _Call(_Decayed _Pmf, _Refwrap _Rw, _Types2&&... _Args2) noexcept(
        noexcept((_Rw.get().*_Pmf)(static_cast<_Types2&&>(_Args2)...)))
        -> decltype((_Rw.get().*_Pmf)(static_cast<_Types2&&>(_Args2)...)) {
        return (_Rw.get().*_Pmf)(static_cast<_Types2&&>(_Args2)...);
    }
};

struct _Invoker_pmf_pointer {
    static constexpr _Invoker_strategy _Strategy = _Invoker_strategy::_Pmf_pointer;

    template <class _Decayed, class _Ty1, class... _Types2>
    static constexpr auto _Call(_Decayed _Pmf, _Ty1&& _Arg1, _Types2&&... _Args2) noexcept(
        noexcept(((*static_cast<_Ty1&&>(_Arg1)).*_Pmf)(static_cast<_Types2&&>(_Args2)...)))
        -> decltype(((*static_cast<_Ty1&&>(_Arg1)).*_Pmf)(static_cast<_Types2&&>(_Args2)...)) {
        return ((*static_cast<_Ty1&&>(_Arg1)).*_Pmf)(static_cast<_Types2&&>(_Args2)...);
    }
};

struct _Invoker_pmd_object {
    static constexpr _Invoker_strategy _Strategy = _Invoker_strategy::_Pmd_object;

    template <class _Decayed, class _Ty1>
    static constexpr auto _Call(_Decayed _Pmd, _Ty1&& _Arg1) noexcept -> decltype(static_cast<_Ty1&&>(_Arg1).*_Pmd) {
        return static_cast<_Ty1&&>(_Arg1).*_Pmd;
    }
};

struct _Invoker_pmd_refwrap {
    static constexpr _Invoker_strategy _Strategy = _Invoker_strategy::_Pmd_refwrap;

    template <class _Decayed, class _Refwrap>
    static constexpr auto _Call(_Decayed _Pmd, _Refwrap _Rw) noexcept -> decltype(_Rw.get().*_Pmd) {
        return _Rw.get().*_Pmd;
    }
};

struct _Invoker_pmd_pointer {
    static constexpr _Invoker_strategy _Strategy = _Invoker_strategy::_Pmd_pointer;

    template <class _Decayed, class _Ty1>
    static constexpr auto _Call(_Decayed _Pmd, _Ty1&& _Arg1) noexcept(noexcept((*static_cast<_Ty1&&>(_Arg1)).*_Pmd))
        -> decltype((*static_cast<_Ty1&&>(_Arg1)).*_Pmd) {
        return (*static_cast<_Ty1&&>(_Arg1)).*_Pmd;
    }
};

template <class _Callable, class _Ty1, class _Removed_cvref = _Remove_cvref_t<_Callable>,
    bool _Is_pmf = is_member_function_pointer_v<_Removed_cvref>,
    bool _Is_pmd = is_member_object_pointer_v<_Removed_cvref>>
struct _Invoker1;

template <class _Callable, class _Ty1, class _Removed_cvref>
struct _Invoker1<_Callable, _Ty1, _Removed_cvref, true, false>
    : conditional_t<is_base_of_v<typename _Is_memfunptr<_Removed_cvref>::_Class_type, remove_reference_t<_Ty1>>,
          _Invoker_pmf_object,
          conditional_t<_Is_specialization_v<_Remove_cvref_t<_Ty1>, reference_wrapper>, _Invoker_pmf_refwrap,
              _Invoker_pmf_pointer>> {}; 

template <class _Callable, class _Ty1, class _Removed_cvref>
struct _Invoker1<_Callable, _Ty1, _Removed_cvref, false, true>
    : conditional_t<
          is_base_of_v<typename _Is_member_object_pointer<_Removed_cvref>::_Class_type, remove_reference_t<_Ty1>>,
          _Invoker_pmd_object,
          conditional_t<_Is_specialization_v<_Remove_cvref_t<_Ty1>, reference_wrapper>, _Invoker_pmd_refwrap,
              _Invoker_pmd_pointer>> {}; 

template <class _Callable, class _Ty1, class _Removed_cvref>
struct _Invoker1<_Callable, _Ty1, _Removed_cvref, false, false> : _Invoker_functor {};

template <class _Callable>
constexpr auto invoke(_Callable&& _Obj) noexcept(noexcept(static_cast<_Callable&&>(_Obj)()))
    -> decltype(static_cast<_Callable&&>(_Obj)()) {
    return static_cast<_Callable&&>(_Obj)();
}

template <class _Callable, class _Ty1, class... _Types2>
constexpr auto invoke(_Callable&& _Obj, _Ty1&& _Arg1, _Types2&&... _Args2) noexcept(
    noexcept(_Invoker1<_Callable, _Ty1>::_Call(
        static_cast<_Callable&&>(_Obj), static_cast<_Ty1&&>(_Arg1), static_cast<_Types2&&>(_Args2)...)))
    -> decltype(_Invoker1<_Callable, _Ty1>::_Call(
        static_cast<_Callable&&>(_Obj), static_cast<_Ty1&&>(_Arg1), static_cast<_Types2&&>(_Args2)...)) {
    if constexpr (_Invoker1<_Callable, _Ty1>::_Strategy == _Invoker_strategy::_Functor) {
        return static_cast<_Callable&&>(_Obj)(static_cast<_Ty1&&>(_Arg1), static_cast<_Types2&&>(_Args2)...);
    } else if constexpr (_Invoker1<_Callable, _Ty1>::_Strategy == _Invoker_strategy::_Pmf_object) {
        return (static_cast<_Ty1&&>(_Arg1).*_Obj)(static_cast<_Types2&&>(_Args2)...);
    } else if constexpr (_Invoker1<_Callable, _Ty1>::_Strategy == _Invoker_strategy::_Pmf_refwrap) {
        return (_Arg1.get().*_Obj)(static_cast<_Types2&&>(_Args2)...);
    } else if constexpr (_Invoker1<_Callable, _Ty1>::_Strategy == _Invoker_strategy::_Pmf_pointer) {
        return ((*static_cast<_Ty1&&>(_Arg1)).*_Obj)(static_cast<_Types2&&>(_Args2)...);
    } else if constexpr (_Invoker1<_Callable, _Ty1>::_Strategy == _Invoker_strategy::_Pmd_object) {
        return static_cast<_Ty1&&>(_Arg1).*_Obj;
    } else if constexpr (_Invoker1<_Callable, _Ty1>::_Strategy == _Invoker_strategy::_Pmd_refwrap) {
        return _Arg1.get().*_Obj;
    } else {
        static_assert(_Invoker1<_Callable, _Ty1>::_Strategy == _Invoker_strategy::_Pmd_pointer, "bug in invoke");
        return (*static_cast<_Ty1&&>(_Arg1)).*_Obj;
    }
}

#pragma warning(push)
#pragma warning(disable : 4242) 
#pragma warning(disable : 4244) 
#pragma warning(disable : 4365) 
#pragma warning(disable : 5215) 


template <class _To>
void _Implicitly_convert_to(_To) noexcept; 

template <class _From, class _To, bool = is_convertible_v<_From, _To>, bool = is_void_v<_To>>
inline constexpr bool _Is_nothrow_convertible_v = noexcept(_Implicitly_convert_to<_To>(::std:: declval<_From>()));


#pragma warning(pop)

template <class _From, class _To, bool _IsVoid>
inline constexpr bool _Is_nothrow_convertible_v<_From, _To, false, _IsVoid> = false;

template <class _From, class _To>
inline constexpr bool _Is_nothrow_convertible_v<_From, _To, true, true> = true;

template <class _From, class _To>
struct _Is_nothrow_convertible : bool_constant<_Is_nothrow_convertible_v<_From, _To>> {
    
};


template <class _From, class _To>
inline constexpr bool is_nothrow_convertible_v = _Is_nothrow_convertible_v<_From, _To>;

template <class _From, class _To>
using is_nothrow_convertible = _Is_nothrow_convertible<_From, _To>;
#line 1546 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"

template <class _Ty>
_Ty _Returns_exactly() noexcept; 

template <class _From, class _To, class = void>
struct _Invoke_convertible : false_type {};

template <class _From, class _To>
struct _Invoke_convertible<_From, _To, void_t<decltype(_Implicitly_convert_to<_To>(_Returns_exactly<_From>()))>>
    : true_type {};

template <class _From, class _To>
struct _Invoke_nothrow_convertible : bool_constant<noexcept(_Implicitly_convert_to<_To>(_Returns_exactly<_From>()))> {};

template <class _Result, bool _Nothrow>
struct _Invoke_traits_common {
    using type                  = _Result;
    using _Is_invocable         = true_type;
    using _Is_nothrow_invocable = bool_constant<_Nothrow>;
    template <class _Rx>
    using _Is_invocable_r = bool_constant<disjunction_v<is_void<_Rx>, _Invoke_convertible<type, _Rx>>>;
    template <class _Rx>
    using _Is_nothrow_invocable_r = bool_constant<conjunction_v<_Is_nothrow_invocable,
        disjunction<is_void<_Rx>,
            conjunction<_Invoke_convertible<type, _Rx>, _Invoke_nothrow_convertible<type, _Rx>>>>>;
};

template <class _Void, class _Callable>
struct _Invoke_traits_zero {
    
    using _Is_invocable         = false_type;
    using _Is_nothrow_invocable = false_type;
    template <class _Rx>
    using _Is_invocable_r = false_type;
    template <class _Rx>
    using _Is_nothrow_invocable_r = false_type;
};

template <class _Callable>
using _Decltype_invoke_zero = decltype(::std:: declval<_Callable>()());

template <class _Callable>
struct _Invoke_traits_zero<void_t<_Decltype_invoke_zero<_Callable>>, _Callable>
    : _Invoke_traits_common<_Decltype_invoke_zero<_Callable>, noexcept(::std:: declval<_Callable>()())> {};

template <class _Void, class... _Types>
struct _Invoke_traits_nonzero {
    
    using _Is_invocable         = false_type;
    using _Is_nothrow_invocable = false_type;
    template <class _Rx>
    using _Is_invocable_r = false_type;
    template <class _Rx>
    using _Is_nothrow_invocable_r = false_type;
};

template <class _Callable, class _Ty1, class... _Types2>
using _Decltype_invoke_nonzero = decltype(_Invoker1<_Callable, _Ty1>::_Call(
    ::std:: declval<_Callable>(), ::std:: declval<_Ty1>(), ::std:: declval<_Types2>()...));

template <class _Callable, class _Ty1, class... _Types2>
struct _Invoke_traits_nonzero<void_t<_Decltype_invoke_nonzero<_Callable, _Ty1, _Types2...>>, _Callable, _Ty1,
    _Types2...> : _Invoke_traits_common<_Decltype_invoke_nonzero<_Callable, _Ty1, _Types2...>,
                      noexcept(_Invoker1<_Callable, _Ty1>::_Call(
                          ::std:: declval<_Callable>(), ::std:: declval<_Ty1>(), ::std:: declval<_Types2>()...))> {};

template <class _Callable, class... _Args>
using _Select_invoke_traits = conditional_t<sizeof...(_Args) == 0, _Invoke_traits_zero<void, _Callable>,
    _Invoke_traits_nonzero<void, _Callable, _Args...>>;


#line 1637 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"

template <class _Callable, class... _Args>
using _Invoke_result_t = typename _Select_invoke_traits<_Callable, _Args...>::type;

template <class _Rx, class _Callable, class... _Args>
using _Is_invocable_r_ = typename _Select_invoke_traits<_Callable, _Args...>::template _Is_invocable_r<_Rx>;

template <class _Rx, class _Callable, class... _Args>
struct _Is_invocable_r : _Is_invocable_r_<_Rx, _Callable, _Args...> {
    
};


template <class _Callable, class... _Args>
struct invoke_result : _Select_invoke_traits<_Callable, _Args...> {
    
};

template <class _Callable, class... _Args>
using invoke_result_t = typename _Select_invoke_traits<_Callable, _Args...>::type;

template <class _Callable, class... _Args>
struct is_invocable : _Select_invoke_traits<_Callable, _Args...>::_Is_invocable {
    
};

template <class _Callable, class... _Args>
inline constexpr bool is_invocable_v = _Select_invoke_traits<_Callable, _Args...>::_Is_invocable::value;

template <class _Callable, class... _Args>
struct is_nothrow_invocable : _Select_invoke_traits<_Callable, _Args...>::_Is_nothrow_invocable {
    
};

template <class _Callable, class... _Args>
inline constexpr bool is_nothrow_invocable_v = _Select_invoke_traits<_Callable, _Args...>::_Is_nothrow_invocable::value;

template <class _Rx, class _Callable, class... _Args>
struct is_invocable_r : _Is_invocable_r_<_Rx, _Callable, _Args...> {
    
};

template <class _Rx, class _Callable, class... _Args>
inline constexpr bool is_invocable_r_v = _Is_invocable_r_<_Rx, _Callable, _Args...>::value;

template <class _Rx, class _Callable, class... _Args>
struct is_nothrow_invocable_r : _Select_invoke_traits<_Callable, _Args...>::template _Is_nothrow_invocable_r<_Rx> {
    
};

template <class _Rx, class _Callable, class... _Args>
inline constexpr bool is_nothrow_invocable_r_v =
    _Select_invoke_traits<_Callable, _Args...>::template _Is_nothrow_invocable_r<_Rx>::value;
#line 1691 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"


template <class _Ty1, class _Ty2>
struct is_layout_compatible : bool_constant<__is_layout_compatible(_Ty1, _Ty2)> {};

template <class _Ty1, class _Ty2>
inline constexpr bool is_layout_compatible_v = __is_layout_compatible(_Ty1, _Ty2);

template <class _Base, class _Derived>
struct is_pointer_interconvertible_base_of : bool_constant<__is_pointer_interconvertible_base_of(_Base, _Derived)> {};

template <class _Base, class _Derived>
inline constexpr bool is_pointer_interconvertible_base_of_v = __is_pointer_interconvertible_base_of(_Base, _Derived);

template <class _ClassTy, class _MemberTy>
[[nodiscard]] constexpr bool is_pointer_interconvertible_with_class(_MemberTy _ClassTy::*_Pm) noexcept {
    return __is_pointer_interconvertible_with_class(_ClassTy, _Pm);
}

template <class _ClassTy1, class _ClassTy2, class _MemberTy1, class _MemberTy2>
[[nodiscard]] constexpr bool is_corresponding_member(_MemberTy1 _ClassTy1::*_Pm1, _MemberTy2 _ClassTy2::*_Pm2) noexcept {
    return __is_corresponding_member(_ClassTy1, _ClassTy2, _Pm1, _Pm2);
}
#line 1717 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"
#line 1718 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"
#line 1719 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"

template <class _Ty>
struct _Function_args {}; 


template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...)   > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; };  template <class _Ret, class... _Types> struct _Function_args<_Ret __fastcall(_Types...)   > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __stdcall(_Types...)   > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...)   > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) const  > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; };  template <class _Ret, class... _Types> struct _Function_args<_Ret __fastcall(_Types...) const  > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __stdcall(_Types...) const  > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) const  > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) volatile  > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; };  template <class _Ret, class... _Types> struct _Function_args<_Ret __fastcall(_Types...) volatile  > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __stdcall(_Types...) volatile  > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) volatile  > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) const volatile  > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; };  template <class _Ret, class... _Types> struct _Function_args<_Ret __fastcall(_Types...) const volatile  > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __stdcall(_Types...) const volatile  > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) const volatile  > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...)  & > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; };  template <class _Ret, class... _Types> struct _Function_args<_Ret __fastcall(_Types...)  & > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __stdcall(_Types...)  & > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...)  & > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) const & > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; };  template <class _Ret, class... _Types> struct _Function_args<_Ret __fastcall(_Types...) const & > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __stdcall(_Types...) const & > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) const & > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) volatile & > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; };  template <class _Ret, class... _Types> struct _Function_args<_Ret __fastcall(_Types...) volatile & > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __stdcall(_Types...) volatile & > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) volatile & > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) const volatile & > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; };  template <class _Ret, class... _Types> struct _Function_args<_Ret __fastcall(_Types...) const volatile & > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __stdcall(_Types...) const volatile & > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) const volatile & > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...)  && > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; };  template <class _Ret, class... _Types> struct _Function_args<_Ret __fastcall(_Types...)  && > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __stdcall(_Types...)  && > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...)  && > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) const && > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; };  template <class _Ret, class... _Types> struct _Function_args<_Ret __fastcall(_Types...) const && > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __stdcall(_Types...) const && > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) const && > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) volatile && > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; };  template <class _Ret, class... _Types> struct _Function_args<_Ret __fastcall(_Types...) volatile && > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __stdcall(_Types...) volatile && > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) volatile && > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) const volatile && > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; };  template <class _Ret, class... _Types> struct _Function_args<_Ret __fastcall(_Types...) const volatile && > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __stdcall(_Types...) const volatile && > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) const volatile && > : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...)   noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; };  template <class _Ret, class... _Types> struct _Function_args<_Ret __fastcall(_Types...)   noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __stdcall(_Types...)   noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...)   noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) const  noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; };  template <class _Ret, class... _Types> struct _Function_args<_Ret __fastcall(_Types...) const  noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __stdcall(_Types...) const  noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) const  noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) volatile  noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; };  template <class _Ret, class... _Types> struct _Function_args<_Ret __fastcall(_Types...) volatile  noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __stdcall(_Types...) volatile  noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) volatile  noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) const volatile  noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; };  template <class _Ret, class... _Types> struct _Function_args<_Ret __fastcall(_Types...) const volatile  noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __stdcall(_Types...) const volatile  noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) const volatile  noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...)  & noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; };  template <class _Ret, class... _Types> struct _Function_args<_Ret __fastcall(_Types...)  & noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __stdcall(_Types...)  & noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...)  & noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) const & noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; };  template <class _Ret, class... _Types> struct _Function_args<_Ret __fastcall(_Types...) const & noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __stdcall(_Types...) const & noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) const & noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) volatile & noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; };  template <class _Ret, class... _Types> struct _Function_args<_Ret __fastcall(_Types...) volatile & noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __stdcall(_Types...) volatile & noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) volatile & noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) const volatile & noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; };  template <class _Ret, class... _Types> struct _Function_args<_Ret __fastcall(_Types...) const volatile & noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __stdcall(_Types...) const volatile & noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) const volatile & noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...)  && noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; };  template <class _Ret, class... _Types> struct _Function_args<_Ret __fastcall(_Types...)  && noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __stdcall(_Types...)  && noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...)  && noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) const && noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; };  template <class _Ret, class... _Types> struct _Function_args<_Ret __fastcall(_Types...) const && noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __stdcall(_Types...) const && noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) const && noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) volatile && noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; };  template <class _Ret, class... _Types> struct _Function_args<_Ret __fastcall(_Types...) volatile && noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __stdcall(_Types...) volatile && noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) volatile && noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __cdecl(_Types...) const volatile && noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; };  template <class _Ret, class... _Types> struct _Function_args<_Ret __fastcall(_Types...) const volatile && noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __stdcall(_Types...) const volatile && noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret __vectorcall(_Types...) const volatile && noexcept> : _Arg_types<_Types...> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; };


template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) > { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) const> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) volatile> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) const volatile> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) &> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) const&> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) volatile&> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) const volatile&> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) &&> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) const&&> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) volatile&&> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) const volatile&&> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) noexcept> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) const noexcept> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) volatile noexcept> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) const volatile noexcept> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) &noexcept> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) const& noexcept> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) volatile& noexcept> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) const volatile& noexcept> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) &&noexcept> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) const&& noexcept> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) volatile&& noexcept> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; }; template <class _Ret, class... _Types> struct _Function_args<_Ret(_Types..., ...) const volatile&& noexcept> { [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result; };


template <class _Ty, class = void>
struct _Weak_result_type {}; 

__pragma(warning(push)) __pragma(warning(disable : 4996))
template <class _Ty>
struct _Weak_result_type<_Ty, void_t<typename _Ty::result_type>> { 
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef typename _Ty::result_type _Unnameable_result;
};
__pragma(warning(pop))

template <class _Ty, class = void>
struct _Weak_argument_type : _Weak_result_type<_Ty> {}; 

__pragma(warning(push)) __pragma(warning(disable : 4996))
template <class _Ty>
struct _Weak_argument_type<_Ty, void_t<typename _Ty::argument_type>> : _Weak_result_type<_Ty> {
    
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef typename _Ty::argument_type _Unnameable_argument;
};
__pragma(warning(pop))

template <class _Ty, class = void>
struct _Weak_binary_args : _Weak_argument_type<_Ty> {}; 

__pragma(warning(push)) __pragma(warning(disable : 4996))
template <class _Ty>
struct _Weak_binary_args<_Ty, void_t<typename _Ty::first_argument_type,
                                  typename _Ty::second_argument_type>>
    : _Weak_argument_type<_Ty> { 
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef typename _Ty::first_argument_type _Unnameable_first_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef typename _Ty::second_argument_type _Unnameable_second_argument;
};
__pragma(warning(pop))

template <class _Ty>
using _Weak_types = conditional_t<is_function_v<remove_pointer_t<_Ty>>, _Function_args<remove_pointer_t<_Ty>>,
    conditional_t<is_member_function_pointer_v<_Ty>, _Is_memfunptr<remove_cv_t<_Ty>>, _Weak_binary_args<_Ty>>>;

template <class _Ty>
void _Refwrap_ctor_fun(_Identity_t<_Ty&>) noexcept;
template <class _Ty>
void _Refwrap_ctor_fun(_Identity_t<_Ty&&>) = delete;

template <class _Ty, class _Uty, class = void>
struct _Refwrap_has_ctor_from : false_type {};

template <class _Ty, class _Uty>
struct _Refwrap_has_ctor_from<_Ty, _Uty, void_t<decltype(_Refwrap_ctor_fun<_Ty>(::std:: declval<_Uty>()))>> : true_type {};

template <class _Ty>
class reference_wrapper


#line 1795 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"
{
public:
    static_assert(is_object_v<_Ty> || is_function_v<_Ty>,
        "reference_wrapper<T> requires T to be an object type or a function type.");

    using type = _Ty;

    template <class _Uty, enable_if_t<conjunction_v<negation<is_same<_Remove_cvref_t<_Uty>, reference_wrapper>>,
                                          _Refwrap_has_ctor_from<_Ty, _Uty>>,
                              int> = 0>
    constexpr reference_wrapper(_Uty&& _Val) noexcept(noexcept(_Refwrap_ctor_fun<_Ty>(::std:: declval<_Uty>()))) {
        _Ty& _Ref = static_cast<_Uty&&>(_Val);
        _Ptr      = ::std:: addressof(_Ref);
    }

    constexpr operator _Ty&() const noexcept {
        return *_Ptr;
    }

    [[nodiscard]] constexpr _Ty& get() const noexcept {
        return *_Ptr;
    }

private:
    _Ty* _Ptr{};

public:
    template <class... _Types>
    constexpr auto operator()(_Types&&... _Args) const
        noexcept(noexcept(::std:: invoke(*_Ptr, static_cast<_Types&&>(_Args)...))) 
        -> decltype(::std:: invoke(*_Ptr, static_cast<_Types&&>(_Args)...)) {
        return ::std:: invoke(*_Ptr, static_cast<_Types&&>(_Args)...);
    }
};


template <class _Ty>
reference_wrapper(_Ty&) -> reference_wrapper<_Ty>;
#line 1834 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"

template <class _Ty>
[[nodiscard]] constexpr reference_wrapper<_Ty> ref(_Ty& _Val) noexcept {
    return reference_wrapper<_Ty>(_Val);
}

template <class _Ty>
void ref(const _Ty&&) = delete;

template <class _Ty>
[[nodiscard]] constexpr reference_wrapper<_Ty> ref(reference_wrapper<_Ty> _Val) noexcept {
    return _Val;
}

template <class _Ty>
[[nodiscard]] constexpr reference_wrapper<const _Ty> cref(const _Ty& _Val) noexcept {
    return reference_wrapper<const _Ty>(_Val);
}

template <class _Ty>
void cref(const _Ty&&) = delete;

template <class _Ty>
[[nodiscard]] constexpr reference_wrapper<const _Ty> cref(reference_wrapper<_Ty> _Val) noexcept {
    return _Val;
}


template <class _Ty>
struct unwrap_reference {
    using type = _Ty;
};
template <class _Ty>
struct unwrap_reference<reference_wrapper<_Ty>> {
    using type = _Ty&;
};
template <class _Ty>
using unwrap_reference_t = typename unwrap_reference<_Ty>::type;

template <class _Ty>
using unwrap_ref_decay_t = unwrap_reference_t<decay_t<_Ty>>;
template <class _Ty>
struct unwrap_ref_decay {
    using type = unwrap_ref_decay_t<_Ty>;
};
#line 1880 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"

template <class _Ty>
struct _Is_swappable;

template <class _Ty>
struct _Is_nothrow_swappable;


template <class _Ty, enable_if_t<is_move_constructible_v<_Ty> && is_move_assignable_v<_Ty>, int> = 0>


#line 1892 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"
constexpr void swap(_Ty&, _Ty&) noexcept(is_nothrow_move_constructible_v<_Ty>&& is_nothrow_move_assignable_v<_Ty>);

template <class _Ty, size_t _Size, enable_if_t<_Is_swappable<_Ty>::value, int> = 0>
constexpr void swap(_Ty (&)[_Size], _Ty (&)[_Size]) noexcept(_Is_nothrow_swappable<_Ty>::value);

template <class _Ty1, class _Ty2, class = void>
struct _Swappable_with_helper : false_type {}; 

template <class _Ty1, class _Ty2>
struct _Swappable_with_helper<_Ty1, _Ty2, void_t<decltype(swap(::std:: declval<_Ty1>(), ::std:: declval<_Ty2>()))>>
    : true_type {}; 

template <class _Ty1, class _Ty2>
struct _Is_swappable_with
    : bool_constant<conjunction_v<_Swappable_with_helper<_Ty1, _Ty2>, _Swappable_with_helper<_Ty2, _Ty1>>> {
    
};

template <class _Ty>
struct _Is_swappable : _Is_swappable_with<add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<_Ty>>::type {
    
};

template <class _Ty1, class _Ty2>
struct _Swap_cannot_throw : bool_constant<noexcept(swap(::std:: declval<_Ty1>(), ::std:: declval<_Ty2>())) 
                                    && noexcept(swap(::std:: declval<_Ty2>(), ::std:: declval<_Ty1>()))> {
    
    
};

template <class _Ty1, class _Ty2>
struct _Is_nothrow_swappable_with
    : bool_constant<conjunction_v<_Is_swappable_with<_Ty1, _Ty2>, _Swap_cannot_throw<_Ty1, _Ty2>>> {
    
    
};

template <class _Ty>
struct _Is_nothrow_swappable
    : _Is_nothrow_swappable_with<add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<_Ty>>::type {
    
};


template <class _Ty1, class _Ty2>
struct is_swappable_with : _Is_swappable_with<_Ty1, _Ty2>::type {
    
    
};

template <class _Ty1, class _Ty2>
inline constexpr bool is_swappable_with_v =
    conjunction_v<_Swappable_with_helper<_Ty1, _Ty2>, _Swappable_with_helper<_Ty2, _Ty1>>;

template <class _Ty>
struct is_swappable : _Is_swappable<_Ty>::type {}; 

template <class _Ty>
inline constexpr bool is_swappable_v = _Is_swappable<_Ty>::value;

template <class _Ty1, class _Ty2>
struct is_nothrow_swappable_with : _Is_nothrow_swappable_with<_Ty1, _Ty2>::type {
    
    
};

template <class _Ty1, class _Ty2>
inline constexpr bool is_nothrow_swappable_with_v = _Is_nothrow_swappable_with<_Ty1, _Ty2>::value;

template <class _Ty>
struct is_nothrow_swappable : _Is_nothrow_swappable<_Ty>::type {
    
};

template <class _Ty>
inline constexpr bool is_nothrow_swappable_v = _Is_nothrow_swappable<_Ty>::value;
#line 1969 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"

namespace _Has_ADL_swap_detail {
    void swap(); 

    template <class, class = void>
    struct _Has_ADL_swap : false_type {};
    template <class _Ty>
    struct _Has_ADL_swap<_Ty, void_t<decltype(swap(::std:: declval<_Ty&>(), ::std:: declval<_Ty&>()))>> : true_type {};
} 
using _Has_ADL_swap_detail::_Has_ADL_swap;

template <class _Ty>
inline constexpr bool _Is_trivially_swappable_v = conjunction_v<is_trivially_destructible<_Ty>,
    is_trivially_move_constructible<_Ty>, is_trivially_move_assignable<_Ty>, negation<_Has_ADL_swap<_Ty>>>;


template <>
inline constexpr bool _Is_trivially_swappable_v<byte> = true;
#line 1988 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"

template <class _Ty>
struct _Is_trivially_swappable : bool_constant<_Is_trivially_swappable_v<_Ty>> {
    
};


#line 2043 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"
inline constexpr size_t _FNV_offset_basis = 2166136261U;
inline constexpr size_t _FNV_prime        = 16777619U;
#line 2046 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"

[[nodiscard]] inline size_t _Fnv1a_append_bytes(size_t _Val, const unsigned char* const _First,
    const size_t _Count) noexcept { 
    for (size_t _Idx = 0; _Idx < _Count; ++_Idx) {
        _Val ^= static_cast<size_t>(_First[_Idx]);
        _Val *= _FNV_prime;
    }

    return _Val;
}

template <class _Ty>
[[nodiscard]] size_t _Fnv1a_append_range(const size_t _Val, const _Ty* const _First,
    const _Ty* const _Last) noexcept { 
    static_assert(is_trivial_v<_Ty>, "Only trivial types can be directly hashed.");
    const auto _Firstb = reinterpret_cast<const unsigned char*>(_First);
    const auto _Lastb  = reinterpret_cast<const unsigned char*>(_Last);
    return _Fnv1a_append_bytes(_Val, _Firstb, static_cast<size_t>(_Lastb - _Firstb));
}

template <class _Kty>
[[nodiscard]] size_t _Fnv1a_append_value(
    const size_t _Val, const _Kty& _Keyval) noexcept { 
    static_assert(is_trivial_v<_Kty>, "Only trivial types can be directly hashed.");
    return _Fnv1a_append_bytes(_Val, &reinterpret_cast<const unsigned char&>(_Keyval), sizeof(_Kty));
}

template <class _Kty>
[[nodiscard]] size_t _Hash_representation(const _Kty& _Keyval) noexcept { 
    return _Fnv1a_append_value(_FNV_offset_basis, _Keyval);
}

template <class _Kty>
[[nodiscard]] size_t _Hash_array_representation(
    const _Kty* const _First, const size_t _Count) noexcept { 
    static_assert(is_trivial_v<_Kty>, "Only trivial types can be directly hashed.");
    return _Fnv1a_append_bytes(
        _FNV_offset_basis, reinterpret_cast<const unsigned char*>(_First), _Count * sizeof(_Kty));
}

template <class _Kty>
struct hash;

template <class _Kty, bool _Enabled>
struct _Conditionally_enabled_hash { 
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Kty _Unnameable_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef size_t _Unnameable_result;

    [[nodiscard]] size_t operator()(const _Kty& _Keyval) const
        noexcept(noexcept(hash<_Kty>::_Do_hash(_Keyval)))  {
        return hash<_Kty>::_Do_hash(_Keyval);
    }
};

template <class _Kty>
struct _Conditionally_enabled_hash<_Kty, false> { 
    _Conditionally_enabled_hash()                                   = delete;
    _Conditionally_enabled_hash(const _Conditionally_enabled_hash&) = delete;
    _Conditionally_enabled_hash(_Conditionally_enabled_hash&&)      = delete;
    _Conditionally_enabled_hash& operator=(const _Conditionally_enabled_hash&) = delete;
    _Conditionally_enabled_hash& operator=(_Conditionally_enabled_hash&&) = delete;
};

template <class _Kty>
struct hash
    : _Conditionally_enabled_hash<_Kty,
          !is_const_v<_Kty> && !is_volatile_v<_Kty> && (is_enum_v<_Kty> || is_integral_v<_Kty> || is_pointer_v<_Kty>)> {
    
    static size_t _Do_hash(const _Kty& _Keyval) noexcept {
        return _Hash_representation(_Keyval);
    }
};

template <>
struct hash<float> {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef float _Unnameable_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef size_t _Unnameable_result;
    [[nodiscard]] size_t operator()(const float _Keyval) const noexcept {
        return _Hash_representation(_Keyval == 0.0F ? 0.0F : _Keyval); 
    }
};

template <>
struct hash<double> {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef double _Unnameable_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef size_t _Unnameable_result;
    [[nodiscard]] size_t operator()(const double _Keyval) const noexcept {
        return _Hash_representation(_Keyval == 0.0 ? 0.0 : _Keyval); 
    }
};

template <>
struct hash<long double> {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef long double _Unnameable_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef size_t _Unnameable_result;
    [[nodiscard]] size_t operator()(const long double _Keyval) const noexcept {
        return _Hash_representation(_Keyval == 0.0L ? 0.0L : _Keyval); 
    }
};

template <>
struct hash<nullptr_t> {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef nullptr_t _Unnameable_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef size_t _Unnameable_result;
    [[nodiscard]] size_t operator()(nullptr_t) const noexcept {
        void* _Null{};
        return _Hash_representation(_Null);
    }
};

template <class _Kty, class = void>
struct _Is_nothrow_hashable : false_type {}; 

template <class _Kty>
struct _Is_nothrow_hashable<_Kty, void_t<decltype(hash<_Kty>{}(::std:: declval<const _Kty&>()))>>
    : bool_constant<noexcept(hash<_Kty>{}(::std:: declval<const _Kty&>()))> {};


template <class _FloatingType>
struct _Floating_type_traits;

template <>
struct _Floating_type_traits<float> {
    static constexpr int32_t _Mantissa_bits           = 24; 
    static constexpr int32_t _Exponent_bits           = 8; 
    static constexpr int32_t _Maximum_binary_exponent = 127; 
    static constexpr int32_t _Minimum_binary_exponent = -126; 
    static constexpr int32_t _Exponent_bias           = 127;
    static constexpr int32_t _Sign_shift              = 31; 
    static constexpr int32_t _Exponent_shift          = 23; 

    using _Uint_type = uint32_t;

    static constexpr uint32_t _Exponent_mask             = 0x000000FFu; 
    static constexpr uint32_t _Normal_mantissa_mask      = 0x00FFFFFFu; 
    static constexpr uint32_t _Denormal_mantissa_mask    = 0x007FFFFFu; 
    static constexpr uint32_t _Special_nan_mantissa_mask = 0x00400000u; 
    static constexpr uint32_t _Shifted_sign_mask         = 0x80000000u; 
    static constexpr uint32_t _Shifted_exponent_mask     = 0x7F800000u; 
};

template <>
struct _Floating_type_traits<double> {
    static constexpr int32_t _Mantissa_bits           = 53; 
    static constexpr int32_t _Exponent_bits           = 11; 
    static constexpr int32_t _Maximum_binary_exponent = 1023; 
    static constexpr int32_t _Minimum_binary_exponent = -1022; 
    static constexpr int32_t _Exponent_bias           = 1023;
    static constexpr int32_t _Sign_shift              = 63; 
    static constexpr int32_t _Exponent_shift          = 52; 

    using _Uint_type = uint64_t;

    static constexpr uint64_t _Exponent_mask             = 0x00000000000007FFu; 
    static constexpr uint64_t _Normal_mantissa_mask      = 0x001FFFFFFFFFFFFFu; 
    static constexpr uint64_t _Denormal_mantissa_mask    = 0x000FFFFFFFFFFFFFu; 
    static constexpr uint64_t _Special_nan_mantissa_mask = 0x0008000000000000u; 
    static constexpr uint64_t _Shifted_sign_mask         = 0x8000000000000000u; 
    static constexpr uint64_t _Shifted_exponent_mask     = 0x7FF0000000000000u; 
};

template <>
struct _Floating_type_traits<long double> : _Floating_type_traits<double> {};


#line 2279 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"

}


#pragma warning(pop)
#pragma pack(pop)

#line 2288 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"
#line 2289 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\type_traits"
#line 16 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\concepts"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime_new.h"


#pragma once


#pragma warning(push)
#pragma warning(disable:   4514 4820 )
#pragma warning(disable: 4985) 


extern "C++" {

#pragma pack(push, 8)


namespace std
{
    enum class align_val_t : size_t {};
}
#line 30 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime_new.h"


    namespace std
    {
        struct nothrow_t {
            explicit nothrow_t() = default;
        };

        
            extern nothrow_t const nothrow;
        #line 44 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime_new.h"
    }
#line 46 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime_new.h"

[[nodiscard]]     __declspec(allocator)
void* __cdecl operator new(
    size_t _Size
    );

[[nodiscard]]       __declspec(allocator)
void* __cdecl operator new(
    size_t _Size,
    ::std::nothrow_t const&
    ) noexcept;

[[nodiscard]]     __declspec(allocator)
void* __cdecl operator new[](
    size_t _Size
    );

[[nodiscard]]       __declspec(allocator)
void* __cdecl operator new[](
    size_t _Size,
    ::std::nothrow_t const&
    ) noexcept;

void __cdecl operator delete(
    void* _Block
    ) noexcept;

void __cdecl operator delete(
    void* _Block,
    ::std::nothrow_t const&
    ) noexcept;

void __cdecl operator delete[](
    void* _Block
    ) noexcept;

void __cdecl operator delete[](
    void* _Block,
    ::std::nothrow_t const&
    ) noexcept;

void __cdecl operator delete(
    void*  _Block,
    size_t _Size
    ) noexcept;

void __cdecl operator delete[](
    void* _Block,
    size_t _Size
    ) noexcept;


[[nodiscard]]     __declspec(allocator)
void* __cdecl operator new(
    size_t             _Size,
    ::std::align_val_t _Al
    );

[[nodiscard]]       __declspec(allocator)
void* __cdecl operator new(
    size_t                  _Size,
    ::std::align_val_t      _Al,
    ::std::nothrow_t const&
    ) noexcept;


[[nodiscard]]     __declspec(allocator)
void* __cdecl operator new[](
    size_t             _Size,
    ::std::align_val_t _Al
    );

[[nodiscard]]       __declspec(allocator)
void* __cdecl operator new[](
    size_t                  _Size,
    ::std::align_val_t      _Al,
    ::std::nothrow_t const&
    ) noexcept;

void __cdecl operator delete(
    void*              _Block,
    ::std::align_val_t _Al
    ) noexcept;

void __cdecl operator delete(
    void*                   _Block,
    ::std::align_val_t      _Al,
    ::std::nothrow_t const&
    ) noexcept;

void __cdecl operator delete[](
    void*              _Block,
    ::std::align_val_t _Al
    ) noexcept;

void __cdecl operator delete[](
    void*                   _Block,
    ::std::align_val_t      _Al,
    ::std::nothrow_t const&
    ) noexcept;

void __cdecl operator delete(
    void*              _Block,
    size_t             _Size,
    ::std::align_val_t _Al
    ) noexcept;

void __cdecl operator delete[](
    void*              _Block,
    size_t             _Size,
    ::std::align_val_t _Al
    ) noexcept;
#line 159 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime_new.h"

#pragma warning(push)
#pragma warning(disable: 4577) 
#pragma warning(disable: 4514) 

    
    [[nodiscard]]      
    inline void* __cdecl operator new(size_t _Size,   void* _Where) noexcept
    {
        (void)_Size;
        return _Where;
    }

    inline void __cdecl operator delete(void*, void*) noexcept
    {
        return;
    }
#line 177 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime_new.h"


    [[nodiscard]]      
    inline void* __cdecl operator new[](size_t _Size,
          void* _Where) noexcept
    {
        (void)_Size;
        return _Where;
    }

    inline void __cdecl operator delete[](void*, void*) noexcept
    {
    }
#line 192 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime_new.h"
#pragma warning(pop)


#pragma pack(pop)

} 
#line 200 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime_new.h"

#pragma warning(pop) 
#line 17 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\concepts"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {

template <class _Ty1, class _Ty2>
concept _Same_impl = 


    is_same_v<_Ty1, _Ty2>;
#line 34 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\concepts"

template <class _Ty1, class _Ty2>
concept same_as = _Same_impl<_Ty1, _Ty2> && _Same_impl<_Ty2, _Ty1>;

template <class _Derived, class _Base>
concept derived_from = __is_base_of(_Base, _Derived)
    && __is_convertible_to(const volatile _Derived*, const volatile _Base*);

template <class _From, class _To>
concept convertible_to = __is_convertible_to(_From, _To)
    && requires {
        static_cast<_To>(::std:: declval<_From>());
    };

template <class _From, class _To>
concept _Implicitly_convertible_to = is_convertible_v<_From, _To>;

template <class _Ty1, class _Ty2>
concept common_reference_with =
    requires {
        typename common_reference_t<_Ty1, _Ty2>;
        typename common_reference_t<_Ty2, _Ty1>;
    }
    && same_as<common_reference_t<_Ty1, _Ty2>, common_reference_t<_Ty2, _Ty1>>
    && convertible_to<_Ty1, common_reference_t<_Ty1, _Ty2>>
    && convertible_to<_Ty2, common_reference_t<_Ty1, _Ty2>>;

template <class _Ty1, class _Ty2>
concept common_with =
    requires {
        typename common_type_t<_Ty1, _Ty2>;
        typename common_type_t<_Ty2, _Ty1>;
    }
    && same_as<common_type_t<_Ty1, _Ty2>, common_type_t<_Ty2, _Ty1>>
    && requires {
        static_cast<common_type_t<_Ty1, _Ty2>>(::std:: declval<_Ty1>());
        static_cast<common_type_t<_Ty1, _Ty2>>(::std:: declval<_Ty2>());
    }
    && common_reference_with<add_lvalue_reference_t<const _Ty1>, add_lvalue_reference_t<const _Ty2>>
    && common_reference_with<add_lvalue_reference_t<common_type_t<_Ty1, _Ty2>>,
        common_reference_t<add_lvalue_reference_t<const _Ty1>, add_lvalue_reference_t<const _Ty2>>>;

template <class _Ty>
concept integral = is_integral_v<_Ty>;

template <class _Ty>
concept signed_integral = integral<_Ty> && static_cast<_Ty>(-1) < static_cast<_Ty>(0);

template <class _Ty>
concept unsigned_integral = integral<_Ty> && !signed_integral<_Ty>;

template <class _Ty>
concept floating_point = is_floating_point_v<_Ty>;

template <class _LTy, class _RTy>
concept assignable_from = is_lvalue_reference_v<_LTy>
    && common_reference_with<const remove_reference_t<_LTy>&, const remove_reference_t<_RTy>&>
    && requires(_LTy _Left, _RTy&& _Right) {
        { _Left = static_cast<_RTy&&>(_Right) } -> same_as<_LTy>;
    };


template <class _Ty>
concept destructible = __is_nothrow_destructible(_Ty);

template <class _Ty, class... _ArgTys>
concept constructible_from = destructible<_Ty>
    && __is_constructible(_Ty, _ArgTys...);

template <class _Ty>
concept default_initializable = constructible_from<_Ty>
    && requires {
        _Ty{};
        ::new (static_cast<void*>(nullptr)) _Ty; 
    };

template <class _Ty>
concept move_constructible = constructible_from<_Ty, _Ty> && convertible_to<_Ty, _Ty>;

template <class _Ty>
concept _Has_class_or_enum_type = __is_class(remove_reference_t<_Ty>) || __is_enum(remove_reference_t<_Ty>)
    || __is_union(remove_reference_t<_Ty>);

namespace ranges {
    namespace _Swap {
        template <class _Ty>
        void swap(_Ty&, _Ty&) = delete;

        template <class _Ty1, class _Ty2>
        concept _Use_ADL_swap = (_Has_class_or_enum_type<_Ty1> || _Has_class_or_enum_type<_Ty2>)
            && requires(_Ty1&& __t, _Ty2&& __u) {
                swap(static_cast<_Ty1&&>(__t), static_cast<_Ty2&&>(__u));
            };

        struct _Cpo {
            template <class _Ty1, class _Ty2>
                requires _Use_ADL_swap<_Ty1, _Ty2>
            constexpr void operator()(_Ty1&& __t, _Ty2&& __u) const
                noexcept(noexcept(swap(static_cast<_Ty1&&>(__t), static_cast<_Ty2&&>(__u)))) {
                swap(static_cast<_Ty1&&>(__t), static_cast<_Ty2&&>(__u));
            }

            template <class _Ty>
                requires (!_Use_ADL_swap<_Ty&, _Ty&> && move_constructible<_Ty> && assignable_from<_Ty&, _Ty>)
            constexpr void operator()(_Ty& __x, _Ty& __y) const
                noexcept(is_nothrow_move_constructible_v<_Ty> && is_nothrow_move_assignable_v<_Ty>) {
                _Ty __tmp(static_cast<_Ty&&>(__x));
                __x = static_cast<_Ty&&>(__y);
                __y = static_cast<_Ty&&>(__tmp);
            }

            template <class _Ty1, class _Ty2, size_t _Size>
            constexpr void operator()(_Ty1 (&__t)[_Size], _Ty2 (&__u)[_Size]) const
                noexcept(noexcept((*this)(__t[0], __u[0])))
                requires requires { (*this)(__t[0], __u[0]); } {
                for (size_t __i = 0; __i < _Size; ++__i) {
                    (*this)(__t[__i], __u[__i]);
                }
            }
        };
    } 

    inline namespace _Cpos {
        inline constexpr _Swap::_Cpo swap;
    }
} 

template <class _Ty>
concept swappable = requires(_Ty& __x, _Ty& __y) {
    ::std::ranges:: swap(__x, __y);
};

template <class _Ty1, class _Ty2>
concept swappable_with = common_reference_with<_Ty1, _Ty2>
    && requires(_Ty1&& __t, _Ty2&& __u) {
        ::std::ranges:: swap(static_cast<_Ty1&&>(__t), static_cast<_Ty1&&>(__t));
        ::std::ranges:: swap(static_cast<_Ty2&&>(__u), static_cast<_Ty2&&>(__u));
        ::std::ranges:: swap(static_cast<_Ty1&&>(__t), static_cast<_Ty2&&>(__u));
        ::std::ranges:: swap(static_cast<_Ty2&&>(__u), static_cast<_Ty1&&>(__t));
    };

template <class _Ty>
concept copy_constructible = move_constructible<_Ty>
    && constructible_from<_Ty, _Ty&> && convertible_to<_Ty&, _Ty>
    && constructible_from<_Ty, const _Ty&> && convertible_to<const _Ty&, _Ty>
    && constructible_from<_Ty, const _Ty> && convertible_to<const _Ty, _Ty>;

template <class _Ty>
concept _Boolean_testable_impl = convertible_to<_Ty, bool>;

template <class _Ty>
concept _Boolean_testable = _Boolean_testable_impl<_Ty>
    && requires(_Ty&& __t) {
        { !static_cast<_Ty&&>(__t) } -> _Boolean_testable_impl;
    };

template <class _Ty1, class _Ty2>
concept _Half_equality_comparable =
    requires(const remove_reference_t<_Ty1>& __x, const remove_reference_t<_Ty2>& __y) {
        { __x == __y } -> _Boolean_testable;
        { __x != __y } -> _Boolean_testable;
    };

template <class _Ty1, class _Ty2>
concept _Weakly_equality_comparable_with =
    _Half_equality_comparable<_Ty1, _Ty2> && _Half_equality_comparable<_Ty2, _Ty1>;

template <class _Ty>
concept equality_comparable = _Half_equality_comparable<_Ty, _Ty>;

template <class _Ty1, class _Ty2>
concept equality_comparable_with = equality_comparable<_Ty1> && equality_comparable<_Ty2>
    && common_reference_with<const remove_reference_t<_Ty1>&, const remove_reference_t<_Ty2>&>
    && equality_comparable<common_reference_t<const remove_reference_t<_Ty1>&, const remove_reference_t<_Ty2>&>>
    && _Weakly_equality_comparable_with<_Ty1, _Ty2>;

template <class _Ty1, class _Ty2>
concept _Half_ordered = requires(const remove_reference_t<_Ty1>& __t, const remove_reference_t<_Ty2>& __u) {
    { __t <  __u } -> _Boolean_testable;
    { __t >  __u } -> _Boolean_testable;
    { __t <= __u } -> _Boolean_testable;
    { __t >= __u } -> _Boolean_testable;
};

template <class _Ty1, class _Ty2>
concept _Partially_ordered_with = _Half_ordered<_Ty1, _Ty2> && _Half_ordered<_Ty2, _Ty1>;

template <class _Ty>
concept totally_ordered = equality_comparable<_Ty> && _Half_ordered<_Ty, _Ty>;

template <class _Ty1, class _Ty2>
concept totally_ordered_with = totally_ordered<_Ty1> && totally_ordered<_Ty2>
    && equality_comparable_with<_Ty1, _Ty2>
    && totally_ordered<common_reference_t<const remove_reference_t<_Ty1>&, const remove_reference_t<_Ty2>&>>
    && _Partially_ordered_with<_Ty1, _Ty2>;

template <class _Ty>
concept movable = is_object_v<_Ty>
    && move_constructible<_Ty>
    && assignable_from<_Ty&, _Ty>
    && swappable<_Ty>;

template <class _Ty>
concept copyable = copy_constructible<_Ty>
    && movable<_Ty>
    && assignable_from<_Ty&, _Ty&>
    && assignable_from<_Ty&, const _Ty&>
    && assignable_from<_Ty&, const _Ty>;

template <class _Ty>
concept semiregular = copyable<_Ty> && default_initializable<_Ty>;

template <class _Ty>
concept regular = semiregular<_Ty> && equality_comparable<_Ty>;

template <class _FTy, class... _ArgTys>
concept invocable = requires(_FTy&& _Fn, _ArgTys&&... _Args) {
    ::std:: invoke(static_cast<_FTy&&>(_Fn), static_cast<_ArgTys&&>(_Args)...);
};

template <class _FTy, class... _ArgTys>
concept regular_invocable = invocable<_FTy, _ArgTys...>;

template <class _FTy, class... _ArgTys>
concept predicate = regular_invocable<_FTy, _ArgTys...>
    && _Boolean_testable<invoke_result_t<_FTy, _ArgTys...>>;

template <class _FTy, class _Ty1, class _Ty2>
concept relation =
       predicate<_FTy, _Ty1, _Ty1>
    && predicate<_FTy, _Ty2, _Ty2>
    && predicate<_FTy, _Ty1, _Ty2>
    && predicate<_FTy, _Ty2, _Ty1>;

template <class _FTy, class _Ty1, class _Ty2>
concept equivalence_relation = relation<_FTy, _Ty1, _Ty2>;

template <class _FTy, class _Ty1, class _Ty2>
concept strict_weak_order = relation<_FTy, _Ty1, _Ty2>;


template <class _Ty>
struct _Choice_t {
    _Ty _Strategy  = _Ty{};
    bool _No_throw = false;
};

}


#pragma warning(pop)
#pragma pack(pop)
#line 290 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\concepts"
#line 291 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\concepts"
#line 292 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\concepts"
#line 11 "all-std.cxx"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\coroutine"


#pragma once


#pragma detect_mismatch("_COROUTINE_ABI", "2")
#line 23 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\coroutine"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\compare"


#pragma once


#line 15 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\compare"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\bit"


#pragma once


#line 14 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\bit"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin0.h"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin0.inl.h"


#pragma once


#pragma warning(push)
#pragma warning(disable:   4514 4820 )


extern "C" {
#line 26 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin0.inl.h"


#line 57 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin0.inl.h"


#line 60 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin0.inl.h"


#line 67 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin0.inl.h"


#line 72 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin0.inl.h"


#line 77 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin0.inl.h"


#line 82 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin0.inl.h"


#line 87 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin0.inl.h"

#line 89 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin0.inl.h"


#line 94 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin0.inl.h"


#line 99 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin0.inl.h"


#line 104 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin0.inl.h"


#line 109 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin0.inl.h"


#line 114 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin0.inl.h"


unsigned char _BitScanForward(unsigned long * _Index, unsigned long _Mask);


unsigned char _BitScanReverse(unsigned long * _Index, unsigned long _Mask);


unsigned char _bittest(long const *, long);


long _InterlockedAnd(long volatile * _Value, long _Mask);
short _InterlockedAnd16(short volatile * _Value, short _Mask);


__int64 _interlockedand64(__int64 volatile * _Value, __int64 _Mask);


char _InterlockedAnd8(char volatile * _Value, char _Mask);


long __cdecl _InterlockedCompareExchange(long volatile * _Destination, long _Exchange, long _Comparand);

short _InterlockedCompareExchange16(short volatile * _Destination, short _Exchange, short _Comparand);


__int64 _InterlockedCompareExchange64(__int64 volatile * _Destination, __int64 _Exchange, __int64 _Comparand);


char _InterlockedCompareExchange8(char volatile * _Destination, char _Exchange, char _Comparand);


long __cdecl _InterlockedDecrement(long volatile * _Addend);

short _InterlockedDecrement16(short volatile * _Addend);

__int64 _interlockeddecrement64(__int64 volatile * _Addend);
long __cdecl _InterlockedExchange(long volatile * _Target, long _Value);

short _InterlockedExchange16(short volatile * _Target, short _Value);


__int64 _interlockedexchange64(__int64 volatile * _Target, __int64 _Value);


char _InterlockedExchange8(char volatile * _Target, char _Value);


long __cdecl _InterlockedExchangeAdd(long volatile * _Addend, long _Value);
short _InterlockedExchangeAdd16(short volatile * _Addend, short _Value);


__int64 _interlockedexchangeadd64(__int64 volatile * _Addend, __int64 _Value);


char _InterlockedExchangeAdd8(char volatile * _Addend, char _Value);


long __cdecl _InterlockedIncrement(long volatile * _Addend);

short _InterlockedIncrement16(short volatile * _Addend);

__int64 _interlockedincrement64(__int64 volatile * _Addend);

long _InterlockedOr(long volatile * _Value, long _Mask);
short _InterlockedOr16(short volatile * _Value, short _Mask);


__int64 _interlockedor64(__int64 volatile * _Value, __int64 _Mask);


char _InterlockedOr8(char volatile * _Value, char _Mask);


long _InterlockedXor(long volatile * _Value, long _Mask);
short _InterlockedXor16(short volatile * _Value, short _Mask);


__int64 _interlockedxor64(__int64 volatile * _Value, __int64 _Mask);


char _InterlockedXor8(char volatile * _Value, char _Mask);


void _ReadWriteBarrier(void);
__int16 __iso_volatile_load16(const volatile __int16 *);
__int32 __iso_volatile_load32(const volatile __int32 *);
__int64 __iso_volatile_load64(const volatile __int64 *);
__int8 __iso_volatile_load8(const volatile __int8 *);
void __iso_volatile_store16(volatile __int16 *, __int16);
void __iso_volatile_store32(volatile __int32 *, __int32);
void __iso_volatile_store64(volatile __int64 *, __int64);
void __iso_volatile_store8(volatile __int8 *, __int8);


void _mm_pause(void);
unsigned int __lzcnt(unsigned int);
unsigned short __lzcnt16(unsigned short);

unsigned int __popcnt(unsigned int);
unsigned short __popcnt16(unsigned short);

unsigned int __cdecl _rotl(  unsigned int _Value,   int _Shift);
unsigned short __cdecl _rotl16(unsigned short _Value, unsigned char _Shift);
unsigned __int64 __cdecl _rotl64(  unsigned __int64 _Value,   int _Shift);
unsigned char __cdecl _rotl8(unsigned char _Value, unsigned char _Shift);
unsigned int __cdecl _rotr(  unsigned int _Value,   int _Shift);
unsigned short __cdecl _rotr16(unsigned short _Value, unsigned char _Shift);
unsigned __int64 __cdecl _rotr64(  unsigned __int64 _Value,   int _Shift);
unsigned char __cdecl _rotr8(unsigned char _Value, unsigned char _Shift);


unsigned int _tzcnt_u32(unsigned int);

#line 282 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin0.inl.h"


double __ceil(double);
float __ceilf(float);
double __floor(double);
float __floorf(float);
double __round(double);
float __roundf(float);
double __trunc(double);
float __truncf(float);
double __copysign(double, double);
float __copysignf(float, float);
unsigned __signbitvalue(double);
unsigned __signbitvaluef(float);


constexpr void * __cdecl __builtin_assume_aligned(const void *, size_t, ...) noexcept;


#line 305 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin0.inl.h"
#line 306 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin0.inl.h"


}
#line 316 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin0.inl.h"
#pragma warning(pop) 
#line 318 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin0.inl.h"
#line 20 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin0.h"
#line 21 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin0.h"
#line 16 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\bit"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\isa_availability.h"


enum ISA_AVAILABILITY
{
    __ISA_AVAILABLE_X86   = 0,
    __ISA_AVAILABLE_SSE2  = 1,
    __ISA_AVAILABLE_SSE42 = 2,
    __ISA_AVAILABLE_AVX   = 3,
    __ISA_AVAILABLE_ENFSTRG = 4,
    __ISA_AVAILABLE_AVX2 = 5,
    __ISA_AVAILABLE_AVX512 = 6,

    __ISA_AVAILABLE_ARMNT   = 0,   
    __ISA_AVAILABLE_NEON    = 1,   
    __ISA_AVAILABLE_NEON_ARM64 = 2,
                                   
};


#line 46 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\isa_availability.h"

#line 48 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\isa_availability.h"
#line 17 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\bit"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cfloat"


#pragma once


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\float.h"


#pragma once


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


        #line 32 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\float.h"
    #line 33 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\float.h"
#line 34 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\float.h"


#line 59 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\float.h"
    

#line 62 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\float.h"
#line 63 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\float.h"


#line 220 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\float.h"


 unsigned int __cdecl _clearfp(void);

#pragma warning(push)
#pragma warning(disable: 4141) 

 __declspec(deprecated("This function or variable may be unsafe. Consider using " "_controlfp_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
 unsigned int __cdecl _controlfp(
      unsigned int _NewValue,
      unsigned int _Mask
    );

#pragma warning(pop)


 void __cdecl _set_controlfp(
      unsigned int _NewValue,
      unsigned int _Mask
    );


 errno_t __cdecl _controlfp_s(
      unsigned int* _CurrentState,
           unsigned int  _NewValue,
           unsigned int  _Mask
    );


 unsigned int __cdecl _statusfp(void);


 void __cdecl _fpreset(void);


     void __cdecl _statusfp2(
          unsigned int* _X86Status,
          unsigned int* _SSE2Status
        );

#line 272 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\float.h"


 unsigned int __cdecl _control87(
      unsigned int _NewValue,
      unsigned int _Mask
    );


     int __cdecl __control87_2(
               unsigned int  _NewValue,
               unsigned int  _Mask,
          unsigned int* _X86ControlWord,
          unsigned int* _Sse2ControlWord
        );
#line 291 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\float.h"


 int* __cdecl __fpecode(void);


 int __cdecl __fpe_flt_rounds(void);


   double __cdecl _copysign(  double _Number,   double _Sign);
   double __cdecl _chgsign(  double _X);
   double __cdecl _scalb(  double _X,   long _Y);
   double __cdecl _logb(  double _X);
   double __cdecl _nextafter(  double _X,   double _Y);
   int    __cdecl _finite(  double _X);
   int    __cdecl _isnan(  double _X);
   int    __cdecl _fpclass(  double _X);


     void __cdecl fpreset(void);

    
#line 403 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\float.h"


} __pragma(pack(pop))

#pragma warning(pop) 
#line 410 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\float.h"
#line 12 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cfloat"
#line 13 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cfloat"
#line 12 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\climits"


#pragma once


#line 15 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\climits"
#line 16 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\climits"
#line 13 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cwchar"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cstdio"


#pragma once


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"


#pragma once


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"


#pragma once


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_stdio_config.h"


#pragma once


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


#line 21 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_stdio_config.h"


#line 26 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_stdio_config.h"
    
#line 28 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_stdio_config.h"


#line 37 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_stdio_config.h"
#line 38 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_stdio_config.h"


#line 62 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_stdio_config.h"


#line 67 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_stdio_config.h"

    
            #pragma detect_mismatch("_CRT_STDIO_ISO_WIDE_SPECIFIERS", "0")
        #line 74 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_stdio_config.h"
    #line 75 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_stdio_config.h"
#line 76 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_stdio_config.h"


#line 83 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_stdio_config.h"


    __declspec(noinline) __inline unsigned __int64* __cdecl __local_stdio_printf_options(void)
    {
        static unsigned __int64 _OptionsStorage;
        return &_OptionsStorage;
    }

    
    __declspec(noinline) __inline unsigned __int64* __cdecl __local_stdio_scanf_options(void)
    {
        static unsigned __int64 _OptionsStorage;
        return &_OptionsStorage;
    }
#line 105 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_stdio_config.h"


#line 109 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_stdio_config.h"


} __pragma(pack(pop))

#pragma warning(pop) 
#line 14 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


    typedef struct _iobuf
    {
        void* _Placeholder;
    } FILE;
#line 33 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

 FILE* __cdecl __acrt_iob_func(unsigned _Ix);


     wint_t __cdecl fgetwc(
          FILE* _Stream
        );

    
     wint_t __cdecl _fgetwchar(void);

    
     wint_t __cdecl fputwc(
             wchar_t _Character,
          FILE*   _Stream);

    
     wint_t __cdecl _fputwchar(
          wchar_t _Character
        );

     
     wint_t __cdecl getwc(
          FILE* _Stream
        );

     
     wint_t __cdecl getwchar(void);


     wchar_t* __cdecl fgetws(
          wchar_t* _Buffer,
                                  int      _BufferCount,
                               FILE*    _Stream
        );

    
     int __cdecl fputws(
           wchar_t const* _Buffer,
          FILE*          _Stream
        );

    
     wchar_t* __cdecl _getws_s(
          wchar_t* _Buffer,
                                  size_t   _BufferCount
        );

    extern "C++" { template <size_t _Size> inline   wchar_t* __cdecl _getws_s( wchar_t (&_Buffer)[_Size]) throw() { return _getws_s(_Buffer, _Size); } }
#line 103 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
     wint_t __cdecl putwc(
             wchar_t _Character,
          FILE*   _Stream
        );

    
     wint_t __cdecl putwchar(
          wchar_t _Character
        );

    
     int __cdecl _putws(
          wchar_t const* _Buffer
        );

    
     wint_t __cdecl ungetwc(
             wint_t _Character,
          FILE*  _Stream
        );

     
     FILE * __cdecl _wfdopen(
            int            _FileHandle,
          wchar_t const* _Mode
        );

      __declspec(deprecated("This function or variable may be unsafe. Consider using " "_wfopen_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
     FILE* __cdecl _wfopen(
          wchar_t const* _FileName,
          wchar_t const* _Mode
        );

    
     errno_t __cdecl _wfopen_s(
          FILE**         _Stream,
                             wchar_t const* _FileName,
                             wchar_t const* _Mode
        );

     
    __declspec(deprecated("This function or variable may be unsafe. Consider using " "_wfreopen_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
     FILE* __cdecl _wfreopen(
           wchar_t const* _FileName,
           wchar_t const* _Mode,
          FILE*          _OldStream
        );

    
     errno_t __cdecl _wfreopen_s(
          FILE**         _Stream,
                             wchar_t const* _FileName,
                             wchar_t const* _Mode,
                            FILE*          _OldStream
        );

     
     FILE* __cdecl _wfsopen(
          wchar_t const* _FileName,
          wchar_t const* _Mode,
            int            _ShFlag
        );

     void __cdecl _wperror(
          wchar_t const* _ErrorMessage
        );

    
         FILE* __cdecl _wpopen(
              wchar_t const* _Command,
              wchar_t const* _Mode
            );

    #line 181 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     int __cdecl _wremove(
          wchar_t const* _FileName
        );

    
     __declspec(allocator) wchar_t* __cdecl _wtempnam(
          wchar_t const* _Directory,
          wchar_t const* _FilePrefix
        );

    
     errno_t __cdecl _wtmpnam_s(
          wchar_t* _Buffer,
                                  size_t   _BufferCount
        );

    extern "C++" { template <size_t _Size> inline   errno_t __cdecl _wtmpnam_s( wchar_t (&_Buffer)[_Size]) throw() { return _wtmpnam_s(_Buffer, _Size); } }
#line 209 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    __declspec(deprecated("This function or variable may be unsafe. Consider using " "_wtmpnam_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))   wchar_t* __cdecl _wtmpnam(  wchar_t *_Buffer);
#line 215 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"


     wint_t __cdecl _fgetwc_nolock(
          FILE* _Stream
        );

    
     wint_t __cdecl _fputwc_nolock(
             wchar_t _Character,
          FILE*   _Stream
        );

    
     wint_t __cdecl _getwc_nolock(
          FILE* _Stream
        );

    
     wint_t __cdecl _putwc_nolock(
             wchar_t _Character,
          FILE*   _Stream
        );

    
     wint_t __cdecl _ungetwc_nolock(
             wint_t _Character,
          FILE*  _Stream
        );

    
#line 256 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"


     int __cdecl __stdio_common_vfwprintf(
                                             unsigned __int64 _Options,
                                          FILE*            _Stream,
            wchar_t const*   _Format,
                                         _locale_t        _Locale,
                                                va_list          _ArgList
        );

    
     int __cdecl __stdio_common_vfwprintf_s(
                                             unsigned __int64 _Options,
                                          FILE*            _Stream,
            wchar_t const*   _Format,
                                         _locale_t        _Locale,
                                                va_list          _ArgList
        );

    
     int __cdecl __stdio_common_vfwprintf_p(
                                             unsigned __int64 _Options,
                                          FILE*            _Stream,
            wchar_t const*   _Format,
                                         _locale_t        _Locale,
                                                va_list          _ArgList
        );

    
    __inline int __cdecl _vfwprintf_l(
                                          FILE*          const _Stream,
            wchar_t const* const _Format,
                                         _locale_t      const _Locale,
                                                va_list              _ArgList
        )
    

#line 308 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return __stdio_common_vfwprintf((*__local_stdio_printf_options()), _Stream, _Format, _Locale, _ArgList);
    }
    #line 312 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
    __inline int __cdecl vfwprintf(
                                FILE*          const _Stream,
            wchar_t const* const _Format,
                                      va_list              _ArgList
        )
    

#line 322 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return _vfwprintf_l(_Stream, _Format, 0, _ArgList);
    }
    #line 326 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
    __inline int __cdecl _vfwprintf_s_l(
                                          FILE*          const _Stream,
            wchar_t const* const _Format,
                                         _locale_t      const _Locale,
                                                va_list              _ArgList
        )
    

#line 337 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return __stdio_common_vfwprintf_s((*__local_stdio_printf_options()), _Stream, _Format, _Locale, _ArgList);
    }
    #line 341 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
        __inline int __cdecl vfwprintf_s(
                                    FILE*          const _Stream,
                wchar_t const* const _Format,
                                          va_list              _ArgList
            )
    

#line 353 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
        {
            return _vfwprintf_s_l(_Stream, _Format, 0, _ArgList);
        }
    #line 357 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    #line 359 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
    __inline int __cdecl _vfwprintf_p_l(
                                          FILE*          const _Stream,
            wchar_t const* const _Format,
                                         _locale_t      const _Locale,
                                                va_list              _ArgList
        )
    

#line 370 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return __stdio_common_vfwprintf_p((*__local_stdio_printf_options()), _Stream, _Format, _Locale, _ArgList);
    }
    #line 374 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
    __inline int __cdecl _vfwprintf_p(
                                FILE*          const _Stream,
            wchar_t const* const _Format,
                                      va_list              _ArgList
        )
    

#line 384 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return _vfwprintf_p_l(_Stream, _Format, 0, _ArgList);
    }
    #line 388 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
    __inline int __cdecl _vwprintf_l(
            wchar_t const* const _Format,
                                         _locale_t      const _Locale,
                                                va_list              _ArgList
        )
    

#line 398 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return _vfwprintf_l((__acrt_iob_func(1)), _Format, _Locale, _ArgList);
    }
    #line 402 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
    __inline int __cdecl vwprintf(
            wchar_t const* const _Format,
                                      va_list              _ArgList
        )
    

#line 411 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return _vfwprintf_l((__acrt_iob_func(1)), _Format, 0, _ArgList);
    }
    #line 415 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
    __inline int __cdecl _vwprintf_s_l(
            wchar_t const* const _Format,
                                         _locale_t      const _Locale,
                                                va_list              _ArgList
        )
    

#line 425 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return _vfwprintf_s_l((__acrt_iob_func(1)), _Format, _Locale, _ArgList);
    }
    #line 429 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
        __inline int __cdecl vwprintf_s(
                wchar_t const* const _Format,
                                          va_list              _ArgList
            )
    

#line 440 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
        {
            return _vfwprintf_s_l((__acrt_iob_func(1)), _Format, 0, _ArgList);
        }
    #line 444 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    #line 446 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
    __inline int __cdecl _vwprintf_p_l(
            wchar_t const* const _Format,
                                         _locale_t      const _Locale,
                                                va_list              _ArgList
        )
    

#line 456 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return _vfwprintf_p_l((__acrt_iob_func(1)), _Format, _Locale, _ArgList);
    }
    #line 460 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
    __inline int __cdecl _vwprintf_p(
            wchar_t const* const _Format,
                                      va_list              _ArgList
        )
    

#line 469 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return _vfwprintf_p_l((__acrt_iob_func(1)), _Format, 0, _ArgList);
    }
    #line 473 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
    __inline int __cdecl _fwprintf_l(
                                          FILE*          const _Stream,
            wchar_t const* const _Format,
                                         _locale_t      const _Locale,
        ...)
    

#line 483 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfwprintf_l(_Stream, _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 492 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
    __inline int __cdecl fwprintf(
                                FILE*          const _Stream,
            wchar_t const* const _Format,
        ...)
    

#line 501 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfwprintf_l(_Stream, _Format, 0, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 510 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
    __inline int __cdecl _fwprintf_s_l(
                                          FILE*          const _Stream,
            wchar_t const* const _Format,
                                         _locale_t      const _Locale,
        ...)
    

#line 520 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfwprintf_s_l(_Stream, _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 529 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
        __inline int __cdecl fwprintf_s(
                                    FILE*          const _Stream,
                wchar_t const* const _Format,
            ...)
    

#line 540 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
        {
            int _Result;
            va_list _ArgList;
            ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
            _Result = _vfwprintf_s_l(_Stream, _Format, 0, _ArgList);
            ((void)(_ArgList = (va_list)0));
            return _Result;
        }
    #line 549 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    #line 551 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
    __inline int __cdecl _fwprintf_p_l(
                                          FILE*          const _Stream,
            wchar_t const* const _Format,
                                         _locale_t      const _Locale,
        ...)
    

#line 561 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfwprintf_p_l(_Stream, _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 570 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
    __inline int __cdecl _fwprintf_p(
                                FILE*          const _Stream,
            wchar_t const* const _Format,
        ...)
    

#line 579 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfwprintf_p_l(_Stream, _Format, 0, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 588 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
    __inline int __cdecl _wprintf_l(
            wchar_t const* const _Format,
                                         _locale_t      const _Locale,
        ...)
    

#line 597 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfwprintf_l((__acrt_iob_func(1)), _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 606 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
    __inline int __cdecl wprintf(
            wchar_t const* const _Format,
        ...)
    

#line 614 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfwprintf_l((__acrt_iob_func(1)), _Format, 0, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 623 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
    __inline int __cdecl _wprintf_s_l(
            wchar_t const* const _Format,
                                         _locale_t      const _Locale,
        ...)
    

#line 632 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfwprintf_s_l((__acrt_iob_func(1)), _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 641 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
        __inline int __cdecl wprintf_s(
                wchar_t const* const _Format,
            ...)
    

#line 651 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
        {
            int _Result;
            va_list _ArgList;
            ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
            _Result = _vfwprintf_s_l((__acrt_iob_func(1)), _Format, 0, _ArgList);
            ((void)(_ArgList = (va_list)0));
            return _Result;
        }
    #line 660 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    #line 662 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
    __inline int __cdecl _wprintf_p_l(
            wchar_t const* const _Format,
                                         _locale_t      const _Locale,
        ...)
    

#line 671 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfwprintf_p_l((__acrt_iob_func(1)), _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 680 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
    __inline int __cdecl _wprintf_p(
            wchar_t const* const _Format,
        ...)
    

#line 688 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfwprintf_p_l((__acrt_iob_func(1)), _Format, 0, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 697 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"


     int __cdecl __stdio_common_vfwscanf(
                                            unsigned __int64 _Options,
                                         FILE*            _Stream,
            wchar_t const*   _Format,
                                        _locale_t        _Locale,
                                               va_list          _ArgList
        );

    
    __inline int __cdecl _vfwscanf_l(
          FILE*                                const _Stream,
            wchar_t const* const _Format,
                               _locale_t      const _Locale,
                                      va_list              _ArgList
        )
    

#line 723 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return __stdio_common_vfwscanf(
            (*__local_stdio_scanf_options ()),
            _Stream, _Format, _Locale, _ArgList);
    }
    #line 729 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
    __inline int __cdecl vfwscanf(
          FILE*                                const _Stream,
            wchar_t const* const _Format,
                                      va_list              _ArgList
        )
    

#line 739 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return _vfwscanf_l(_Stream, _Format, 0, _ArgList);
    }
    #line 743 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
    __inline int __cdecl _vfwscanf_s_l(
                                FILE*          const _Stream,
            wchar_t const* const _Format,
                               _locale_t      const _Locale,
                                      va_list              _ArgList
        )
    

#line 754 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return __stdio_common_vfwscanf(
            (*__local_stdio_scanf_options ()) | (1ULL << 0),
            _Stream, _Format, _Locale, _ArgList);
    }
    #line 760 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
        __inline int __cdecl vfwscanf_s(
                                    FILE*          const _Stream,
                wchar_t const* const _Format,
                                          va_list              _ArgList
            )
    

#line 772 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
        {
            return _vfwscanf_s_l(_Stream, _Format, 0, _ArgList);
        }
    #line 776 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    #line 778 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    __inline int __cdecl _vwscanf_l(
            wchar_t const* const _Format,
                               _locale_t      const _Locale,
                                      va_list              _ArgList
        )
    

#line 787 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return _vfwscanf_l((__acrt_iob_func(0)), _Format, _Locale, _ArgList);
    }
    #line 791 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
    __inline int __cdecl vwscanf(
            wchar_t const* const _Format,
                                      va_list              _ArgList
        )
    

#line 800 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return _vfwscanf_l((__acrt_iob_func(0)), _Format, 0, _ArgList);
    }
    #line 804 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
    __inline int __cdecl _vwscanf_s_l(
            wchar_t const* const _Format,
                               _locale_t      const _Locale,
                                      va_list              _ArgList
        )
    

#line 814 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return _vfwscanf_s_l((__acrt_iob_func(0)), _Format, _Locale, _ArgList);
    }
    #line 818 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
        __inline int __cdecl vwscanf_s(
                wchar_t const* const _Format,
                                          va_list              _ArgList
            )
    

#line 829 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
        {
            return _vfwscanf_s_l((__acrt_iob_func(0)), _Format, 0, _ArgList);
        }
    #line 833 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    #line 835 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     __declspec(deprecated("This function or variable may be unsafe. Consider using " "_fwscanf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    __inline int __cdecl _fwscanf_l(
                                         FILE*          const _Stream,
            wchar_t const* const _Format,
                                        _locale_t      const _Locale,
        ...)
    

#line 845 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfwscanf_l(_Stream, _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 854 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

      __declspec(deprecated("This function or variable may be unsafe. Consider using " "fwscanf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    __inline int __cdecl fwscanf(
                               FILE*          const _Stream,
            wchar_t const* const _Format,
        ...)
    

#line 863 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfwscanf_l(_Stream, _Format, 0, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 872 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
    __inline int __cdecl _fwscanf_s_l(
                                           FILE*          const _Stream,
            wchar_t const* const _Format,
                                          _locale_t      const _Locale,
        ...)
    

#line 882 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfwscanf_s_l(_Stream, _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 891 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
        __inline int __cdecl fwscanf_s(
                                     FILE*          const _Stream,
                wchar_t const* const _Format,
            ...)
    

#line 902 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
        {
            int _Result;
            va_list _ArgList;
            ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
            _Result = _vfwscanf_s_l(_Stream, _Format, 0, _ArgList);
            ((void)(_ArgList = (va_list)0));
            return _Result;
        }
    #line 911 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    #line 913 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     __declspec(deprecated("This function or variable may be unsafe. Consider using " "_wscanf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    __inline int __cdecl _wscanf_l(
            wchar_t const* const _Format,
                                        _locale_t      const _Locale,
        ...)
    

#line 922 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfwscanf_l((__acrt_iob_func(0)), _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 931 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

      __declspec(deprecated("This function or variable may be unsafe. Consider using " "wscanf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    __inline int __cdecl wscanf(
            wchar_t const* const _Format,
        ...)
    

#line 939 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfwscanf_l((__acrt_iob_func(0)), _Format, 0, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 948 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
    __inline int __cdecl _wscanf_s_l(
            wchar_t const* const _Format,
                                          _locale_t      const _Locale,
        ...)
    

#line 957 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfwscanf_s_l((__acrt_iob_func(0)), _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 966 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
        __inline int __cdecl wscanf_s(
                wchar_t const* const _Format,
            ...)
    

#line 976 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
        {
            int _Result;
            va_list _ArgList;
            ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
            _Result = _vfwscanf_s_l((__acrt_iob_func(0)), _Format, 0, _ArgList);
            ((void)(_ArgList = (va_list)0));
            return _Result;
        }
    #line 985 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    #line 987 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"


#line 1003 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
     int __cdecl __stdio_common_vswprintf(
                                             unsigned __int64 _Options,
                 wchar_t*         _Buffer,
                                             size_t           _BufferCount,
            wchar_t const*   _Format,
                                         _locale_t        _Locale,
                                                va_list          _ArgList
        );

     
     int __cdecl __stdio_common_vswprintf_s(
                                             unsigned __int64 _Options,
                     wchar_t*         _Buffer,
                                             size_t           _BufferCount,
            wchar_t const*   _Format,
                                         _locale_t        _Locale,
                                                va_list          _ArgList
        );

     
     int __cdecl __stdio_common_vsnwprintf_s(
                                             unsigned __int64 _Options,
                 wchar_t*         _Buffer,
                                             size_t           _BufferCount,
                                             size_t           _MaxCount,
            wchar_t const*   _Format,
                                         _locale_t        _Locale,
                                                va_list          _ArgList
        );

     
     int __cdecl __stdio_common_vswprintf_p(
                                             unsigned __int64 _Options,
                     wchar_t*         _Buffer,
                                             size_t           _BufferCount,
            wchar_t const*   _Format,
                                         _locale_t        _Locale,
                                                va_list          _ArgList
        );

     
     __declspec(deprecated("This function or variable may be unsafe. Consider using " "_vsnwprintf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    __inline int __cdecl _vsnwprintf_l(
            wchar_t*       const _Buffer,
                                                  size_t         const _BufferCount,
                 wchar_t const* const _Format,
                                              _locale_t      const _Locale,
                                                     va_list              _ArgList
        )
    

#line 1061 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int const _Result = __stdio_common_vswprintf(
            (*__local_stdio_printf_options()) | (1ULL << 0),
            _Buffer, _BufferCount, _Format, _Locale, _ArgList);

        return _Result < 0 ? -1 : _Result;
    }
    #line 1069 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _vsnwprintf_s_l(
           wchar_t*       const _Buffer,
                                                       size_t         const _BufferCount,
                                                       size_t         const _MaxCount,
                      wchar_t const* const _Format,
                                                   _locale_t      const _Locale,
                                                          va_list              _ArgList
        )
    

#line 1083 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int const _Result = __stdio_common_vsnwprintf_s(
            (*__local_stdio_printf_options()),
            _Buffer, _BufferCount, _MaxCount, _Format, _Locale, _ArgList);

        return _Result < 0 ? -1 : _Result;
    }
    #line 1091 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _vsnwprintf_s(
           wchar_t*       const _Buffer,
                                                       size_t         const _BufferCount,
                                                       size_t         const _MaxCount,
                                wchar_t const* const _Format,
                                                          va_list              _ArgList
        )
    

#line 1104 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return _vsnwprintf_s_l(_Buffer, _BufferCount, _MaxCount, _Format, 0, _ArgList);
    }
    #line 1108 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    __declspec(deprecated("This function or variable may be unsafe. Consider using " "_snwprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline   int __cdecl _snwprintf(    wchar_t *_Buffer,   size_t _BufferCount,     wchar_t const* _Format, ...); __declspec(deprecated("This function or variable may be unsafe. Consider using " "_vsnwprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline   int __cdecl _vsnwprintf(    wchar_t *_Buffer,   size_t _BufferCount,     wchar_t const* _Format, va_list _Args);
#line 1117 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
     __declspec(deprecated("This function or variable may be unsafe. Consider using " "_vsnwprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    __inline int __cdecl _vsnwprintf(
            wchar_t*       _Buffer,
                                                  size_t         _BufferCount,
                           wchar_t const* _Format,
                                                     va_list        _ArgList
        )
    

#line 1129 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return _vsnwprintf_l(_Buffer, _BufferCount, _Format, 0, _ArgList);
    }
    #line 1133 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    extern "C++" { template <size_t _Size> inline   int __cdecl _vsnwprintf_s( wchar_t (&_Buffer)[_Size],   size_t _BufferCount,     wchar_t const* _Format, va_list _ArgList) throw() { return _vsnwprintf_s(_Buffer, _Size, _BufferCount, _Format, _ArgList); } }
#line 1142 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _vswprintf_c_l(
           wchar_t*       const _Buffer,
                                                       size_t         const _BufferCount,
                      wchar_t const* const _Format,
                                                   _locale_t      const _Locale,
                                                          va_list              _ArgList
        )
    

#line 1155 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int const _Result = __stdio_common_vswprintf(
            (*__local_stdio_printf_options()),
            _Buffer, _BufferCount, _Format, _Locale, _ArgList);

        return _Result < 0 ? -1 : _Result;
    }
    #line 1163 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _vswprintf_c(
           wchar_t*       const _Buffer,
                                                       size_t         const _BufferCount,
                                wchar_t const* const _Format,
                                                          va_list              _ArgList
        )
    

#line 1175 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return _vswprintf_c_l(_Buffer, _BufferCount, _Format, 0, _ArgList);
    }
    #line 1179 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _vswprintf_l(
           wchar_t*       const _Buffer,
                                                       size_t         const _BufferCount,
                      wchar_t const* const _Format,
                                                   _locale_t      const _Locale,
                                                          va_list              _ArgList
        )
    

#line 1192 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return _vswprintf_c_l(_Buffer, _BufferCount, _Format, _Locale, _ArgList);
    }
    #line 1196 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl __vswprintf_l(
                  wchar_t*       const _Buffer,
            wchar_t const* const _Format,
                                         _locale_t      const _Locale,
                                                va_list              _ArgList
        )
    

#line 1208 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return _vswprintf_l(_Buffer, (size_t)-1, _Format, _Locale, _ArgList);
    }
    #line 1212 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _vswprintf(
           wchar_t*       const _Buffer,
               wchar_t const* const _Format,
                                         va_list              _ArgList
        )
    

#line 1223 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return _vswprintf_l(_Buffer, (size_t)-1, _Format, 0, _ArgList);
    }
    #line 1227 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl vswprintf(
           wchar_t*       const _Buffer,
                                                       size_t         const _BufferCount,
                      wchar_t const* const _Format,
                                                          va_list              _ArgList
        )
    

#line 1239 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return _vswprintf_c_l(_Buffer, _BufferCount, _Format, 0, _ArgList);
    }
    #line 1243 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _vswprintf_s_l(
           wchar_t*       const _Buffer,
                                                   size_t         const _BufferCount,
                  wchar_t const* const _Format,
                                               _locale_t      const _Locale,
                                                      va_list              _ArgList
        )
    

#line 1256 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int const _Result = __stdio_common_vswprintf_s(
            (*__local_stdio_printf_options()),
            _Buffer, _BufferCount, _Format, _Locale, _ArgList);

        return _Result < 0 ? -1 : _Result;
    }
    #line 1264 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
        __inline int __cdecl vswprintf_s(
               wchar_t*       const _Buffer,
                                                       size_t         const _BufferCount,
                                wchar_t const* const _Format,
                                                          va_list              _ArgList
            )
    

#line 1277 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
        {
            return _vswprintf_s_l(_Buffer, _BufferCount, _Format, 0, _ArgList);
        }
    #line 1281 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    #line 1283 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    extern "C++" { template <size_t _Size> inline   int __cdecl vswprintf_s( wchar_t (&_Buffer)[_Size],     wchar_t const* _Format, va_list _ArgList) throw() { return vswprintf_s(_Buffer, _Size, _Format, _ArgList); } }
#line 1291 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _vswprintf_p_l(
           wchar_t*       const _Buffer,
                                                   size_t         const _BufferCount,
                  wchar_t const* const _Format,
                                               _locale_t      const _Locale,
                                                      va_list              _ArgList
        )
    

#line 1304 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int const _Result = __stdio_common_vswprintf_p(
            (*__local_stdio_printf_options()),
            _Buffer, _BufferCount, _Format, _Locale, _ArgList);

        return _Result < 0 ? -1 : _Result;
    }
    #line 1312 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _vswprintf_p(
           wchar_t*       const _Buffer,
                                                   size_t         const _BufferCount,
                            wchar_t const* const _Format,
                                                      va_list              _ArgList
        )
    

#line 1324 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return _vswprintf_p_l(_Buffer, _BufferCount, _Format, 0, _ArgList);
    }
    #line 1328 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _vscwprintf_l(
            wchar_t const* const _Format,
                                         _locale_t      const _Locale,
                                                va_list              _ArgList
        )
    

#line 1339 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int const _Result = __stdio_common_vswprintf(
            (*__local_stdio_printf_options()) | (1ULL << 1),
            0, 0, _Format, _Locale, _ArgList);

        return _Result < 0 ? -1 : _Result;
    }
    #line 1347 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _vscwprintf(
            wchar_t const* const _Format,
                                      va_list              _ArgList
        )
    

#line 1357 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return _vscwprintf_l(_Format, 0, _ArgList);
    }
    #line 1361 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _vscwprintf_p_l(
            wchar_t const* const _Format,
                                         _locale_t      const _Locale,
                                                va_list              _ArgList
        )
    

#line 1372 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int const _Result = __stdio_common_vswprintf_p(
            (*__local_stdio_printf_options()) | (1ULL << 1),
            0, 0, _Format, _Locale, _ArgList);

        return _Result < 0 ? -1 : _Result;
    }
    #line 1380 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _vscwprintf_p(
            wchar_t const* const _Format,
                                      va_list              _ArgList
        )
    

#line 1390 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return _vscwprintf_p_l(_Format, 0, _ArgList);
    }
    #line 1394 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl __swprintf_l(
                  wchar_t*       const _Buffer,
            wchar_t const* const _Format,
                                         _locale_t      const _Locale,
        ...)
    

#line 1405 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = __vswprintf_l(_Buffer, _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1414 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _swprintf_l(
           wchar_t*       const _Buffer,
                                                       size_t         const _BufferCount,
                      wchar_t const* const _Format,
                                                   _locale_t      const _Locale,
        ...)
    

#line 1426 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vswprintf_c_l(_Buffer, _BufferCount, _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1435 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _swprintf(
           wchar_t*       const _Buffer,
               wchar_t const* const _Format,
        ...)
    

#line 1445 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = __vswprintf_l(_Buffer, _Format, 0, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1454 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl swprintf(
           wchar_t*       const _Buffer,
                                                       size_t         const _BufferCount,
                                wchar_t const* const _Format,
        ...)
    

#line 1465 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vswprintf_c_l(_Buffer, _BufferCount, _Format, 0, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1474 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    __declspec(deprecated("This function or variable may be unsafe. Consider using " "__swprintf_l_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline   int __cdecl __swprintf_l(   wchar_t *_Buffer,     wchar_t const* _Format,   _locale_t _Locale, ...); __declspec(deprecated("This function or variable may be unsafe. Consider using " "_vswprintf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline   int __cdecl __vswprintf_l(   wchar_t *_Buffer,     wchar_t const* _Format,   _locale_t _Locale, va_list _Args);
#line 1483 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    __declspec(deprecated("This function or variable may be unsafe. Consider using " "swprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline   int __cdecl _swprintf(   wchar_t *_Buffer,     wchar_t const* _Format, ...); __declspec(deprecated("This function or variable may be unsafe. Consider using " "vswprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details.")) __inline   int __cdecl _vswprintf(   wchar_t *_Buffer,     wchar_t const* _Format, va_list _Args);
#line 1490 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _swprintf_s_l(
           wchar_t*       const _Buffer,
                                                   size_t         const _BufferCount,
                  wchar_t const* const _Format,
                                               _locale_t      const _Locale,
        ...)
    

#line 1502 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vswprintf_s_l(_Buffer, _BufferCount, _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1511 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
        __inline int __cdecl swprintf_s(
               wchar_t*       const _Buffer,
                                                       size_t         const _BufferCount,
                                wchar_t const* const _Format,
            ...)
    

#line 1523 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
        {
            int _Result;
            va_list _ArgList;
            ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
            _Result = _vswprintf_s_l(_Buffer, _BufferCount, _Format, 0, _ArgList);
            ((void)(_ArgList = (va_list)0));
            return _Result;
        }
    #line 1532 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    #line 1534 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    extern "C++" { template <size_t _Size> inline   int __cdecl swprintf_s( wchar_t (&_Buffer)[_Size],     wchar_t const* _Format, ...) throw() { va_list _ArgList; ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1)))))); return vswprintf_s(_Buffer, _Size, _Format, _ArgList); } }
#line 1541 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _swprintf_p_l(
           wchar_t*       const _Buffer,
                                                   size_t         const _BufferCount,
                  wchar_t const* const _Format,
                                               _locale_t      const _Locale,
        ...)
    

#line 1553 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vswprintf_p_l(_Buffer, _BufferCount, _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1562 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _swprintf_p(
           wchar_t*       const _Buffer,
                                                   size_t         const _BufferCount,
                            wchar_t const* const _Format,
        ...)
    

#line 1573 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vswprintf_p_l(_Buffer, _BufferCount, _Format, 0, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1582 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _swprintf_c_l(
           wchar_t*       const _Buffer,
                                                       size_t         const _BufferCount,
                      wchar_t const* const _Format,
                                                   _locale_t      const _Locale,
        ...)
    

#line 1594 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vswprintf_c_l(_Buffer, _BufferCount, _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1603 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _swprintf_c(
           wchar_t*       const _Buffer,
                                                       size_t         const _BufferCount,
                                wchar_t const* const _Format,
        ...)
    

#line 1614 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vswprintf_c_l(_Buffer, _BufferCount, _Format, 0, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1623 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
     __declspec(deprecated("This function or variable may be unsafe. Consider using " "_snwprintf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    __inline int __cdecl _snwprintf_l(
            wchar_t*       const _Buffer,
                                                  size_t         const _BufferCount,
                 wchar_t const* const _Format,
                                              _locale_t      const _Locale,
        ...)
    

#line 1635 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));

        _Result = _vsnwprintf_l(_Buffer, _BufferCount, _Format, _Locale, _ArgList);

        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1646 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _snwprintf(
            wchar_t*       _Buffer,
                                                  size_t         _BufferCount,
                           wchar_t const* _Format,
        ...)
    

#line 1657 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));

        _Result = _vsnwprintf_l(_Buffer, _BufferCount, _Format, 0, _ArgList);

        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1668 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _snwprintf_s_l(
           wchar_t*       const _Buffer,
                                                       size_t         const _BufferCount,
                                                       size_t         const _MaxCount,
                      wchar_t const* const _Format,
                                                   _locale_t      const _Locale,
        ...)
    

#line 1681 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vsnwprintf_s_l(_Buffer, _BufferCount, _MaxCount, _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1690 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _snwprintf_s(
           wchar_t*       const _Buffer,
                                                       size_t         const _BufferCount,
                                                       size_t         const _MaxCount,
                                wchar_t const* const _Format,
        ...)
    

#line 1702 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vsnwprintf_s_l(_Buffer, _BufferCount, _MaxCount, _Format, 0, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1711 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    extern "C++" { template <size_t _Size> inline   int __cdecl _snwprintf_s( wchar_t (&_Buffer)[_Size],   size_t _BufferCount,     wchar_t const* _Format, ...) throw() { va_list _ArgList; ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1)))))); return _vsnwprintf_s(_Buffer, _Size, _BufferCount, _Format, _ArgList); } }
#line 1719 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _scwprintf_l(
            wchar_t const* const _Format,
                                         _locale_t      const _Locale,
        ...)
    

#line 1728 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vscwprintf_l(_Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1737 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _scwprintf(
            wchar_t const* const _Format,
        ...)
    

#line 1746 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vscwprintf_l(_Format, 0, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1755 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _scwprintf_p_l(
            wchar_t const* const _Format,
                                         _locale_t      const _Locale,
        ...)
    

#line 1765 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vscwprintf_p_l(_Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1774 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _scwprintf_p(
            wchar_t const* const _Format,
        ...)
    

#line 1783 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vscwprintf_p_l(_Format, 0, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1792 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"


        #pragma warning(push)
        #pragma warning(disable: 4141 6054)

        
            extern "C++" __declspec(deprecated("function has been changed to conform with the ISO C standard, " "adding an extra character count parameter. To use the traditional " "Microsoft version, set _CRT_NON_CONFORMING_SWPRINTFS.")) __declspec(deprecated("This function or variable may be unsafe. Consider using " "swprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
            inline int swprintf(
                           wchar_t*       const _Buffer,
                    wchar_t const* const _Format,
                ...) throw()
            {
                int _Result;
                va_list _ArgList;
                ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
                _Result = vswprintf(_Buffer, 2147483647, _Format, _ArgList);
                ((void)(_ArgList = (va_list)0));
                return _Result;
            }

            extern "C++" __declspec(deprecated("function has been changed to conform with the ISO C standard, " "adding an extra character count parameter. To use the traditional " "Microsoft version, set _CRT_NON_CONFORMING_SWPRINTFS.")) __declspec(deprecated("This function or variable may be unsafe. Consider using " "vswprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
            inline int __cdecl vswprintf(
                           wchar_t*       const _Buffer,
                    wchar_t const* const _Format,
                                              va_list              _ArgList
                ) throw()
            {
                return vswprintf(_Buffer, 2147483647, _Format, _ArgList);
            }

            extern "C++" __declspec(deprecated("function has been changed to conform with the ISO C standard, " "adding an extra character count parameter. To use the traditional " "Microsoft version, set _CRT_NON_CONFORMING_SWPRINTFS.")) __declspec(deprecated("This function or variable may be unsafe. Consider using " "_swprintf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
            inline int _swprintf_l(
                                     wchar_t*       const _Buffer,
                    wchar_t const* const _Format,
                                                 _locale_t      const _Locale,
                ...) throw()
            {
                int _Result;
                va_list _ArgList;
                ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
                _Result = _vswprintf_l(_Buffer, (size_t)-1, _Format, _Locale, _ArgList);
                ((void)(_ArgList = (va_list)0));
                return _Result;
            }

            extern "C++" __declspec(deprecated("function has been changed to conform with the ISO C standard, " "adding an extra character count parameter. To use the traditional " "Microsoft version, set _CRT_NON_CONFORMING_SWPRINTFS.")) __declspec(deprecated("This function or variable may be unsafe. Consider using " "_vswprintf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
            inline int __cdecl _vswprintf_l(
                                     wchar_t*       const _Buffer,
                    wchar_t const* const _Format,
                                                 _locale_t      const _Locale,
                                                        va_list              _ArgList
                ) throw()
            {
                return _vswprintf_l(_Buffer, (size_t)-1, _Format, _Locale, _ArgList);
            }

        #line 1853 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

        #pragma warning(pop)
    #line 1856 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
#line 1863 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"


     int __cdecl __stdio_common_vswscanf(
                                            unsigned __int64 _Options,
                  wchar_t const*   _Buffer,
                                            size_t           _BufferCount,
            wchar_t const*   _Format,
                                        _locale_t        _Locale,
                                               va_list          _ArgList
        );

     
    __inline int __cdecl _vswscanf_l(
                                 wchar_t const* const _Buffer,
            wchar_t const* const _Format,
                               _locale_t      const _Locale,
                                      va_list              _ArgList
        )
    

#line 1891 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return __stdio_common_vswscanf(
            (*__local_stdio_scanf_options ()),
            _Buffer, (size_t)-1, _Format, _Locale, _ArgList);
    }
    #line 1897 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl vswscanf(
                                 wchar_t const* _Buffer,
            wchar_t const* _Format,
                                      va_list        _ArgList
        )
    

#line 1908 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return _vswscanf_l(_Buffer, _Format, 0, _ArgList);
    }
    #line 1912 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _vswscanf_s_l(
                                 wchar_t const* const _Buffer,
            wchar_t const* const _Format,
                               _locale_t      const _Locale,
                                      va_list              _ArgList
        )
    

#line 1924 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return __stdio_common_vswscanf(
            (*__local_stdio_scanf_options ()) | (1ULL << 0),
            _Buffer, (size_t)-1, _Format, _Locale, _ArgList);
    }
    #line 1930 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
        __inline int __cdecl vswscanf_s(
                                     wchar_t const* const _Buffer,
                wchar_t const* const _Format,
                                          va_list              _ArgList
            )
    

#line 1943 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
        {
            return _vswscanf_s_l(_Buffer, _Format, 0, _ArgList);
        }
    #line 1947 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    #line 1949 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    extern "C++" { template <size_t _Size> inline   int __cdecl vswscanf_s(  wchar_t (&_Buffer)[_Size],     wchar_t const* _Format, va_list _ArgList) throw() { return vswscanf_s(_Buffer, _Size, _Format, _ArgList); } }
#line 1957 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
     __declspec(deprecated("This function or variable may be unsafe. Consider using " "_vsnwscanf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    __inline int __cdecl _vsnwscanf_l(
                  wchar_t const* const _Buffer,
                                            size_t         const _BufferCount,
            wchar_t const* const _Format,
                                        _locale_t      const _Locale,
                                               va_list              _ArgList
        )
    

#line 1970 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return __stdio_common_vswscanf(
            (*__local_stdio_scanf_options ()),
            _Buffer, _BufferCount, _Format, _Locale, _ArgList);
    }
    #line 1976 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _vsnwscanf_s_l(
                    wchar_t const* const _Buffer,
                                              size_t         const _BufferCount,
            wchar_t const* const _Format,
                                          _locale_t      const _Locale,
                                                 va_list              _ArgList
        )
    

#line 1989 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        return __stdio_common_vswscanf(
            (*__local_stdio_scanf_options ()) | (1ULL << 0),
            _Buffer, _BufferCount, _Format, _Locale, _ArgList);
    }
    #line 1995 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
     __declspec(deprecated("This function or variable may be unsafe. Consider using " "_swscanf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    __inline int __cdecl _swscanf_l(
                                          wchar_t const* const _Buffer,
            wchar_t const* const _Format,
                                        _locale_t            _Locale,
        ...)
    

#line 2006 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vswscanf_l(_Buffer, _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 2015 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
      __declspec(deprecated("This function or variable may be unsafe. Consider using " "swscanf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    __inline int __cdecl swscanf(
                                wchar_t const* const _Buffer,
            wchar_t const* const _Format,
        ...)
    

#line 2025 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vswscanf_l(_Buffer, _Format, 0, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 2034 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _swscanf_s_l(
                                            wchar_t const* const _Buffer,
            wchar_t const* const _Format,
                                          _locale_t      const _Locale,
        ...)
    

#line 2045 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vswscanf_s_l(_Buffer, _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 2054 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
        __inline int __cdecl swscanf_s(
                                      wchar_t const* const _Buffer,
                wchar_t const* const _Format,
            ...)
    

#line 2066 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
        {
            int _Result;
            va_list _ArgList;
            ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
            _Result = _vswscanf_s_l(_Buffer, _Format, 0, _ArgList);
            ((void)(_ArgList = (va_list)0));
            return _Result;
        }
    #line 2075 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    #line 2077 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
     __declspec(deprecated("This function or variable may be unsafe. Consider using " "_snwscanf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    __inline int __cdecl _snwscanf_l(
                  wchar_t const* const _Buffer,
                                            size_t         const _BufferCount,
            wchar_t const* const _Format,
                                        _locale_t      const _Locale,
        ...)
    

#line 2089 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));

        _Result = _vsnwscanf_l(_Buffer, _BufferCount, _Format, _Locale, _ArgList);

        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 2100 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
     __declspec(deprecated("This function or variable may be unsafe. Consider using " "_snwscanf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    __inline int __cdecl _snwscanf(
            wchar_t const* const _Buffer,
                                      size_t         const _BufferCount,
                wchar_t const* const _Format,
        ...)
    

#line 2111 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));

        _Result = _vsnwscanf_l(_Buffer, _BufferCount, _Format, 0, _ArgList);

        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 2122 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _snwscanf_s_l(
                    wchar_t const* const _Buffer,
                                              size_t         const _BufferCount,
            wchar_t const* const _Format,
                                          _locale_t      const _Locale,
        ...)
    

#line 2134 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vsnwscanf_s_l(_Buffer, _BufferCount, _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 2143 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

     
    __inline int __cdecl _snwscanf_s(
             wchar_t const* const _Buffer,
                                       size_t         const _BufferCount,
               wchar_t const* const _Format,
        ...)
    

#line 2154 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vsnwscanf_s_l(_Buffer, _BufferCount, _Format, 0, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 2163 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

    
#line 2168 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstdio.h"

} __pragma(pack(pop))

#pragma warning(pop) 
#line 14 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


#line 53 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"


#line 71 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"


typedef __int64 fpos_t;


     errno_t __cdecl _get_stream_buffer_pointers(
               FILE*   _Stream,
          char*** _Base,
          char*** _Pointer,
          int**   _Count
        );


         errno_t __cdecl clearerr_s(
              FILE* _Stream
            );

        
         errno_t __cdecl fopen_s(
              FILE**      _Stream,
                                     char const* _FileName,
                                     char const* _Mode
            );

        
         size_t __cdecl fread_s(
                void*  _Buffer,
                                    size_t _BufferSize,
                                                                            size_t _ElementSize,
                                                                            size_t _ElementCount,
                                                                         FILE*  _Stream
            );

        
         errno_t __cdecl freopen_s(
              FILE**      _Stream,
                                 char const* _FileName,
                                 char const* _Mode,
                                FILE*       _OldStream
            );

         
         char* __cdecl gets_s(
              char*   _Buffer,
                               rsize_t _Size
            );

        
         errno_t __cdecl tmpfile_s(
                FILE** _Stream
            );

         
         errno_t __cdecl tmpnam_s(
              char*   _Buffer,
                               rsize_t _Size
            );

    #line 145 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     void __cdecl clearerr(
          FILE* _Stream
        );

     
     int __cdecl fclose(
          FILE* _Stream
        );

    
     int __cdecl _fcloseall(void);

     
     FILE* __cdecl _fdopen(
            int         _FileHandle,
          char const* _Mode
        );

     
     int __cdecl feof(
          FILE* _Stream
        );

     
     int __cdecl ferror(
          FILE* _Stream
        );

    
     int __cdecl fflush(
          FILE* _Stream
        );

     
     int __cdecl fgetc(
          FILE* _Stream
        );

    
     int __cdecl _fgetchar(void);

     
     int __cdecl fgetpos(
          FILE*   _Stream,
            fpos_t* _Position
        );

     
     char* __cdecl fgets(
          char* _Buffer,
                               int   _MaxCount,
                            FILE* _Stream
        );

     
     int __cdecl _fileno(
          FILE* _Stream
        );

    
     int __cdecl _flushall(void);

      __declspec(deprecated("This function or variable may be unsafe. Consider using " "fopen_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
     FILE* __cdecl fopen(
          char const* _FileName,
          char const* _Mode
        );


     int __cdecl fputc(
             int   _Character,
          FILE* _Stream
        );

    
     int __cdecl _fputchar(
          int _Character
        );

     
     int __cdecl fputs(
           char const* _Buffer,
          FILE*       _Stream
        );

    
     size_t __cdecl fread(
          void*  _Buffer,
                                                      size_t _ElementSize,
                                                      size_t _ElementCount,
                                                   FILE*  _Stream
        );

     
      __declspec(deprecated("This function or variable may be unsafe. Consider using " "freopen_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
     FILE* __cdecl freopen(
           char const* _FileName,
           char const* _Mode,
          FILE*       _Stream
        );

     
     FILE* __cdecl _fsopen(
          char const* _FileName,
          char const* _Mode,
            int         _ShFlag
        );

     
     int __cdecl fsetpos(
          FILE*         _Stream,
             fpos_t const* _Position
        );

     
     int __cdecl fseek(
          FILE* _Stream,
             long  _Offset,
             int   _Origin
        );

     
     int __cdecl _fseeki64(
          FILE*   _Stream,
             __int64 _Offset,
             int     _Origin
        );

     
     long __cdecl ftell(
          FILE* _Stream
        );

     
     __int64 __cdecl _ftelli64(
          FILE* _Stream
        );

    
     size_t __cdecl fwrite(
          void const* _Buffer,
                                                    size_t      _ElementSize,
                                                    size_t      _ElementCount,
                                                 FILE*       _Stream
        );

     
     int __cdecl getc(
          FILE* _Stream
        );

     
     int __cdecl getchar(void);

     
     int __cdecl _getmaxstdio(void);

    extern "C++" { template <size_t _Size> inline char* __cdecl gets_s(char (&_Buffer)[_Size]) throw() { return gets_s(_Buffer, _Size); } }
#line 319 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     
     int __cdecl _getw(
          FILE* _Stream
        );

     void __cdecl perror(
          char const* _ErrorMessage
        );

    
         int __cdecl _pclose(
              FILE* _Stream
            );

         
         FILE* __cdecl _popen(
              char const* _Command,
              char const* _Mode
            );

    #line 344 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     
     int __cdecl putc(
             int   _Character,
          FILE* _Stream
        );

    
     int __cdecl putchar(
          int _Character
        );

    
     int __cdecl puts(
          char const* _Buffer
        );

     
     int __cdecl _putw(
             int   _Word,
          FILE* _Stream
        );

     int __cdecl remove(
          char const* _FileName
        );

     
     int __cdecl rename(
          char const* _OldFileName,
          char const* _NewFileName
        );

     int __cdecl _unlink(
          char const* _FileName
        );

    
        __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_unlink" ". See online help for details."))
         int __cdecl unlink(
              char const* _FileName
            );

    #line 391 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     void __cdecl rewind(
          FILE* _Stream
        );

    
     int __cdecl _rmtmp(void);

    __declspec(deprecated("This function or variable may be unsafe. Consider using " "setvbuf" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
     void __cdecl setbuf(
                                                      FILE* _Stream,
            char* _Buffer
        );

    
     int __cdecl _setmaxstdio(
          int _Maximum
        );

     
     int __cdecl setvbuf(
                               FILE*  _Stream,
            char*  _Buffer,
                                  int    _Mode,
                                  size_t _Size
        );

    
#line 423 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     
     __declspec(allocator) char* __cdecl _tempnam(
          char const* _DirectoryName,
          char const* _FilePrefix
        );

    
#line 433 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

      __declspec(deprecated("This function or variable may be unsafe. Consider using " "tmpfile_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
     FILE* __cdecl tmpfile(void);

    extern "C++" { template <size_t _Size> inline   errno_t __cdecl tmpnam_s( char (&_Buffer)[_Size]) throw() { return tmpnam_s(_Buffer, _Size); } }
#line 442 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "tmpnam_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))   char* __cdecl tmpnam(  char *_Buffer);
#line 448 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     
     int __cdecl ungetc(
             int   _Character,
          FILE* _Stream
        );


     void __cdecl _lock_file(
          FILE* _Stream
        );

     void __cdecl _unlock_file(
          FILE* _Stream
        );

     
     int __cdecl _fclose_nolock(
          FILE* _Stream
        );

     
     int __cdecl _fflush_nolock(
          FILE* _Stream
        );

     
     int __cdecl _fgetc_nolock(
          FILE* _Stream
        );

     
     int __cdecl _fputc_nolock(
             int   _Character,
          FILE* _Stream
        );

    
     size_t __cdecl _fread_nolock(
          void*  _Buffer,
                                                      size_t _ElementSize,
                                                      size_t _ElementCount,
                                                   FILE*  _Stream
        );

    
     size_t __cdecl _fread_nolock_s(
          void*  _Buffer,
                              size_t _BufferSize,
                                                                      size_t _ElementSize,
                                                                      size_t _ElementCount,
                                                                   FILE*  _Stream
        );

    
     int __cdecl _fseek_nolock(
          FILE* _Stream,
             long  _Offset,
             int   _Origin
        );

    
     int __cdecl _fseeki64_nolock(
          FILE*   _Stream,
             __int64 _Offset,
             int     _Origin
        );

     
     long __cdecl _ftell_nolock(
          FILE* _Stream
        );

     
     __int64 __cdecl _ftelli64_nolock(
          FILE* _Stream
        );

    
     size_t __cdecl _fwrite_nolock(
          void const* _Buffer,
                                                    size_t      _ElementSize,
                                                    size_t      _ElementCount,
                                                 FILE*       _Stream
        );

    
     int __cdecl _getc_nolock(
          FILE* _Stream
        );

    
     int __cdecl _putc_nolock(
             int   _Character,
          FILE* _Stream
        );

    
     int __cdecl _ungetc_nolock(
             int   _Character,
          FILE* _Stream
        );

    
#line 586 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"


     int* __cdecl __p__commode(void);

    
    #line 596 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"


#line 603 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
     int __cdecl __stdio_common_vfprintf(
                                             unsigned __int64 _Options,
                                          FILE*            _Stream,
            char const*      _Format,
                                         _locale_t        _Locale,
                                                va_list          _ArgList
        );

     int __cdecl __stdio_common_vfprintf_s(
                                             unsigned __int64 _Options,
                                          FILE*            _Stream,
            char const*      _Format,
                                         _locale_t        _Locale,
                                                va_list          _ArgList
        );

     
     int __cdecl __stdio_common_vfprintf_p(
                                             unsigned __int64 _Options,
                                          FILE*            _Stream,
            char const*      _Format,
                                         _locale_t        _Locale,
                                                va_list          _ArgList
        );

    
    __inline int __cdecl _vfprintf_l(
           FILE*       const _Stream,
            char const* const _Format,
          _locale_t   const _Locale,
                 va_list           _ArgList
        )
    

#line 644 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        return __stdio_common_vfprintf((*__local_stdio_printf_options()), _Stream, _Format, _Locale, _ArgList);
    }
    #line 648 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl vfprintf(
                                FILE*       const _Stream,
            char const* const _Format,
                                      va_list           _ArgList
        )
    

#line 658 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        return _vfprintf_l(_Stream, _Format, 0, _ArgList);
    }
    #line 662 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl _vfprintf_s_l(
           FILE*       const _Stream,
            char const* const _Format,
          _locale_t   const _Locale,
                 va_list           _ArgList
        )
    

#line 673 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        return __stdio_common_vfprintf_s((*__local_stdio_printf_options()), _Stream, _Format, _Locale, _ArgList);
    }
    #line 677 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
        __inline int __cdecl vfprintf_s(
                                    FILE*       const _Stream,
                char const* const _Format,
                                          va_list           _ArgList
            )
    

#line 689 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
        {
            return _vfprintf_s_l(_Stream, _Format, 0, _ArgList);
        }
    #line 693 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    #line 695 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl _vfprintf_p_l(
           FILE*       const _Stream,
            char const* const _Format,
          _locale_t   const _Locale,
                 va_list           _ArgList
        )
    

#line 706 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        return __stdio_common_vfprintf_p((*__local_stdio_printf_options()), _Stream, _Format, _Locale, _ArgList);
    }
    #line 710 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl _vfprintf_p(
                                FILE*       const _Stream,
            char const* const _Format,
                                      va_list           _ArgList
        )
    

#line 720 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        return _vfprintf_p_l(_Stream, _Format, 0, _ArgList);
    }
    #line 724 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl _vprintf_l(
            char const* const _Format,
                                         _locale_t   const _Locale,
                                                va_list           _ArgList
        )
    

#line 734 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        return _vfprintf_l((__acrt_iob_func(1)), _Format, _Locale, _ArgList);
    }
    #line 738 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl vprintf(
            char const* const _Format,
                                      va_list           _ArgList
        )
    

#line 747 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        return _vfprintf_l((__acrt_iob_func(1)), _Format, 0, _ArgList);
    }
    #line 751 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl _vprintf_s_l(
            char const* const _Format,
                                         _locale_t   const _Locale,
                                                va_list           _ArgList
        )
    

#line 761 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        return _vfprintf_s_l((__acrt_iob_func(1)), _Format, _Locale, _ArgList);
    }
    #line 765 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
        __inline int __cdecl vprintf_s(
                char const* const _Format,
                                          va_list           _ArgList
            )
    

#line 776 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
        {
            return _vfprintf_s_l((__acrt_iob_func(1)), _Format, 0, _ArgList);
        }
    #line 780 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    #line 782 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl _vprintf_p_l(
            char const* const _Format,
                                         _locale_t   const _Locale,
                                                va_list           _ArgList
        )
    

#line 792 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        return _vfprintf_p_l((__acrt_iob_func(1)), _Format, _Locale, _ArgList);
    }
    #line 796 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl _vprintf_p(
            char const* const _Format,
                                      va_list           _ArgList
        )
    

#line 805 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        return _vfprintf_p_l((__acrt_iob_func(1)), _Format, 0, _ArgList);
    }
    #line 809 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl _fprintf_l(
                                          FILE*       const _Stream,
            char const* const _Format,
                                         _locale_t   const _Locale,
        ...)
    

#line 819 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfprintf_l(_Stream, _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 828 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl fprintf(
                                FILE*       const _Stream,
            char const* const _Format,
        ...)
    

#line 837 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfprintf_l(_Stream, _Format, 0, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 846 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     int __cdecl _set_printf_count_output(
          int _Value
        );

     int __cdecl _get_printf_count_output(void);

    
    __inline int __cdecl _fprintf_s_l(
                                          FILE*       const _Stream,
            char const* const _Format,
                                         _locale_t   const _Locale,
        ...)
    

#line 862 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfprintf_s_l(_Stream, _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 871 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
        __inline int __cdecl fprintf_s(
                                    FILE*       const _Stream,
                char const* const _Format,
            ...)
    

#line 882 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
        {
            int _Result;
            va_list _ArgList;
            ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
            _Result = _vfprintf_s_l(_Stream, _Format, 0, _ArgList);
            ((void)(_ArgList = (va_list)0));
            return _Result;
        }
    #line 891 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    #line 893 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl _fprintf_p_l(
                                          FILE*       const _Stream,
            char const* const _Format,
                                         _locale_t   const _Locale,
        ...)
    

#line 903 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfprintf_p_l(_Stream, _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 912 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl _fprintf_p(
                                FILE*       const _Stream,
            char const* const _Format,
        ...)
    

#line 921 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfprintf_p_l(_Stream, _Format, 0, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 930 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl _printf_l(
            char const* const _Format,
                                         _locale_t   const _Locale,
        ...)
    

#line 939 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfprintf_l((__acrt_iob_func(1)), _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 948 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl printf(
            char const* const _Format,
        ...)
    

#line 956 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfprintf_l((__acrt_iob_func(1)), _Format, 0, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 965 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl _printf_s_l(
            char const* const _Format,
                                         _locale_t   const _Locale,
        ...)
    

#line 974 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfprintf_s_l((__acrt_iob_func(1)), _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 983 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
        __inline int __cdecl printf_s(
                char const* const _Format,
            ...)
    

#line 993 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
        {
            int _Result;
            va_list _ArgList;
            ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
            _Result = _vfprintf_s_l((__acrt_iob_func(1)), _Format, 0, _ArgList);
            ((void)(_ArgList = (va_list)0));
            return _Result;
        }
    #line 1002 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    #line 1004 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl _printf_p_l(
            char const* const _Format,
                                         _locale_t   const _Locale,
        ...)
    

#line 1013 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfprintf_p_l((__acrt_iob_func(1)), _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1022 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl _printf_p(
            char const* const _Format,
        ...)
    

#line 1030 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfprintf_p_l((__acrt_iob_func(1)), _Format, 0, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1039 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"


     int __cdecl __stdio_common_vfscanf(
                                            unsigned __int64 _Options,
                                         FILE*            _Stream,
            char const*      _Format,
                                        _locale_t        _Locale,
                                               va_list          _Arglist
        );

    
    __inline int __cdecl _vfscanf_l(
                                FILE*       const _Stream,
            char const* const _Format,
                               _locale_t   const _Locale,
                                      va_list           _ArgList
        )
    

#line 1064 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        return __stdio_common_vfscanf(
            (*__local_stdio_scanf_options ()),
            _Stream, _Format, _Locale, _ArgList);
    }
    #line 1070 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl vfscanf(
                                FILE*       const _Stream,
            char const* const _Format,
                                      va_list           _ArgList
        )
    

#line 1080 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        return _vfscanf_l(_Stream, _Format, 0, _ArgList);
    }
    #line 1084 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl _vfscanf_s_l(
                                FILE*       const _Stream,
            char const* const _Format,
                               _locale_t   const _Locale,
                                      va_list           _ArgList
        )
    

#line 1095 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        return __stdio_common_vfscanf(
            (*__local_stdio_scanf_options ()) | (1ULL << 0),
            _Stream, _Format, _Locale, _ArgList);
    }
    #line 1101 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"


        __inline int __cdecl vfscanf_s(
                                    FILE*       const _Stream,
                char const* const _Format,
                                          va_list           _ArgList
            )
    

#line 1114 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
        {
            return _vfscanf_s_l(_Stream, _Format, 0, _ArgList);
        }
    #line 1118 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    #line 1120 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl _vscanf_l(
            char const* const _Format,
                               _locale_t   const _Locale,
                                      va_list           _ArgList
        )
    

#line 1130 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        return _vfscanf_l((__acrt_iob_func(0)), _Format, _Locale, _ArgList);
    }
    #line 1134 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl vscanf(
            char const* const _Format,
                                      va_list           _ArgList
        )
    

#line 1143 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        return _vfscanf_l((__acrt_iob_func(0)), _Format, 0, _ArgList);
    }
    #line 1147 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl _vscanf_s_l(
            char const* const _Format,
                               _locale_t   const _Locale,
                                      va_list           _ArgList
        )
    

#line 1157 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        return _vfscanf_s_l((__acrt_iob_func(0)), _Format, _Locale, _ArgList);
    }
    #line 1161 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
        __inline int __cdecl vscanf_s(
                char const* const _Format,
                                          va_list           _ArgList
            )
    

#line 1172 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
        {
            return _vfscanf_s_l((__acrt_iob_func(0)), _Format, 0, _ArgList);
        }
    #line 1176 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    #line 1178 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     __declspec(deprecated("This function or variable may be unsafe. Consider using " "_fscanf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    __inline int __cdecl _fscanf_l(
                                         FILE*       const _Stream,
            char const* const _Format,
                                        _locale_t   const _Locale,
        ...)
    

#line 1188 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfscanf_l(_Stream, _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1197 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

      __declspec(deprecated("This function or variable may be unsafe. Consider using " "fscanf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    __inline int __cdecl fscanf(
                               FILE*       const _Stream,
            char const* const _Format,
        ...)
    

#line 1206 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfscanf_l(_Stream, _Format, 0, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1215 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl _fscanf_s_l(
                                           FILE*       const _Stream,
            char const* const _Format,
                                          _locale_t   const _Locale,
        ...)
    

#line 1225 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfscanf_s_l(_Stream, _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1234 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
        __inline int __cdecl fscanf_s(
                                     FILE*       const _Stream,
                char const* const _Format,
            ...)
    

#line 1245 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
        {
            int _Result;
            va_list _ArgList;
            ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
            _Result = _vfscanf_s_l(_Stream, _Format, 0, _ArgList);
            ((void)(_ArgList = (va_list)0));
            return _Result;
        }
    #line 1254 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    #line 1256 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     __declspec(deprecated("This function or variable may be unsafe. Consider using " "_scanf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    __inline int __cdecl _scanf_l(
            char const* const _Format,
                                        _locale_t   const _Locale,
        ...)
    

#line 1265 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfscanf_l((__acrt_iob_func(0)), _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1274 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

      __declspec(deprecated("This function or variable may be unsafe. Consider using " "scanf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    __inline int __cdecl scanf(
            char const* const _Format,
        ...)
    

#line 1282 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfscanf_l((__acrt_iob_func(0)), _Format, 0, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1291 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl _scanf_s_l(
            char const* const _Format,
                                          _locale_t   const _Locale,
        ...)
    

#line 1300 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vfscanf_s_l((__acrt_iob_func(0)), _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1309 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
        __inline int __cdecl scanf_s(
                char const* const _Format,
            ...)
    

#line 1319 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
        {
            int _Result;
            va_list _ArgList;
            ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
            _Result = _vfscanf_s_l((__acrt_iob_func(0)), _Format, 0, _ArgList);
            ((void)(_ArgList = (va_list)0));
            return _Result;
        }
    #line 1328 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    #line 1330 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"


     int __cdecl __stdio_common_vsprintf(
                                             unsigned __int64 _Options,
                 char*            _Buffer,
                                             size_t           _BufferCount,
            char const*      _Format,
                                         _locale_t        _Locale,
                                                va_list          _ArgList
        );

     
     int __cdecl __stdio_common_vsprintf_s(
                                             unsigned __int64 _Options,
                     char*            _Buffer,
                                             size_t           _BufferCount,
            char const*      _Format,
                                         _locale_t        _Locale,
                                                va_list          _ArgList
        );

     
     int __cdecl __stdio_common_vsnprintf_s(
                                             unsigned __int64 _Options,
                 char*            _Buffer,
                                             size_t           _BufferCount,
                                             size_t           _MaxCount,
            char const*      _Format,
                                         _locale_t        _Locale,
                                                va_list          _ArgList
        );

     
     int __cdecl __stdio_common_vsprintf_p(
                                             unsigned __int64 _Options,
                     char*            _Buffer,
                                             size_t           _BufferCount,
            char const*      _Format,
                                         _locale_t        _Locale,
                                                va_list          _ArgList
        );

     
     __declspec(deprecated("This function or variable may be unsafe. Consider using " "_vsnprintf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    __inline int __cdecl _vsnprintf_l(
            char*       const _Buffer,
                                                  size_t      const _BufferCount,
                 char const* const _Format,
                                              _locale_t   const _Locale,
                                                     va_list           _ArgList
        )
    

#line 1391 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int const _Result = __stdio_common_vsprintf(
            (*__local_stdio_printf_options()) | (1ULL << 0),
            _Buffer, _BufferCount, _Format, _Locale, _ArgList);

        return _Result < 0 ? -1 : _Result;
    }
    #line 1399 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     
    __inline int __cdecl _vsnprintf(
            char*       const _Buffer,
                                                 size_t      const _BufferCount,
                          char const* const _Format,
                                                    va_list           _ArgList
        )
    

#line 1411 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        return _vsnprintf_l(_Buffer, _BufferCount, _Format, 0, _ArgList);
    }
    #line 1415 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
#line 1426 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     
    __inline int __cdecl vsnprintf(
           char*       const _Buffer,
                                                       size_t      const _BufferCount,
                                char const* const _Format,
                                                          va_list           _ArgList
        )
    

#line 1438 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int const _Result = __stdio_common_vsprintf(
            (*__local_stdio_printf_options()) | (1ULL << 1),
            _Buffer, _BufferCount, _Format, 0, _ArgList);

        return _Result < 0 ? -1 : _Result;
    }
    #line 1446 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     
     __declspec(deprecated("This function or variable may be unsafe. Consider using " "_vsprintf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    __inline int __cdecl _vsprintf_l(
           char*       const _Buffer,
                                    char const* const _Format,
                                  _locale_t   const _Locale,
                                         va_list           _ArgList
        )
    

#line 1458 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        return _vsnprintf_l(_Buffer, (size_t)-1, _Format, _Locale, _ArgList);
    }
    #line 1462 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     
     __declspec(deprecated("This function or variable may be unsafe. Consider using " "vsprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    __inline int __cdecl vsprintf(
           char*       const _Buffer,
               char const* const _Format,
                                         va_list           _ArgList
        )
    

#line 1473 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        return _vsnprintf_l(_Buffer, (size_t)-1, _Format, 0, _ArgList);
    }
    #line 1477 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     
    __inline int __cdecl _vsprintf_s_l(
           char*       const _Buffer,
                                                   size_t      const _BufferCount,
                  char const* const _Format,
                                               _locale_t   const _Locale,
                                                      va_list           _ArgList
        )
    

#line 1490 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int const _Result = __stdio_common_vsprintf_s(
            (*__local_stdio_printf_options()),
            _Buffer, _BufferCount, _Format, _Locale, _ArgList);

        return _Result < 0 ? -1 : _Result;
    }
    #line 1498 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
        __inline int __cdecl vsprintf_s(
               char*       const _Buffer,
                                                       size_t      const _BufferCount,
                                char const* const _Format,
                                                          va_list           _ArgList
            )
    

#line 1512 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
        {
            return _vsprintf_s_l(_Buffer, _BufferCount, _Format, 0, _ArgList);
        }
    #line 1516 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

        extern "C++" { template <size_t _Size> inline   int __cdecl vsprintf_s( char (&_Buffer)[_Size],     char const* _Format, va_list _ArgList) throw() { return vsprintf_s(_Buffer, _Size, _Format, _ArgList); } }
#line 1524 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    #line 1526 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     
    __inline int __cdecl _vsprintf_p_l(
           char*       const _Buffer,
                                                   size_t      const _BufferCount,
                  char const* const _Format,
                                               _locale_t   const _Locale,
                                                      va_list           _ArgList
        )
    

#line 1539 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int const _Result = __stdio_common_vsprintf_p(
            (*__local_stdio_printf_options()),
            _Buffer, _BufferCount, _Format, _Locale, _ArgList);

        return _Result < 0 ? -1 : _Result;
    }
    #line 1547 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     
    __inline int __cdecl _vsprintf_p(
           char*       const _Buffer,
                                                   size_t      const _BufferCount,
                            char const* const _Format,
                                                      va_list           _ArgList
        )
    

#line 1559 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        return _vsprintf_p_l(_Buffer, _BufferCount, _Format, 0, _ArgList);
    }
    #line 1563 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     
    __inline int __cdecl _vsnprintf_s_l(
           char*       const _Buffer,
                                                       size_t      const _BufferCount,
                                                       size_t      const _MaxCount,
                      char const* const _Format,
                                                   _locale_t   const _Locale,
                                                          va_list          _ArgList
        )
    

#line 1577 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int const _Result = __stdio_common_vsnprintf_s(
            (*__local_stdio_printf_options()),
            _Buffer, _BufferCount, _MaxCount, _Format, _Locale, _ArgList);

        return _Result < 0 ? -1 : _Result;
    }
    #line 1585 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     
    __inline int __cdecl _vsnprintf_s(
           char*       const _Buffer,
                                                       size_t      const _BufferCount,
                                                       size_t      const _MaxCount,
                                char const* const _Format,
                                                          va_list           _ArgList
        )
    

#line 1598 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        return _vsnprintf_s_l(_Buffer, _BufferCount, _MaxCount, _Format, 0, _ArgList);
    }
    #line 1602 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    extern "C++" { template <size_t _Size> inline   int __cdecl _vsnprintf_s( char (&_Buffer)[_Size],   size_t _BufferCount,     char const* _Format, va_list _ArgList) throw() { return _vsnprintf_s(_Buffer, _Size, _BufferCount, _Format, _ArgList); } }
#line 1611 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
        __inline int __cdecl vsnprintf_s(
               char*       const _Buffer,
                                                           size_t      const _BufferCount,
                                                           size_t      const _MaxCount,
                                    char const* const _Format,
                                                              va_list           _ArgList
            )
    

#line 1626 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
        {
            return _vsnprintf_s_l(_Buffer, _BufferCount, _MaxCount, _Format, 0, _ArgList);
        }
    #line 1630 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

        extern "C++" { template <size_t _Size> inline   int __cdecl vsnprintf_s( char (&_Buffer)[_Size],   size_t _BufferCount,     char const* _Format, va_list _ArgList) throw() { return vsnprintf_s(_Buffer, _Size, _BufferCount, _Format, _ArgList); } }
#line 1639 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    #line 1641 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl _vscprintf_l(
            char const* const _Format,
                                         _locale_t   const _Locale,
                                                va_list           _ArgList
        )
    

#line 1651 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int const _Result = __stdio_common_vsprintf(
            (*__local_stdio_printf_options()) | (1ULL << 1),
            0, 0, _Format, _Locale, _ArgList);

        return _Result < 0 ? -1 : _Result;
    }
    #line 1659 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     
    __inline int __cdecl _vscprintf(
            char const* const _Format,
                                      va_list           _ArgList
        )
    

#line 1668 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        return _vscprintf_l(_Format, 0, _ArgList);
    }
    #line 1672 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl _vscprintf_p_l(
            char const* const _Format,
                                         _locale_t   const _Locale,
                                                va_list           _ArgList
        )
    

#line 1682 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int const _Result = __stdio_common_vsprintf_p(
            (*__local_stdio_printf_options()) | (1ULL << 1),
            0, 0, _Format, _Locale, _ArgList);

        return _Result < 0 ? -1 : _Result;
    }
    #line 1690 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     
    __inline int __cdecl _vscprintf_p(
            char const* const _Format,
                                      va_list           _ArgList
        )
    

#line 1699 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        return _vscprintf_p_l(_Format, 0, _ArgList);
    }
    #line 1703 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl _vsnprintf_c_l(
                   char*       const _Buffer,
                                             size_t      const _BufferCount,
            char const* const _Format,
                                         _locale_t   const _Locale,
                                                va_list           _ArgList
        )
    

#line 1715 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int const _Result = __stdio_common_vsprintf(
            (*__local_stdio_printf_options()),
            _Buffer, _BufferCount, _Format, _Locale, _ArgList);

        return _Result < 0 ? -1 : _Result;
    }
    #line 1723 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     
    __inline int __cdecl _vsnprintf_c(
          char*       const _Buffer,
                                    size_t      const _BufferCount,
             char const* const _Format,
                                       va_list           _ArgList
        )
    

#line 1735 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        return _vsnprintf_c_l(_Buffer, _BufferCount, _Format, 0, _ArgList);
    }
    #line 1739 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     
     __declspec(deprecated("This function or variable may be unsafe. Consider using " "_sprintf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    __inline int __cdecl _sprintf_l(
                  char*       const _Buffer,
            char const* const _Format,
                                         _locale_t   const _Locale,
        ...)
    

#line 1750 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));

        _Result = _vsprintf_l(_Buffer, _Format, _Locale, _ArgList);

        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1761 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     
    __inline int __cdecl sprintf(
           char*       const _Buffer,
               char const* const _Format,
        ...)
    

#line 1771 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));

        _Result = _vsprintf_l(_Buffer, _Format, 0, _ArgList);

        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1782 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    __declspec(deprecated("This function or variable may be unsafe. Consider using " "sprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))   int __cdecl sprintf(  char *_Buffer,  char const* _Format, ...); __declspec(deprecated("This function or variable may be unsafe. Consider using " "vsprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))   int __cdecl vsprintf(  char *_Buffer,  char const* _Format, va_list _Args);
#line 1789 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     
    __inline int __cdecl _sprintf_s_l(
           char*       const _Buffer,
                                                   size_t      const _BufferCount,
                  char const* const _Format,
                                               _locale_t   const _Locale,
        ...)
    

#line 1801 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vsprintf_s_l(_Buffer, _BufferCount, _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1810 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
        __inline int __cdecl sprintf_s(
               char*       const _Buffer,
                                                       size_t      const _BufferCount,
                                char const* const _Format,
            ...)
    

#line 1823 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
        {
            int _Result;
            va_list _ArgList;
            ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
            _Result = _vsprintf_s_l(_Buffer, _BufferCount, _Format, 0, _ArgList);
            ((void)(_ArgList = (va_list)0));
            return _Result;
        }
    #line 1832 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    #line 1834 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    extern "C++" { template <size_t _Size> inline   int __cdecl sprintf_s( char (&_Buffer)[_Size],     char const* _Format, ...) throw() { va_list _ArgList; ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1)))))); return vsprintf_s(_Buffer, _Size, _Format, _ArgList); } }
#line 1841 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     
    __inline int __cdecl _sprintf_p_l(
           char*       const _Buffer,
                                                   size_t      const _BufferCount,
                  char const* const _Format,
                                               _locale_t   const _Locale,
        ...)
    

#line 1853 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vsprintf_p_l(_Buffer, _BufferCount, _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1862 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     
    __inline int __cdecl _sprintf_p(
           char*       const _Buffer,
                                                   size_t      const _BufferCount,
                            char const* const _Format,
        ...)
    

#line 1873 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vsprintf_p_l(_Buffer, _BufferCount, _Format, 0, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1882 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     
     __declspec(deprecated("This function or variable may be unsafe. Consider using " "_snprintf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    __inline int __cdecl _snprintf_l(
            char*       const _Buffer,
                                                  size_t      const _BufferCount,
                 char const* const _Format,
                                              _locale_t   const _Locale,
        ...)
    

#line 1894 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));

        _Result = _vsnprintf_l(_Buffer, _BufferCount, _Format, _Locale, _ArgList);

        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1905 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
#line 1916 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     
    __inline int __cdecl snprintf(
           char*       const _Buffer,
                                                       size_t      const _BufferCount,
                                char const* const _Format,
        ...)
    

#line 1927 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = vsnprintf(_Buffer, _BufferCount, _Format, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1936 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     
    __inline int __cdecl _snprintf(
            char*       const _Buffer,
                                                  size_t      const _BufferCount,
                           char const* const _Format,
        ...)
    

#line 1947 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vsnprintf(_Buffer, _BufferCount, _Format, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1956 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    __declspec(deprecated("This function or variable may be unsafe. Consider using " "_snprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))    int __cdecl _snprintf(    char *_Buffer,   size_t _BufferCount,     char const* _Format, ...); __declspec(deprecated("This function or variable may be unsafe. Consider using " "_vsnprintf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))    int __cdecl _vsnprintf(    char *_Buffer,   size_t _BufferCount,     char const* _Format, va_list _Args);
#line 1965 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     
    __inline int __cdecl _snprintf_c_l(
                   char*       const _Buffer,
                                             size_t      const _BufferCount,
            char const* const _Format,
                                         _locale_t   const _Locale,
        ...)
    

#line 1977 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vsnprintf_c_l(_Buffer, _BufferCount, _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 1986 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     
    __inline int __cdecl _snprintf_c(
          char*       const _Buffer,
                                    size_t      const _BufferCount,
             char const* const _Format,
        ...)
    

#line 1997 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vsnprintf_c_l(_Buffer, _BufferCount, _Format, 0, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 2006 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     
    __inline int __cdecl _snprintf_s_l(
           char*       const _Buffer,
                                                       size_t      const _BufferCount,
                                                       size_t      const _MaxCount,
                      char const* const _Format,
                                                   _locale_t   const _Locale,
        ...)
    

#line 2019 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vsnprintf_s_l(_Buffer, _BufferCount, _MaxCount, _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 2028 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     
    __inline int __cdecl _snprintf_s(
           char*       const _Buffer,
                                                       size_t      const _BufferCount,
                                                       size_t      const _MaxCount,
                                char const* const _Format,
        ...)
    

#line 2040 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vsnprintf_s_l(_Buffer, _BufferCount, _MaxCount, _Format, 0, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 2049 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    extern "C++" { template <size_t _Size> inline   int __cdecl _snprintf_s( char (&_Buffer)[_Size],   size_t _BufferCount,     char const* _Format, ...) throw() { va_list _ArgList; ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1)))))); return _vsnprintf_s(_Buffer, _Size, _BufferCount, _Format, _ArgList); } }
#line 2057 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl _scprintf_l(
            char const* const _Format,
                                         _locale_t   const _Locale,
        ...)
    

#line 2066 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vscprintf_l(_Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 2075 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     
    __inline int __cdecl _scprintf(
            char const* const _Format,
        ...)
    

#line 2083 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vscprintf_l(_Format, 0, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 2092 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl _scprintf_p_l(
            char const* const _Format,
                                         _locale_t   const _Locale,
        ...)
    

#line 2101 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vscprintf_p_l(_Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 2110 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     
    __inline int __cdecl _scprintf_p(
            char const* const _Format,
        ...)
    

#line 2118 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vscprintf_p(_Format, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 2127 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
     int __cdecl __stdio_common_vsscanf(
                                            unsigned __int64 _Options,
                  char const*      _Buffer,
                                            size_t           _BufferCount,
            char const*      _Format,
                                        _locale_t        _Locale,
                                               va_list          _ArgList
        );

    
    __inline int __cdecl _vsscanf_l(
                                 char const* const _Buffer,
            char const* const _Format,
                               _locale_t   const _Locale,
                                      va_list           _ArgList
        )
    

#line 2152 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        return __stdio_common_vsscanf(
            (*__local_stdio_scanf_options ()),
            _Buffer, (size_t)-1, _Format, _Locale, _ArgList);
    }
    #line 2158 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl vsscanf(
                                 char const* const _Buffer,
            char const* const _Format,
                                      va_list           _ArgList
        )
    

#line 2168 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        return _vsscanf_l(_Buffer, _Format, 0, _ArgList);
    }
    #line 2172 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl _vsscanf_s_l(
                                 char const* const _Buffer,
            char const* const _Format,
                               _locale_t   const _Locale,
                                      va_list           _ArgList
        )
    

#line 2183 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        return __stdio_common_vsscanf(
            (*__local_stdio_scanf_options ()) | (1ULL << 0),
            _Buffer, (size_t)-1, _Format, _Locale, _ArgList);
    }
    #line 2189 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
        #pragma warning(push)
        #pragma warning(disable: 6530) 

        
        __inline int __cdecl vsscanf_s(
                                     char const* const _Buffer,
                char const* const _Format,
                                          va_list           _ArgList
            )
    

#line 2204 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
        {
            return _vsscanf_s_l(_Buffer, _Format, 0, _ArgList);
        }
    #line 2208 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

        extern "C++" { template <size_t _Size> inline int __cdecl vsscanf_s(  char const (&_Buffer)[_Size],     char const* _Format, va_list _ArgList) throw() { return vsscanf_s(_Buffer, _Size, _Format, _ArgList); } }
#line 2215 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

        #pragma warning(pop)

    #line 2219 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     __declspec(deprecated("This function or variable may be unsafe. Consider using " "_sscanf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    __inline int __cdecl _sscanf_l(
                                          char const* const _Buffer,
            char const* const _Format,
                                        _locale_t   const _Locale,
        ...)
    

#line 2229 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vsscanf_l(_Buffer, _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 2238 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

      __declspec(deprecated("This function or variable may be unsafe. Consider using " "sscanf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    __inline int __cdecl sscanf(
                                char const* const _Buffer,
            char const* const _Format,
        ...)
    

#line 2247 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vsscanf_l(_Buffer, _Format, 0, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 2256 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl _sscanf_s_l(
                                            char const* const _Buffer,
            char const* const _Format,
                                          _locale_t   const _Locale,
        ...)
    

#line 2266 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vsscanf_s_l(_Buffer, _Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 2275 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
        __inline int __cdecl sscanf_s(
                                      char const* const _Buffer,
                char const* const _Format,
            ...)
    

#line 2286 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
        {
            int _Result;
            va_list _ArgList;
            ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));

            _Result = vsscanf_s(_Buffer, _Format, _ArgList);

            ((void)(_ArgList = (va_list)0));
            return _Result;
        }
    #line 2297 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    #line 2299 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    #pragma warning(push)
    #pragma warning(disable: 6530) 

     __declspec(deprecated("This function or variable may be unsafe. Consider using " "_snscanf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    __inline int __cdecl _snscanf_l(
            char const* const _Buffer,
                                            size_t      const _BufferCount,
            char const* const _Format,
                                        _locale_t   const _Locale,
        ...)
    

#line 2313 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));

        _Result = __stdio_common_vsscanf(
            (*__local_stdio_scanf_options ()),
            _Buffer, _BufferCount, _Format, _Locale, _ArgList);

        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 2326 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

     __declspec(deprecated("This function or variable may be unsafe. Consider using " "_snscanf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    __inline int __cdecl _snscanf(
            char const* const _Buffer,
                                            size_t      const _BufferCount,
                      char const* const _Format,
        ...)
    

#line 2336 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));

        _Result = __stdio_common_vsscanf(
            (*__local_stdio_scanf_options ()),
            _Buffer, _BufferCount, _Format, 0, _ArgList);

        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 2349 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"


    __inline int __cdecl _snscanf_s_l(
              char const* const _Buffer,
                                              size_t      const _BufferCount,
            char const* const _Format,
                                          _locale_t   const _Locale,
        ...)
    

#line 2361 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));

        _Result = __stdio_common_vsscanf(
            (*__local_stdio_scanf_options ()) | (1ULL << 0),
            _Buffer, _BufferCount, _Format, _Locale, _ArgList);

        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 2374 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    
    __inline int __cdecl _snscanf_s(
            char const* const _Buffer,
                                            size_t      const _BufferCount,
                    char const* const _Format,
        ...)
    

#line 2384 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));

        _Result = __stdio_common_vsscanf(
            (*__local_stdio_scanf_options ()) | (1ULL << 0),
            _Buffer, _BufferCount, _Format, 0, _ArgList);

        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
    #line 2397 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

    #pragma warning(pop)

    
#line 2403 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"


#line 2419 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

        __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_tempnam" ". See online help for details."))
         char* __cdecl tempnam(
              char const* _Directory,
              char const* _FilePrefix
            );

        
#line 2429 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"

         __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_fcloseall" ". See online help for details."))  int   __cdecl fcloseall(void);
              __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_fdopen" ". See online help for details."))     FILE* __cdecl fdopen(  int _FileHandle,   char const* _Format);
         __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_fgetchar" ". See online help for details."))   int   __cdecl fgetchar(void);
              __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_fileno" ". See online help for details."))     int   __cdecl fileno(  FILE* _Stream);
         __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_flushall" ". See online help for details."))   int   __cdecl flushall(void);
         __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_fputchar" ". See online help for details."))   int   __cdecl fputchar(  int _Ch);
              __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_getw" ". See online help for details."))       int   __cdecl getw(  FILE* _Stream);
         __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_putw" ". See online help for details."))       int   __cdecl putw(  int _Ch,   FILE* _Stream);
              __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_rmtmp" ". See online help for details."))      int   __cdecl rmtmp(void);

    #line 2441 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
#line 2442 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"


} __pragma(pack(pop))

#pragma warning(pop) 
#line 2449 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\stdio.h"
#line 13 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cstdio"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
#pragma warning(push)
#pragma warning(disable : 4995) 

using :: FILE;
using :: _Mbstatet;

using :: size_t;
using :: fpos_t;
using :: FILE;
using :: clearerr;
using :: fclose;
using :: feof;
using :: ferror;
using :: fflush;
using :: fgetc;
using :: fgetpos;
using :: fgets;
using :: fopen;
using :: fprintf;
using :: fputc;
using :: fputs;
using :: fread;
using :: freopen;
using :: fscanf;
using :: fseek;
using :: fsetpos;
using :: ftell;
using :: fwrite;
using :: getc;
using :: getchar;
using :: perror;
using :: putc;
using :: putchar;
using :: printf;
using :: puts;
using :: remove;
using :: rename;
using :: rewind;
using :: scanf;
using :: setbuf;
using :: setvbuf;
using :: sprintf;
using :: sscanf;
using :: tmpfile;
using :: tmpnam;
using :: ungetc;
using :: vfprintf;
using :: vprintf;
using :: vsprintf;

using :: snprintf;
using :: vsnprintf;
using :: vfscanf;
using :: vscanf;
using :: vsscanf;

#pragma warning(pop)
}


#pragma warning(pop)
#pragma pack(pop)

#line 99 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cstdio"
#line 100 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cstdio"
#line 13 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cwchar"
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\wchar.h"


#pragma once


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_memcpy_s.h"


#pragma once


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\errno.h"


#pragma once


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


     int* __cdecl _errno(void);
    

     errno_t __cdecl _set_errno(  int _Value);
     errno_t __cdecl _get_errno(  int* _Value);

     unsigned long* __cdecl __doserrno(void);
    

     errno_t __cdecl _set_doserrno(  unsigned long _Value);
     errno_t __cdecl _get_doserrno(  unsigned long * _Value);
#line 35 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\errno.h"


#line 83 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\errno.h"


#line 131 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\errno.h"


} __pragma(pack(pop))

#pragma warning(pop) 
#line 138 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\errno.h"
#line 12 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_memcpy_s.h"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime_string.h"


#pragma once


#pragma warning(push)
#pragma warning(disable:   4514 4820 )


__pragma(pack(push, 8)) extern "C" {


[[nodiscard]]  
 void const* __cdecl memchr(
      void const* _Buf,
                                 int         _Val,
                                 size_t      _MaxCount
    );

[[nodiscard]]  
int __cdecl memcmp(
      void const* _Buf1,
      void const* _Buf2,
                         size_t      _Size
    );


#line 43 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime_string.h"
void* __cdecl memcpy(
      void* _Dst,
            void const* _Src,
                               size_t      _Size
    );


 void* __cdecl memmove(
      void*       _Dst,
            void const* _Src,
                                   size_t      _Size
    );

 
#line 63 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime_string.h"
void* __cdecl memset(
      void*  _Dst,
                               int    _Val,
                               size_t _Size
    );

[[nodiscard]]  
 char const* __cdecl strchr(
      char const* _Str,
        int         _Val
    );

[[nodiscard]]  
 char const* __cdecl strrchr(
      char const* _Str,
        int         _Ch
    );

[[nodiscard]]    
 char const* __cdecl strstr(
      char const* _Str,
      char const* _SubStr
    );

[[nodiscard]]  

 wchar_t const* __cdecl wcschr(
      wchar_t const* _Str,
        wchar_t        _Ch
    );

[[nodiscard]]  
 wchar_t const* __cdecl wcsrchr(
      wchar_t const* _Str,
        wchar_t        _Ch
    );

[[nodiscard]]    

 wchar_t const* __cdecl wcsstr(
      wchar_t const* _Str,
      wchar_t const* _SubStr
    );


} __pragma(pack(pop))

#line 112 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime_string.h"

#pragma warning(pop) 
#line 13 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_memcpy_s.h"

#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


#line 23 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_memcpy_s.h"


    static __inline errno_t __cdecl memcpy_s(
          void*       const _Destination,
                                                              rsize_t     const _DestinationSize,
                                 void const* const _Source,
                                                              rsize_t     const _SourceSize
        )
    {
        if (_SourceSize == 0)
        {
            return 0;
        }

        { int _Expr_val=!!(_Destination != 0); if (!(_Expr_val)) { (*_errno()) = 22; _invalid_parameter_noinfo(); return 22; } };
        if (_Source == 0 || _DestinationSize < _SourceSize)
        {
            memset(_Destination, 0, _DestinationSize);

            { int _Expr_val=!!(_Source != 0); if (!(_Expr_val)) { (*_errno()) = 22; _invalid_parameter_noinfo(); return 22; } };
            { int _Expr_val=!!(_DestinationSize >= _SourceSize); if (!(_Expr_val)) { (*_errno()) = 34; _invalid_parameter_noinfo(); return 34; } };

            
            return 22;
        }
        memcpy(_Destination, _Source, _SourceSize);
        return 0;
    }

    
    static __inline errno_t __cdecl memmove_s(
          void*       const _Destination,
                                                              rsize_t     const _DestinationSize,
                                 void const* const _Source,
                                                              rsize_t     const _SourceSize
        )
    {
        if (_SourceSize == 0)
        {
            return 0;
        }

        { int _Expr_val=!!(_Destination != 0); if (!(_Expr_val)) { (*_errno()) = 22; _invalid_parameter_noinfo(); return 22; } };
        { int _Expr_val=!!(_Source != 0); if (!(_Expr_val)) { (*_errno()) = 22; _invalid_parameter_noinfo(); return 22; } };
        { int _Expr_val=!!(_DestinationSize >= _SourceSize); if (!(_Expr_val)) { (*_errno()) = 34; _invalid_parameter_noinfo(); return 34; } };

        memmove(_Destination, _Source, _SourceSize);
        return 0;
    }

#line 88 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_memcpy_s.h"


#pragma warning(pop) 
} __pragma(pack(pop))
#line 16 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\wchar.h"
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"


#pragma once


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


     errno_t __cdecl _cgetws_s(
          wchar_t* _Buffer,
                                               size_t   _BufferCount,
                                              size_t*  _SizeRead
        );

    extern "C++" { template <size_t _Size> inline   errno_t __cdecl _cgetws_s(  wchar_t (&_Buffer)[_Size],   size_t* _SizeRead) throw() { return _cgetws_s(_Buffer, _Size, _SizeRead); } }
#line 40 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"

    
     int __cdecl _cputws(
          wchar_t const* _Buffer
        );

           wint_t __cdecl _getwch  (void);
           wint_t __cdecl _getwche (void);
      wint_t __cdecl _putwch  (  wchar_t _Character);
      wint_t __cdecl _ungetwch(  wint_t  _Character);

           wint_t __cdecl _getwch_nolock  (void);
           wint_t __cdecl _getwche_nolock (void);
      wint_t __cdecl _putwch_nolock  (  wchar_t _Character);
      wint_t __cdecl _ungetwch_nolock(  wint_t  _Character);


     int __cdecl __conio_common_vcwprintf(
                                             unsigned __int64 _Options,
            wchar_t const*   _Format,
                                         _locale_t        _Locale,
                                                va_list          _ArgList
        );

    
     int __cdecl __conio_common_vcwprintf_s(
                                             unsigned __int64 _Options,
            wchar_t const*   _Format,
                                         _locale_t        _Locale,
                                                va_list          _ArgList
        );

    
     int __cdecl __conio_common_vcwprintf_p(
                                             unsigned __int64 _Options,
            wchar_t const*   _Format,
                                         _locale_t        _Locale,
                                                va_list          _ArgList
        );

    
    __inline int __cdecl _vcwprintf_l(
            wchar_t const* const _Format,
                                         _locale_t      const _Locale,
                                                va_list              _ArgList
        )


#line 96 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"
    {
        return __conio_common_vcwprintf((*__local_stdio_printf_options()), _Format, _Locale, _ArgList);
    }
#line 100 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"

    
    __inline int __cdecl _vcwprintf(
            wchar_t const* const _Format,
                                      va_list              _ArgList
        )


#line 109 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"
    {
        return _vcwprintf_l(_Format, 0, _ArgList);
    }
#line 113 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"

    
    __inline int __cdecl _vcwprintf_s_l(
            wchar_t const* const _Format,
                                         _locale_t      const _Locale,
                                                va_list              _ArgList
        )


#line 123 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"
    {
        return __conio_common_vcwprintf_s((*__local_stdio_printf_options()), _Format, _Locale, _ArgList);
    }
#line 127 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"

    
    __inline int __cdecl _vcwprintf_s(
            wchar_t const* const _Format,
                                      va_list              _ArgList
        )


#line 136 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"
    {
        return _vcwprintf_s_l(_Format, 0, _ArgList);
    }
#line 140 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"

    
    __inline int __cdecl _vcwprintf_p_l(
            wchar_t const* const _Format,
                                         _locale_t      const _Locale,
                                                va_list              _ArgList
        )


#line 150 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"
    {
        return __conio_common_vcwprintf_p((*__local_stdio_printf_options()), _Format, _Locale, _ArgList);
    }
#line 154 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"

    
    __inline int __cdecl _vcwprintf_p(
            const wchar_t* const _Format,
                                      va_list              _ArgList
        )


#line 163 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"
    {
        return _vcwprintf_p_l(_Format, 0, _ArgList);
    }
#line 167 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"

    
    __inline int __cdecl _cwprintf_l(
            wchar_t const* const _Format,
                                         _locale_t      const _Locale,
        ...)


#line 176 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vcwprintf_l(_Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
#line 185 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"

    
    __inline int __cdecl _cwprintf(
            wchar_t const* const _Format,
        ...)


#line 193 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vcwprintf_l(_Format, 0, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
#line 202 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"

    
    __inline int __cdecl _cwprintf_s_l(
            wchar_t const* const _Format,
                                         _locale_t      const _Locale,
        ...)


#line 211 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vcwprintf_s_l(_Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
#line 220 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"

    
    __inline int __cdecl _cwprintf_s(
            wchar_t const* const _Format,
        ...)


#line 228 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vcwprintf_s_l(_Format, 0, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
#line 237 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"

    
    __inline int __cdecl _cwprintf_p_l(
            wchar_t const* const _Format,
                                         _locale_t      const _Locale,
        ...)


#line 246 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vcwprintf_p_l(_Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
#line 255 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"

    
    __inline int __cdecl _cwprintf_p(
            wchar_t const* const _Format,
        ...)


#line 263 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vcwprintf_p_l(_Format, 0, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
#line 272 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"


     int __cdecl __conio_common_vcwscanf(
                                            unsigned __int64 _Options,
            wchar_t const*   _Format,
                                        _locale_t        _Locale,
                                               va_list          _ArgList
        );

     __declspec(deprecated("This function or variable may be unsafe. Consider using " "_vcwscanf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    __inline int __cdecl _vcwscanf_l(
            wchar_t const* const _Format,
                                        _locale_t      const _Locale,
                                               va_list              _ArgList
        )


#line 297 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"
    {
        return __conio_common_vcwscanf(
            (*__local_stdio_scanf_options ()),
            _Format, _Locale, _ArgList);
    }
#line 303 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"

     __declspec(deprecated("This function or variable may be unsafe. Consider using " "_vcwscanf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    __inline int __cdecl _vcwscanf(
            wchar_t const* const _Format,
                                               va_list              _ArgList
        )


#line 312 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"
    {
        return _vcwscanf_l(_Format, 0, _ArgList);
    }
#line 316 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"

    
    __inline int __cdecl _vcwscanf_s_l(
            wchar_t const* const _Format,
                                        _locale_t      const _Locale,
                                               va_list              _ArgList
        )


#line 326 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"
    {
        return __conio_common_vcwscanf(
            (*__local_stdio_scanf_options ()) | (1ULL << 0),
            _Format, _Locale, _ArgList);
    }
#line 332 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"

    
    __inline int __cdecl _vcwscanf_s(
            wchar_t const* const _Format,
                                               va_list              _ArgList
        )


#line 341 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"
    {
        return _vcwscanf_s_l(_Format, 0, _ArgList);
    }
#line 345 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"

     __declspec(deprecated("This function or variable may be unsafe. Consider using " "_cwscanf_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    __inline int __cdecl _cwscanf_l(
            wchar_t const* const _Format,
                                        _locale_t      const _Locale,
        ...)


#line 354 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));

        _Result = _vcwscanf_l(_Format, _Locale, _ArgList);

        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
#line 365 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"

     __declspec(deprecated("This function or variable may be unsafe. Consider using " "_cwscanf_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    __inline int __cdecl _cwscanf(
            wchar_t const* const _Format,
        ...)


#line 373 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));

        _Result = _vcwscanf_l(_Format, 0, _ArgList);

        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
#line 384 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"

    
    __inline int __cdecl _cwscanf_s_l(
            wchar_t const* const _Format,
                                        _locale_t      const _Locale,
        ...)


#line 393 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Locale)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Locale))) + ((sizeof(_Locale) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vcwscanf_s_l(_Format, _Locale, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
#line 402 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"

    
    __inline int __cdecl _cwscanf_s(
            wchar_t const* const _Format,
        ...)


#line 410 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"
    {
        int _Result;
        va_list _ArgList;
        ((void)(__vcrt_assert_va_start_is_not_reference<decltype(_Format)>(), ((void)(_ArgList = (va_list)(&const_cast<char&>(reinterpret_cast<const volatile char&>(_Format))) + ((sizeof(_Format) + sizeof(int) - 1) & ~(sizeof(int) - 1))))));
        _Result = _vcwscanf_s_l(_Format, 0, _ArgList);
        ((void)(_ArgList = (va_list)0));
        return _Result;
    }
#line 419 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"

#line 421 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wconio.h"

} __pragma(pack(pop))

#pragma warning(pop) 
#line 17 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\wchar.h"
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wctype.h"


#pragma once


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


#line 32 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wctype.h"
        
    #line 34 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wctype.h"

     const unsigned short* __cdecl __pctype_func(void);
     const wctype_t*       __cdecl __pwctype_func(void);

    
    #line 45 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wctype.h"
#line 46 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wctype.h"


   int __cdecl iswalnum  (  wint_t _C);
   int __cdecl iswalpha  (  wint_t _C);
   int __cdecl iswascii  (  wint_t _C);
   int __cdecl iswblank  (  wint_t _C);
   int __cdecl iswcntrl  (  wint_t _C);


   int __cdecl iswdigit  (  wint_t _C);

   int __cdecl iswgraph  (  wint_t _C);
   int __cdecl iswlower  (  wint_t _C);
   int __cdecl iswprint  (  wint_t _C);
   int __cdecl iswpunct  (  wint_t _C);
   int __cdecl iswspace  (  wint_t _C);
   int __cdecl iswupper  (  wint_t _C);
   int __cdecl iswxdigit (  wint_t _C);
   int __cdecl __iswcsymf(  wint_t _C);
   int __cdecl __iswcsym (  wint_t _C);

   int __cdecl _iswalnum_l (  wint_t _C,   _locale_t _Locale);
   int __cdecl _iswalpha_l (  wint_t _C,   _locale_t _Locale);
   int __cdecl _iswblank_l (  wint_t _C,   _locale_t _Locale);
   int __cdecl _iswcntrl_l (  wint_t _C,   _locale_t _Locale);
   int __cdecl _iswdigit_l (  wint_t _C,   _locale_t _Locale);
   int __cdecl _iswgraph_l (  wint_t _C,   _locale_t _Locale);
   int __cdecl _iswlower_l (  wint_t _C,   _locale_t _Locale);
   int __cdecl _iswprint_l (  wint_t _C,   _locale_t _Locale);
   int __cdecl _iswpunct_l (  wint_t _C,   _locale_t _Locale);
   int __cdecl _iswspace_l (  wint_t _C,   _locale_t _Locale);
   int __cdecl _iswupper_l (  wint_t _C,   _locale_t _Locale);
   int __cdecl _iswxdigit_l(  wint_t _C,   _locale_t _Locale);
   int __cdecl _iswcsymf_l (  wint_t _C,   _locale_t _Locale);
   int __cdecl _iswcsym_l  (  wint_t _C,   _locale_t _Locale);


   wint_t __cdecl towupper(  wint_t _C);
   wint_t __cdecl towlower(  wint_t _C);
   int    __cdecl iswctype(  wint_t _C,   wctype_t _Type);

   wint_t __cdecl _towupper_l(  wint_t _C,   _locale_t _Locale);
   wint_t __cdecl _towlower_l(  wint_t _C,   _locale_t _Locale);
   int    __cdecl _iswctype_l(  wint_t _C,   wctype_t _Type,   _locale_t _Locale);


       int __cdecl isleadbyte(  int _C);
       int __cdecl _isleadbyte_l(  int _C,   _locale_t _Locale);

    __declspec(deprecated("This function or variable has been superceded by newer library " "or operating system functionality. Consider using " "iswctype" " " "instead. See online help for details."))  int __cdecl is_wctype(  wint_t _C,   wctype_t _Type);
#line 117 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wctype.h"


#line 200 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wctype.h"


} __pragma(pack(pop))

#pragma warning(pop) 
#line 18 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\wchar.h"
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wdirect.h"


#pragma once


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


 __declspec(allocator) wchar_t* __cdecl _wgetcwd(
      wchar_t* _DstBuf,
                                  int      _SizeInWords
    );

 
 __declspec(allocator) wchar_t* __cdecl _wgetdcwd(
                                  int      _Drive,
      wchar_t* _DstBuf,
                                  int      _SizeInWords
    );


 int __cdecl _wchdir(
      wchar_t const* _Path
    );

 
 int __cdecl _wmkdir(
      wchar_t const* _Path
    );

 
 int __cdecl _wrmdir(
      wchar_t const* _Path
    );


} __pragma(pack(pop))

#pragma warning(pop) 
#line 19 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\wchar.h"
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wio.h"


#pragma once


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_share.h"


#pragma once


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


#line 31 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_share.h"


#pragma warning(pop) 
#line 13 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wio.h"

#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


#line 32 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wio.h"

typedef unsigned long _fsize_t;

struct _wfinddata32_t
{
    unsigned   attrib;
    __time32_t time_create;    
    __time32_t time_access;    
    __time32_t time_write;
    _fsize_t   size;
    wchar_t    name[260];
};

struct _wfinddata32i64_t
{
    unsigned   attrib;
    __time32_t time_create;    
    __time32_t time_access;    
    __time32_t time_write;
    __int64    size;
    wchar_t    name[260];
};

struct _wfinddata64i32_t
{
    unsigned   attrib;
    __time64_t time_create;    
    __time64_t time_access;    
    __time64_t time_write;
    _fsize_t   size;
    wchar_t    name[260];
};

struct _wfinddata64_t
{
    unsigned   attrib;
    __time64_t time_create;    
    __time64_t time_access;    
    __time64_t time_write;
    __int64    size;
    wchar_t    name[260];
};


#line 93 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wio.h"

 
 int __cdecl _waccess(
      wchar_t const* _FileName,
        int            _AccessMode
    );


 errno_t __cdecl _waccess_s(
      wchar_t const* _FileName,
        int            _AccessMode
    );

 
 int __cdecl _wchmod(
      wchar_t const* _FileName,
        int            _Mode
    );

  __declspec(deprecated("This function or variable may be unsafe. Consider using " "_wsopen_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
 int __cdecl _wcreat(
      wchar_t const* _FileName,
        int            _PermissionMode
    );

 
 intptr_t __cdecl _wfindfirst32(
      wchar_t const*         _FileName,
       struct _wfinddata32_t* _FindData
    );

 
 int __cdecl _wfindnext32(
       intptr_t               _FindHandle,
      struct _wfinddata32_t* _FindData
    );

 int __cdecl _wunlink(
      wchar_t const* _FileName
    );

 
 int __cdecl _wrename(
      wchar_t const* _OldFileName,
      wchar_t const* _NewFileName
    );

 errno_t __cdecl _wmktemp_s(
      wchar_t* _TemplateName,
                                 size_t   _SizeInWords
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl _wmktemp_s(wchar_t (&_TemplateName)[_Size]) throw() { return _wmktemp_s(_TemplateName, _Size); } }
#line 151 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wio.h"

 
__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wmktemp_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  wchar_t* __cdecl _wmktemp( wchar_t *_TemplateName);
#line 157 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wio.h"

 
 intptr_t __cdecl _wfindfirst32i64(
      wchar_t const*            _FileName,
       struct _wfinddata32i64_t* _FindData
    );

 
 intptr_t __cdecl _wfindfirst64i32(
      wchar_t const*            _FileName,
       struct _wfinddata64i32_t* _FindData
    );

 
 intptr_t __cdecl _wfindfirst64(
      wchar_t const*         _FileName,
       struct _wfinddata64_t* _FindData
    );

 
 int __cdecl _wfindnext32i64(
       intptr_t                  _FindHandle,
      struct _wfinddata32i64_t* _FindData
    );

 
 int __cdecl _wfindnext64i32(
       intptr_t                  _FindHandle,
      struct _wfinddata64i32_t* _FindData
    );

 
 int __cdecl _wfindnext64(
       intptr_t               _FindHandle,
      struct _wfinddata64_t* _FindData
    );


 errno_t __cdecl _wsopen_s(
       int*           _FileHandle,
      wchar_t const* _FileName,
        int            _OpenFlag,
        int            _ShareFlag,
        int            _PermissionFlag
    );

 errno_t __cdecl _wsopen_dispatch(
      wchar_t const* _FileName,
        int            _OFlag,
        int            _ShFlag,
        int            _PMode,
       int*           _PFileHandle,
        int            _BSecure
    );


    extern "C++"   __declspec(deprecated("This function or variable may be unsafe. Consider using " "_wsopen_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    inline int __cdecl _wopen(
          wchar_t const* _FileName,
            int            _OFlag,
            int            _PMode = 0
        )
    {
        int _FileHandle;
        
        errno_t const _Result = _wsopen_dispatch(_FileName, _OFlag, 0x40, _PMode, &_FileHandle, 0);
        return _Result ? -1 : _FileHandle;
    }

    extern "C++"   __declspec(deprecated("This function or variable may be unsafe. Consider using " "_wsopen_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    inline int __cdecl _wsopen(
          wchar_t const* _FileName,
            int            _OFlag,
            int            _ShFlag,
            int            _PMode = 0
        )
    {
        int _FileHandle;
        
        errno_t const _Result = _wsopen_dispatch(_FileName, _OFlag, _ShFlag, _PMode, &_FileHandle, 0);
        return _Result ? -1 : _FileHandle;
    }


#line 267 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wio.h"

} __pragma(pack(pop))

#pragma warning(pop) 
#line 20 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\wchar.h"
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wprocess.h"


#pragma once


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


         intptr_t __cdecl _wexecl(
              wchar_t const* _FileName,
              wchar_t const* _ArgList,
            ...);

         intptr_t __cdecl _wexecle(
              wchar_t const* _FileName,
              wchar_t const* _ArgList,
            ...);

         intptr_t __cdecl _wexeclp(
              wchar_t const* _FileName,
              wchar_t const* _ArgList,
            ...);

         intptr_t __cdecl _wexeclpe(
              wchar_t const* _FileName,
              wchar_t const* _ArgList,
            ...);

         intptr_t __cdecl _wexecv(
              wchar_t const*        _FileName,
              wchar_t const* const* _ArgList
            );

         intptr_t __cdecl _wexecve(
                  wchar_t const*        _FileName,
                  wchar_t const* const* _ArgList,
              wchar_t const* const* _Env
            );

         intptr_t __cdecl _wexecvp(
              wchar_t const*        _FileName,
              wchar_t const* const* _ArgList
            );

         intptr_t __cdecl _wexecvpe(
                  wchar_t const*        _FileName,
                  wchar_t const* const* _ArgList,
              wchar_t const* const* _Env
            );

         intptr_t __cdecl _wspawnl(
                int            _Mode,
              wchar_t const* _FileName,
              wchar_t const* _ArgList,
            ...);

         intptr_t __cdecl _wspawnle(
                int            _Mode,
              wchar_t const* _FileName,
              wchar_t const* _ArgList,
            ...);

         intptr_t __cdecl _wspawnlp(
                int            _Mode,
              wchar_t const* _FileName,
              wchar_t const* _ArgList,
            ...);

         intptr_t __cdecl _wspawnlpe(
                int            _Mode,
              wchar_t const* _FileName,
              wchar_t const* _ArgList,
            ...);

         intptr_t __cdecl _wspawnv(
                int                   _Mode,
              wchar_t const*        _FileName,
              wchar_t const* const* _ArgList
            );

         intptr_t __cdecl _wspawnve(
                    int                   _Mode,
                  wchar_t const*        _FileName,
                  wchar_t const* const* _ArgList,
              wchar_t const* const* _Env
            );

         intptr_t __cdecl _wspawnvp(
                int                   _Mode,
              wchar_t const*        _FileName,
              wchar_t const* const* _ArgList
            );

         intptr_t __cdecl _wspawnvpe(
                    int                   _Mode,
                  wchar_t const*        _FileName,
                  wchar_t const* const* _ArgList,
              wchar_t const* const* _Env
            );

         int __cdecl _wsystem(
              wchar_t const* _Command
            );

    #line 121 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wprocess.h"
#line 122 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wprocess.h"


} __pragma(pack(pop))

#pragma warning(pop) 
#line 21 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\wchar.h"


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"


#pragma once


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


     errno_t __cdecl wcscat_s(
          wchar_t* _Destination,
          rsize_t _SizeInWords,
          wchar_t const* _Source
        );

    
     errno_t __cdecl wcscpy_s(
          wchar_t* _Destination,
          rsize_t _SizeInWords,
          wchar_t const* _Source
        );

    
     errno_t __cdecl wcsncat_s(
          wchar_t*       _Destination,
                                     rsize_t        _SizeInWords,
               wchar_t const* _Source,
                                     rsize_t        _MaxCount
        );

    
     errno_t __cdecl wcsncpy_s(
          wchar_t*       _Destination,
                                  rsize_t        _SizeInWords,
            wchar_t const* _Source,
                                  rsize_t        _MaxCount
        );

     
     wchar_t* __cdecl wcstok_s(
                          wchar_t*       _String,
                                 wchar_t const* _Delimiter,
            wchar_t**      _Context
        );

#line 69 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"


#line 81 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"

 
 __declspec(allocator) wchar_t* __cdecl _wcsdup(
      wchar_t const* _String
    );


#line 90 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"


extern "C++" { template <size_t _Size> inline errno_t __cdecl wcscat_s(wchar_t (&_Destination)[_Size],   wchar_t const* _Source) throw() { return wcscat_s(_Destination, _Size, _Source); } }
#line 98 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"


    __declspec(deprecated("This function or variable may be unsafe. Consider using " "wcscat_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  wchar_t* __cdecl wcscat( wchar_t *_Destination,  wchar_t const* _Source);
#line 105 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"
#line 106 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"

 
 int __cdecl wcscmp(
      wchar_t const* _String1,
      wchar_t const* _String2
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl wcscpy_s(wchar_t (&_Destination)[_Size],   wchar_t const* _Source) throw() { return wcscpy_s(_Destination, _Size, _Source); } }
#line 118 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "wcscpy_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  wchar_t* __cdecl wcscpy( wchar_t *_Destination,  wchar_t const* _Source);
#line 124 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"

 
 size_t __cdecl wcscspn(
      wchar_t const* _String,
      wchar_t const* _Control
    );

 
 size_t __cdecl wcslen(
      wchar_t const* _String
    );

 
#line 141 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"

#line 145 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"
 size_t __cdecl wcsnlen(
      wchar_t const* _Source,
                            size_t         _MaxCount
    );


#line 157 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"
    
#line 161 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"
    static __inline size_t __cdecl wcsnlen_s(
          wchar_t const* _Source,
                                size_t         _MaxCount
        )
    {
        return (_Source == 0) ? 0 : wcsnlen(_Source, _MaxCount);
    }

#line 170 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"

extern "C++" { template <size_t _Size> inline errno_t __cdecl wcsncat_s(  wchar_t (&_Destination)[_Size],   wchar_t const* _Source,   size_t _Count) throw() { return wcsncat_s(_Destination, _Size, _Source, _Count); } }
#line 177 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "wcsncat_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  wchar_t* __cdecl wcsncat(  wchar_t *_Destination,   wchar_t const* _Source,   size_t _Count);
#line 185 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"

 
 int __cdecl wcsncmp(
      wchar_t const* _String1,
      wchar_t const* _String2,
                            size_t         _MaxCount
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl wcsncpy_s(wchar_t (&_Destination)[_Size],   wchar_t const* _Source,   size_t _Count) throw() { return wcsncpy_s(_Destination, _Size, _Source, _Count); } }
#line 199 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "wcsncpy_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  wchar_t* __cdecl wcsncpy(    wchar_t *_Destination,   wchar_t const* _Source,   size_t _Count);
#line 207 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"

 
 wchar_t const* __cdecl wcspbrk(
      wchar_t const* _String,
      wchar_t const* _Control
    );

 
 size_t __cdecl wcsspn(
      wchar_t const* _String,
      wchar_t const* _Control
    );

  __declspec(deprecated("This function or variable may be unsafe. Consider using " "wcstok_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
 wchar_t* __cdecl wcstok(
                          wchar_t*       _String,
                                 wchar_t const* _Delimiter,
        wchar_t**      _Context
    );


#line 232 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"
        

    #line 237 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"

      __declspec(deprecated("This function or variable may be unsafe. Consider using " "wcstok_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
    static __inline wchar_t* __cdecl _wcstok(
          wchar_t*       const _String,
                 wchar_t const* const _Delimiter
        )
    {
        return wcstok(_String, _Delimiter, 0);
    }

    
#line 250 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"

    
        extern "C++"   __declspec(deprecated("wcstok has been changed to conform with the ISO C standard, " "adding an extra context parameter. To use the legacy Microsoft " "wcstok, define _CRT_NON_CONFORMING_WCSTOK."))
        inline wchar_t* __cdecl wcstok(
              wchar_t*       _String,
                     wchar_t const* _Delimiter
            ) throw()
        {
            return wcstok(_String, _Delimiter, 0);
        }
    #line 261 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"

#line 263 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"


  __declspec(deprecated("This function or variable may be unsafe. Consider using " "_wcserror_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
 wchar_t* __cdecl _wcserror(
      int _ErrorNumber
    );


 errno_t __cdecl _wcserror_s(
      wchar_t* _Buffer,
                                  size_t   _SizeInWords,
                                  int      _ErrorNumber
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl _wcserror_s(wchar_t (&_Buffer)[_Size],   int _Error) throw() { return _wcserror_s(_Buffer, _Size, _Error); } }
#line 284 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"

 
  __declspec(deprecated("This function or variable may be unsafe. Consider using " "__wcserror_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
 wchar_t* __cdecl __wcserror(
      wchar_t const* _String
    );

  errno_t __cdecl __wcserror_s(
      wchar_t*       _Buffer,
                                  size_t         _SizeInWords,
                                wchar_t const* _ErrorMessage
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl __wcserror_s(wchar_t (&_Buffer)[_Size],   wchar_t const* _ErrorMessage) throw() { return __wcserror_s(_Buffer, _Size, _ErrorMessage); } }
#line 303 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"

   int __cdecl _wcsicmp(
      wchar_t const* _String1,
      wchar_t const* _String2
    );

   int __cdecl _wcsicmp_l(
        wchar_t const* _String1,
        wchar_t const* _String2,
      _locale_t      _Locale
    );

   int __cdecl _wcsnicmp(
      wchar_t const* _String1,
      wchar_t const* _String2,
                            size_t         _MaxCount
    );

   int __cdecl _wcsnicmp_l(
      wchar_t const* _String1,
      wchar_t const* _String2,
                            size_t         _MaxCount,
                        _locale_t      _Locale
    );

  errno_t __cdecl _wcsnset_s(
      wchar_t* _Destination,
                                 size_t   _SizeInWords,
                                 wchar_t  _Value,
                                 size_t   _MaxCount
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl _wcsnset_s(  wchar_t (&_Destination)[_Size],   wchar_t _Value,   size_t _MaxCount) throw() { return _wcsnset_s(_Destination, _Size, _Value, _MaxCount); } }
#line 341 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wcsnset_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  wchar_t* __cdecl _wcsnset(  wchar_t *_String,   wchar_t _Value,   size_t _MaxCount);
#line 349 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"

 wchar_t* __cdecl _wcsrev(
      wchar_t* _String
    );

  errno_t __cdecl _wcsset_s(
      wchar_t* _Destination,
                                 size_t   _SizeInWords,
                                 wchar_t  _Value
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl _wcsset_s(  wchar_t (&_String)[_Size],   wchar_t _Value) throw() { return _wcsset_s(_String, _Size, _Value); } }
#line 365 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wcsset_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  wchar_t* __cdecl _wcsset(  wchar_t *_String,   wchar_t _Value);
#line 372 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"

  errno_t __cdecl _wcslwr_s(
      wchar_t* _String,
                                 size_t   _SizeInWords
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl _wcslwr_s(  wchar_t (&_String)[_Size]) throw() { return _wcslwr_s(_String, _Size); } }
#line 382 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wcslwr_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  wchar_t* __cdecl _wcslwr( wchar_t *_String);
#line 387 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"


 errno_t __cdecl _wcslwr_s_l(
      wchar_t*  _String,
                                 size_t    _SizeInWords,
                             _locale_t _Locale
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl _wcslwr_s_l(  wchar_t (&_String)[_Size],   _locale_t _Locale) throw() { return _wcslwr_s_l(_String, _Size, _Locale); } }
#line 400 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wcslwr_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  wchar_t* __cdecl _wcslwr_l(  wchar_t *_String,   _locale_t _Locale);
#line 407 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"


 errno_t __cdecl _wcsupr_s(
      wchar_t* _String,
                          size_t   _Size
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl _wcsupr_s(  wchar_t (&_String)[_Size]) throw() { return _wcsupr_s(_String, _Size); } }
#line 418 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wcsupr_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  wchar_t* __cdecl _wcsupr( wchar_t *_String);
#line 423 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"


 errno_t __cdecl _wcsupr_s_l(
      wchar_t*  _String,
                          size_t    _Size,
                      _locale_t _Locale
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl _wcsupr_s_l(  wchar_t (&_String)[_Size],   _locale_t _Locale) throw() { return _wcsupr_s_l(_String, _Size, _Locale); } }
#line 436 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wcsupr_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  wchar_t* __cdecl _wcsupr_l(  wchar_t *_String,   _locale_t _Locale);
#line 443 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"

 
 size_t __cdecl wcsxfrm(
        wchar_t*       _Destination,
                                         wchar_t const* _Source,
                size_t         _MaxCount
    );

 
 size_t __cdecl _wcsxfrm_l(
        wchar_t*       _Destination,
                                         wchar_t const* _Source,
                size_t         _MaxCount,
                                       _locale_t      _Locale
    );

 
 int __cdecl wcscoll(
      wchar_t const* _String1,
      wchar_t const* _String2
    );

 
 int __cdecl _wcscoll_l(
        wchar_t const* _String1,
        wchar_t const* _String2,
      _locale_t      _Locale
    );

 
 int __cdecl _wcsicoll(
      wchar_t const* _String1,
      wchar_t const* _String2
    );

 
 int __cdecl _wcsicoll_l(
        wchar_t const* _String1,
        wchar_t const* _String2,
      _locale_t      _Locale
    );

 
 int __cdecl _wcsncoll(
      wchar_t const* _String1,
      wchar_t const* _String2,
                            size_t         _MaxCount
    );

 
 int __cdecl _wcsncoll_l(
      wchar_t const* _String1,
      wchar_t const* _String2,
                            size_t         _MaxCount,
                        _locale_t      _Locale
    );

 
 int __cdecl _wcsnicoll(
      wchar_t const* _String1,
      wchar_t const* _String2,
                            size_t         _MaxCount
    );

 
 int __cdecl _wcsnicoll_l(
      wchar_t const* _String1,
      wchar_t const* _String2,
                            size_t         _MaxCount,
                        _locale_t      _Locale
    );


extern "C++" {

     
    inline wchar_t* __cdecl wcschr(  wchar_t* _String, wchar_t _C)
    {
        return const_cast<wchar_t*>(wcschr(static_cast<wchar_t const*>(_String), _C));
    }

     
    inline wchar_t* __cdecl wcspbrk(  wchar_t* _String,   wchar_t const* _Control)
    {
        return const_cast<wchar_t*>(wcspbrk(static_cast<wchar_t const*>(_String), _Control));
    }

     
    inline wchar_t* __cdecl wcsrchr(  wchar_t* _String,   wchar_t _C)
    {
        return const_cast<wchar_t*>(wcsrchr(static_cast<wchar_t const*>(_String), _C));
    }

       
    inline wchar_t* __cdecl wcsstr(  wchar_t* _String,   wchar_t const*_SubStr)
    {
        return const_cast<wchar_t*>(wcsstr(static_cast<wchar_t const*>(_String), _SubStr));
    }

}
#line 555 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"


#line 568 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"

      __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_wcsdup" ". See online help for details."))
     wchar_t* __cdecl wcsdup(
          wchar_t const* _String
        );

    
#line 577 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"

    
      __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_wcsicmp" ". See online help for details."))
     int __cdecl wcsicmp(
          wchar_t const* _String1,
          wchar_t const* _String2
        );

      __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_wcsnicmp" ". See online help for details."))
     int __cdecl wcsnicmp(
          wchar_t const* _String1,
          wchar_t const* _String2,
                                size_t         _MaxCount
        );

    __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_wcsnset" ". See online help for details."))
     
     wchar_t* __cdecl wcsnset(
          wchar_t* _String,
                                  wchar_t  _Value,
                                  size_t   _MaxCount
        );

    __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_wcsrev" ". See online help for details."))
     
     wchar_t* __cdecl wcsrev(
          wchar_t* _String
        );

    __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_wcsset" ". See online help for details."))
     
     wchar_t* __cdecl wcsset(
          wchar_t* _String,
               wchar_t  _Value
        );

    __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_wcslwr" ". See online help for details."))
     
     wchar_t* __cdecl wcslwr(
          wchar_t* _String
        );

    __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_wcsupr" ". See online help for details."))
     
     wchar_t* __cdecl wcsupr(
          wchar_t* _String
        );

      __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_wcsicoll" ". See online help for details."))
     int __cdecl wcsicoll(
          wchar_t const* _String1,
          wchar_t const* _String2
        );

#line 634 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"


} __pragma(pack(pop))

#line 640 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wstring.h"

#pragma warning(pop) 
#line 24 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\wchar.h"
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wtime.h"


#pragma once


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


struct tm
{
    int tm_sec;   
    int tm_min;   
    int tm_hour;  
    int tm_mday;  
    int tm_mon;   
    int tm_year;  
    int tm_wday;  
    int tm_yday;  
    int tm_isdst; 
};


  __declspec(deprecated("This function or variable may be unsafe. Consider using " "_wasctime_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
 
 
 wchar_t* __cdecl _wasctime(
      struct tm const* _Tm
    );

 
 errno_t __cdecl _wasctime_s(
        wchar_t*         _Buffer,
                                          size_t           _SizeInWords,
                                                       struct tm const* _Tm
    );

extern "C++" { template <size_t _Size> inline   errno_t __cdecl _wasctime_s(  wchar_t (&_Buffer)[_Size],   struct tm const* _Time) throw() { return _wasctime_s(_Buffer, _Size, _Time); } }
#line 66 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wtime.h"

 
 size_t __cdecl wcsftime(
       wchar_t*         _Buffer,
                               size_t           _SizeInWords,
                             wchar_t const*   _Format,
                               struct tm const* _Tm
    );

 
 size_t __cdecl _wcsftime_l(
       wchar_t*         _Buffer,
                               size_t           _SizeInWords,
                             wchar_t const*   _Format,
                               struct tm const* _Tm,
                           _locale_t        _Locale
    );

 
  __declspec(deprecated("This function or variable may be unsafe. Consider using " "_wctime32_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
 wchar_t* __cdecl _wctime32(
      __time32_t const* _Time
    );


 errno_t __cdecl _wctime32_s(
        wchar_t*          _Buffer,
                                      size_t            _SizeInWords,
                                                       __time32_t const* _Time
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl _wctime32_s(  wchar_t (&_Buffer)[_Size],   __time32_t const* _Time) throw() { return _wctime32_s(_Buffer, _Size, _Time); } }
#line 104 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wtime.h"

 
  __declspec(deprecated("This function or variable may be unsafe. Consider using " "_wctime64_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
 wchar_t* __cdecl _wctime64(
      __time64_t const* _Time
    );


 errno_t __cdecl _wctime64_s(
        wchar_t*          _Buffer,
                                      size_t            _SizeInWords,
                                                       __time64_t const* _Time);

extern "C++" { template <size_t _Size> inline errno_t __cdecl _wctime64_s(  wchar_t (&_Buffer)[_Size],   __time64_t const* _Time) throw() { return _wctime64_s(_Buffer, _Size, _Time); } }
#line 123 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wtime.h"


 errno_t __cdecl _wstrdate_s(
       wchar_t* _Buffer,
                                                                                size_t   _SizeInWords
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl _wstrdate_s(  wchar_t (&_Buffer)[_Size]) throw() { return _wstrdate_s(_Buffer, _Size); } }
#line 134 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wtime.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wstrdate_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))   wchar_t* __cdecl _wstrdate( wchar_t *_Buffer);
#line 139 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wtime.h"


 errno_t __cdecl _wstrtime_s(
       wchar_t* _Buffer,
                                                                                size_t   _SizeInWords
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl _wstrtime_s(  wchar_t (&_Buffer)[_Size]) throw() { return _wstrtime_s(_Buffer, _Size); } }
#line 150 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wtime.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "_wstrtime_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))   wchar_t* __cdecl _wstrtime( wchar_t *_Buffer);
#line 155 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wtime.h"


        static __inline wchar_t * __cdecl _wctime(
              time_t const* const _Time)
        {
            return _wctime64(_Time);
        }

        
        static __inline errno_t __cdecl _wctime_s(
                  wchar_t*      const _Buffer,
                                                             size_t        const _SizeInWords,
                                                             time_t const* const _Time
            )
        {
            return _wctime64_s(_Buffer, _SizeInWords, _Time);
        }

    #line 203 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wtime.h"
#line 204 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_wtime.h"

} __pragma(pack(pop))

#pragma warning(pop) 
#line 25 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\wchar.h"
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\sys/stat.h"


#pragma once


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\sys/types.h"


#pragma once


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


    typedef unsigned short _ino_t; 

    
        typedef _ino_t ino_t;
    #line 24 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\sys/types.h"
#line 25 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\sys/types.h"


    typedef unsigned int _dev_t; 

    
        typedef _dev_t dev_t;
    #line 36 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\sys/types.h"
#line 37 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\sys/types.h"


    typedef long _off_t; 

    
        typedef _off_t off_t;
    #line 48 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\sys/types.h"
#line 49 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\sys/types.h"


#pragma warning(pop) 
#line 12 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\sys/stat.h"

#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


struct _stat32
{
    _dev_t         st_dev;
    _ino_t         st_ino;
    unsigned short st_mode;
    short          st_nlink;
    short          st_uid;
    short          st_gid;
    _dev_t         st_rdev;
    _off_t         st_size;
    __time32_t     st_atime;
    __time32_t     st_mtime;
    __time32_t     st_ctime;
};

struct _stat32i64
{
    _dev_t         st_dev;
    _ino_t         st_ino;
    unsigned short st_mode;
    short          st_nlink;
    short          st_uid;
    short          st_gid;
    _dev_t         st_rdev;
    __int64        st_size;
    __time32_t     st_atime;
    __time32_t     st_mtime;
    __time32_t     st_ctime;
};

struct _stat64i32
{
    _dev_t         st_dev;
    _ino_t         st_ino;
    unsigned short st_mode;
    short          st_nlink;
    short          st_uid;
    short          st_gid;
    _dev_t         st_rdev;
    _off_t         st_size;
    __time64_t     st_atime;
    __time64_t     st_mtime;
    __time64_t     st_ctime;
};

struct _stat64
{
    _dev_t         st_dev;
    _ino_t         st_ino;
    unsigned short st_mode;
    short          st_nlink;
    short          st_uid;
    short          st_gid;
    _dev_t         st_rdev;
    __int64        st_size;
    __time64_t     st_atime;
    __time64_t     st_mtime;
    __time64_t     st_ctime;
};


    struct stat
    {
        _dev_t         st_dev;
        _ino_t         st_ino;
        unsigned short st_mode;
        short          st_nlink;
        short          st_uid;
        short          st_gid;
        _dev_t         st_rdev;
        _off_t         st_size;
        time_t         st_atime;
        time_t         st_mtime;
        time_t         st_ctime;
    };
#line 102 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\sys/stat.h"


#line 128 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\sys/stat.h"


#line 151 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\sys/stat.h"


 int __cdecl _fstat32(
       int             _FileHandle,
      struct _stat32* _Stat
    );

 int __cdecl _fstat32i64(
       int                _FileHandle,
      struct _stat32i64* _Stat
    );

 int __cdecl _fstat64i32(
       int                _FileHandle,
      struct _stat64i32* _Stat
    );

 int __cdecl _fstat64(
       int             _FileHandle,
      struct _stat64* _Stat
    );

 int __cdecl _stat32(
      char const*     _FileName,
       struct _stat32* _Stat
    );

 int __cdecl _stat32i64(
      char const*        _FileName,
       struct _stat32i64* _Stat
    );

 int __cdecl _stat64i32(
      char const*        _FileName,
       struct _stat64i32* _Stat
    );

 int __cdecl _stat64(
      char const*     _FileName,
       struct _stat64* _Stat
    );

 int __cdecl _wstat32(
      wchar_t const*  _FileName,
       struct _stat32* _Stat
    );

 int __cdecl _wstat32i64(
      wchar_t const*     _FileName,
       struct _stat32i64* _Stat
    );

 int __cdecl _wstat64i32(
      wchar_t const*     _FileName,
       struct _stat64i32* _Stat
    );

 int __cdecl _wstat64(
      wchar_t const*  _FileName,
       struct _stat64* _Stat
    );


        static __inline int __cdecl fstat(int const _FileHandle, struct stat* const _Stat)
        {
            static_assert((sizeof(struct stat) == sizeof(struct _stat64i32)), "sizeof(struct stat) == sizeof(struct _stat64i32)");
            return _fstat64i32(_FileHandle, (struct _stat64i32*)_Stat);
        }
        static __inline int __cdecl stat(char const* const _FileName, struct stat* const _Stat)
        {
            static_assert((sizeof(struct stat) == sizeof(struct _stat64i32)), "sizeof(struct stat) == sizeof(struct _stat64i32)");
            return _stat64i32(_FileName, (struct _stat64i32*)_Stat);
        }

    #line 245 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\sys/stat.h"
#line 246 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\sys/stat.h"

} __pragma(pack(pop))

#pragma warning(pop) 
#line 26 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\wchar.h"


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


typedef wchar_t _Wint_t;


     wchar_t* __cdecl _wsetlocale(
                int            _Category,
          wchar_t const* _Locale
        );

    
     _locale_t __cdecl _wcreate_locale(
            int            _Category,
          wchar_t const* _Locale
        );


     wint_t __cdecl btowc(
          int _Ch
        );

     size_t __cdecl mbrlen(
            char const* _Ch,
                                                    size_t      _SizeInBytes,
                                                 mbstate_t*  _State
        );

     size_t __cdecl mbrtowc(
                                  wchar_t*    _DstCh,
            char const* _SrcCh,
                                                    size_t      _SizeInBytes,
                                                 mbstate_t*  _State
        );

     
     errno_t __cdecl mbsrtowcs_s(
                                  size_t*      _Retval,
                  wchar_t*     _Dst,
                                       size_t       _Size,
                          char const** _PSrc,
                                       size_t       _N,
                                    mbstate_t*   _State
        );

    extern "C++" { template <size_t _Size> inline   errno_t __cdecl mbsrtowcs_s(  size_t* _Retval,   wchar_t (&_Dest)[_Size],     char const** _PSource,   size_t _Count,   mbstate_t* _State) throw() { return mbsrtowcs_s(_Retval, _Dest, _Size, _PSource, _Count, _State); } }
#line 98 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\wchar.h"

    __declspec(deprecated("This function or variable may be unsafe. Consider using " "mbsrtowcs_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))   size_t __cdecl mbsrtowcs( wchar_t *_Dest,  char const** _PSrc,  size_t _Count,  mbstate_t* _State);
#line 106 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\wchar.h"

     
     errno_t __cdecl wcrtomb_s(
                                 size_t*    _Retval,
          char*      _Dst,
                                      size_t     _SizeInBytes,
                                      wchar_t    _Ch,
                               mbstate_t* _State
        );

    extern "C++" { template <size_t _Size> inline   errno_t __cdecl wcrtomb_s(  size_t* _Retval,   char (&_Dest)[_Size],   wchar_t _Source,   mbstate_t* _State) throw() { return wcrtomb_s(_Retval, _Dest, _Size, _Source, _State); } }
#line 124 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\wchar.h"

    __declspec(deprecated("This function or variable may be unsafe. Consider using " "wcrtomb_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  size_t __cdecl wcrtomb(  char *_Dest,  wchar_t _Source,  mbstate_t* _State);
#line 131 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\wchar.h"

     
     errno_t __cdecl wcsrtombs_s(
                                                  size_t*         _Retval,
          char*           _Dst,
                                                       size_t          _SizeInBytes,
                                    wchar_t const** _Src,
                                                       size_t          _Size,
                                                mbstate_t*      _State
        );

    extern "C++" { template <size_t _Size> inline   errno_t __cdecl wcsrtombs_s(  size_t* _Retval,   char (&_Dest)[_Size],     wchar_t const** _PSrc,   size_t _Count,   mbstate_t* _State) throw() { return wcsrtombs_s(_Retval, _Dest, _Size, _PSrc, _Count, _State); } }
#line 151 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\wchar.h"

    __declspec(deprecated("This function or variable may be unsafe. Consider using " "wcsrtombs_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  size_t __cdecl wcsrtombs(  char *_Dest,  wchar_t const** _PSource,  size_t _Count,  mbstate_t* _State);
#line 159 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\wchar.h"

     int __cdecl wctob(
          wint_t _WCh
        );

    
        errno_t __cdecl wmemcpy_s(
              wchar_t*       _S1,
                                      rsize_t        _N1,
                        wchar_t const* _S2,
                                      rsize_t        _N
            );

         
        errno_t __cdecl wmemmove_s(
              wchar_t*       _S1,
                                      rsize_t        _N1,
                        wchar_t const* _S2,
                                      rsize_t        _N
            );

    #line 183 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\wchar.h"

    __inline int __cdecl fwide(
          FILE* _F,
              int   _M
        )
    {
        (void)_F;
        return (_M);
    }

    __inline int __cdecl mbsinit(
          mbstate_t const* _P
        )
    {
        return _P == 0 || _P->_Wchar == 0;
    }

    __inline wchar_t const* __cdecl wmemchr(
          wchar_t const* _S,
                    wchar_t        _C,
                    size_t         _N
        )
    {
        for (; 0 < _N; ++_S, --_N)
            if (*_S == _C)
                return (wchar_t const*)_S;

        return 0;
    }

    __inline int __cdecl wmemcmp(
          wchar_t const* _S1,
          wchar_t const* _S2,
                    size_t         _N
        )
    {
        for (; 0 < _N; ++_S1, ++_S2, --_N)
            if (*_S1 != *_S2)
                return *_S1 < *_S2 ? -1 : 1;

        return 0;
    }

     
    __inline 
    wchar_t* __cdecl wmemcpy(
          wchar_t*       _S1,
                wchar_t const* _S2,
                          size_t         _N
        )
    {
        #pragma warning(suppress: 6386) 
        return (wchar_t*)memcpy(_S1, _S2, _N*sizeof(wchar_t));
    }

    __inline 
    wchar_t* __cdecl wmemmove(
          wchar_t*       _S1,
                wchar_t const* _S2,
                              size_t         _N
        )
    {
        #pragma warning(suppress: 6386) 
        return (wchar_t*)memmove(_S1, _S2, _N*sizeof(wchar_t));
    }

     
    __inline wchar_t* __cdecl wmemset(
          wchar_t* _S,
                          wchar_t  _C,
                          size_t   _N
        )
    {
        wchar_t *_Su = _S;
        for (; 0 < _N; ++_Su, --_N)
        {
            *_Su = _C;
        }
        return _S;
    }

    
        extern "C++" inline wchar_t* __cdecl wmemchr(
              wchar_t* _S,
                        wchar_t  _C,
                        size_t   _N
            )
        {
            wchar_t const* const _SC = _S;
            return const_cast<wchar_t*>(wmemchr(_SC, _C, _N));
        }

    #line 279 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\wchar.h"

#line 281 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\wchar.h"


} __pragma(pack(pop))

#pragma warning(pop) 
#line 287 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\wchar.h"
#line 14 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cwchar"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


using _Mbstatet = mbstate_t;

namespace std {
#pragma warning(push)
#pragma warning(disable : 4995) 

using :: _Mbstatet;

using :: mbstate_t;
using :: size_t;
using :: tm;
using :: wint_t;

using :: btowc;
using :: fgetwc;
using :: fgetws;
using :: fputwc;
using :: fputws;
using :: fwide;
using :: fwprintf;
using :: fwscanf;
using :: getwc;
using :: getwchar;
using :: mbrlen;
using :: mbrtowc;
using :: mbsrtowcs;
using :: mbsinit;
using :: putwc;
using :: putwchar;
using :: swprintf;
using :: swscanf;
using :: ungetwc;
using :: vfwprintf;
using :: vswprintf;
using :: vwprintf;
using :: wcrtomb;
using :: wprintf;
using :: wscanf;
using :: wcsrtombs;
using :: wcstol;
using :: wcscat;
using :: wcschr;
using :: wcscmp;
using :: wcscoll;
using :: wcscpy;
using :: wcscspn;
using :: wcslen;
using :: wcsncat;
using :: wcsncmp;
using :: wcsncpy;
using :: wcspbrk;
using :: wcsrchr;
using :: wcsspn;
using :: wcstod;
using :: wcstoul;
using :: wcsstr;
using :: wcstok;
using :: wcsxfrm;
using :: wctob;
using :: wmemchr;
using :: wmemcmp;
using :: wmemcpy;
using :: wmemmove;
using :: wmemset;
using :: wcsftime;

using :: vfwscanf;
using :: vswscanf;
using :: vwscanf;
using :: wcstof;
using :: wcstold;
using :: wcstoll;
using :: wcstoull;

#pragma warning(pop)
}


#pragma warning(pop)
#pragma pack(pop)

#line 105 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cwchar"
#line 106 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cwchar"
#line 14 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"


#line 23 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"

#line 25 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"


#line 29 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
enum float_denorm_style { 
    denorm_indeterminate = -1,
    denorm_absent        = 0,
    denorm_present       = 1
};

enum float_round_style { 
    round_indeterminate       = -1,
    round_toward_zero         = 0,
    round_to_nearest          = 1,
    round_toward_infinity     = 2,
    round_toward_neg_infinity = 3
};

struct _Num_base { 
    static constexpr float_denorm_style has_denorm = denorm_absent;
    static constexpr bool has_denorm_loss          = false;
    static constexpr bool has_infinity             = false;
    static constexpr bool has_quiet_NaN            = false;
    static constexpr bool has_signaling_NaN        = false;
    static constexpr bool is_bounded               = false;
    static constexpr bool is_exact                 = false;
    static constexpr bool is_iec559                = false;
    static constexpr bool is_integer               = false;
    static constexpr bool is_modulo                = false;
    static constexpr bool is_signed                = false;
    static constexpr bool is_specialized           = false;
    static constexpr bool tinyness_before          = false;
    static constexpr bool traps                    = false;
    static constexpr float_round_style round_style = round_toward_zero;
    static constexpr int digits                    = 0;
    static constexpr int digits10                  = 0;
    static constexpr int max_digits10              = 0;
    static constexpr int max_exponent              = 0;
    static constexpr int max_exponent10            = 0;
    static constexpr int min_exponent              = 0;
    static constexpr int min_exponent10            = 0;
    static constexpr int radix                     = 0;
};

template <class _Ty>
class numeric_limits : public _Num_base { 
public:
    [[nodiscard]] static constexpr _Ty(min)() noexcept {
        return _Ty();
    }

    [[nodiscard]] static constexpr _Ty(max)() noexcept {
        return _Ty();
    }

    [[nodiscard]] static constexpr _Ty lowest() noexcept {
        return _Ty();
    }

    [[nodiscard]] static constexpr _Ty epsilon() noexcept {
        return _Ty();
    }

    [[nodiscard]] static constexpr _Ty round_error() noexcept {
        return _Ty();
    }

    [[nodiscard]] static constexpr _Ty denorm_min() noexcept {
        return _Ty();
    }

    [[nodiscard]] static constexpr _Ty infinity() noexcept {
        return _Ty();
    }

    [[nodiscard]] static constexpr _Ty quiet_NaN() noexcept {
        return _Ty();
    }

    [[nodiscard]] static constexpr _Ty signaling_NaN() noexcept {
        return _Ty();
    }
};

template <class _Ty>
class numeric_limits<const _Ty> : public numeric_limits<_Ty> {}; 

template <class _Ty>
class numeric_limits<volatile _Ty> : public numeric_limits<_Ty> {}; 

template <class _Ty>
class numeric_limits<const volatile _Ty> : public numeric_limits<_Ty> {}; 

struct _Num_int_base : _Num_base { 
    static constexpr bool is_bounded     = true;
    static constexpr bool is_exact       = true;
    static constexpr bool is_integer     = true;
    static constexpr bool is_specialized = true;
    static constexpr int radix           = 2;
};

struct _Num_float_base : _Num_base { 
    static constexpr float_denorm_style has_denorm = denorm_present;
    static constexpr bool has_infinity             = true;
    static constexpr bool has_quiet_NaN            = true;
    static constexpr bool has_signaling_NaN        = true;
    static constexpr bool is_bounded               = true;
    static constexpr bool is_iec559                = true;
    static constexpr bool is_signed                = true;
    static constexpr bool is_specialized           = true;
    static constexpr float_round_style round_style = round_to_nearest;
    static constexpr int radix                     = 2;
};

template <>
class numeric_limits<bool> : public _Num_int_base {
public:
    [[nodiscard]] static constexpr bool(min)() noexcept {
        return false;
    }

    [[nodiscard]] static constexpr bool(max)() noexcept {
        return true;
    }

    [[nodiscard]] static constexpr bool lowest() noexcept {
        return (min) ();
    }

    [[nodiscard]] static constexpr bool epsilon() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr bool round_error() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr bool denorm_min() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr bool infinity() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr bool quiet_NaN() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr bool signaling_NaN() noexcept {
        return 0;
    }

    static constexpr int digits = 1;
};

template <>
class numeric_limits<char> : public _Num_int_base {
public:
    [[nodiscard]] static constexpr char(min)() noexcept {
        return (-128);
    }

    [[nodiscard]] static constexpr char(max)() noexcept {
        return 127;
    }

    [[nodiscard]] static constexpr char lowest() noexcept {
        return (min) ();
    }

    [[nodiscard]] static constexpr char epsilon() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr char round_error() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr char denorm_min() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr char infinity() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr char quiet_NaN() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr char signaling_NaN() noexcept {
        return 0;
    }

    static constexpr bool is_signed = (-128) != 0;
    static constexpr bool is_modulo = (-128) == 0;
    static constexpr int digits     = 8 - ((-128) != 0);
    static constexpr int digits10   = 2;
};

template <>
class numeric_limits<signed char> : public _Num_int_base {
public:
    [[nodiscard]] static constexpr signed char(min)() noexcept {
        return (-128);
    }

    [[nodiscard]] static constexpr signed char(max)() noexcept {
        return 127;
    }

    [[nodiscard]] static constexpr signed char lowest() noexcept {
        return (min) ();
    }

    [[nodiscard]] static constexpr signed char epsilon() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr signed char round_error() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr signed char denorm_min() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr signed char infinity() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr signed char quiet_NaN() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr signed char signaling_NaN() noexcept {
        return 0;
    }

    static constexpr bool is_signed = true;
    static constexpr int digits     = 7;
    static constexpr int digits10   = 2;
};

template <>
class numeric_limits<unsigned char> : public _Num_int_base {
public:
    [[nodiscard]] static constexpr unsigned char(min)() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr unsigned char(max)() noexcept {
        return 0xff;
    }

    [[nodiscard]] static constexpr unsigned char lowest() noexcept {
        return (min) ();
    }

    [[nodiscard]] static constexpr unsigned char epsilon() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr unsigned char round_error() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr unsigned char denorm_min() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr unsigned char infinity() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr unsigned char quiet_NaN() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr unsigned char signaling_NaN() noexcept {
        return 0;
    }

    static constexpr bool is_modulo = true;
    static constexpr int digits     = 8;
    static constexpr int digits10   = 2;
};


template <>
class numeric_limits<char8_t> : public _Num_int_base {
public:
    [[nodiscard]] static constexpr char8_t(min)() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr char8_t(max)() noexcept {
        return 0xff;
    }

    [[nodiscard]] static constexpr char8_t lowest() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr char8_t epsilon() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr char8_t round_error() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr char8_t denorm_min() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr char8_t infinity() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr char8_t quiet_NaN() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr char8_t signaling_NaN() noexcept {
        return 0;
    }

    static constexpr bool is_modulo = true;
    static constexpr int digits     = 8;
    static constexpr int digits10   = 2;
};
#line 368 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"

template <>
class numeric_limits<char16_t> : public _Num_int_base {
public:
    [[nodiscard]] static constexpr char16_t(min)() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr char16_t(max)() noexcept {
        return 0xffff;
    }

    [[nodiscard]] static constexpr char16_t lowest() noexcept {
        return (min) ();
    }

    [[nodiscard]] static constexpr char16_t epsilon() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr char16_t round_error() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr char16_t denorm_min() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr char16_t infinity() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr char16_t quiet_NaN() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr char16_t signaling_NaN() noexcept {
        return 0;
    }

    static constexpr bool is_modulo = true;
    static constexpr int digits     = 16;
    static constexpr int digits10   = 4;
};

template <>
class numeric_limits<char32_t> : public _Num_int_base {
public:
    [[nodiscard]] static constexpr char32_t(min)() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr char32_t(max)() noexcept {
        return 0xffffffff;
    }

    [[nodiscard]] static constexpr char32_t lowest() noexcept {
        return (min) ();
    }

    [[nodiscard]] static constexpr char32_t epsilon() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr char32_t round_error() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr char32_t denorm_min() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr char32_t infinity() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr char32_t quiet_NaN() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr char32_t signaling_NaN() noexcept {
        return 0;
    }

    static constexpr bool is_modulo = true;
    static constexpr int digits     = 32;
    static constexpr int digits10   = 9;
};

template <>
class numeric_limits<wchar_t> : public _Num_int_base {
public:
    [[nodiscard]] static constexpr wchar_t(min)() noexcept {
        return 0x0000;
    }

    [[nodiscard]] static constexpr wchar_t(max)() noexcept {
        return 0xffff;
    }

    [[nodiscard]] static constexpr wchar_t lowest() noexcept {
        return (min) ();
    }

    [[nodiscard]] static constexpr wchar_t epsilon() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr wchar_t round_error() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr wchar_t denorm_min() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr wchar_t infinity() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr wchar_t quiet_NaN() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr wchar_t signaling_NaN() noexcept {
        return 0;
    }

    static constexpr bool is_modulo = true;
    static constexpr int digits     = 16;
    static constexpr int digits10   = 4;
};

template <>
class numeric_limits<short> : public _Num_int_base {
public:
    [[nodiscard]] static constexpr short(min)() noexcept {
        return (-32768);
    }

    [[nodiscard]] static constexpr short(max)() noexcept {
        return 32767;
    }

    [[nodiscard]] static constexpr short lowest() noexcept {
        return (min) ();
    }

    [[nodiscard]] static constexpr short epsilon() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr short round_error() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr short denorm_min() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr short infinity() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr short quiet_NaN() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr short signaling_NaN() noexcept {
        return 0;
    }

    static constexpr bool is_signed = true;
    static constexpr int digits     = 15;
    static constexpr int digits10   = 4;
};

template <>
class numeric_limits<int> : public _Num_int_base {
public:
    [[nodiscard]] static constexpr int(min)() noexcept {
        return (-2147483647 - 1);
    }

    [[nodiscard]] static constexpr int(max)() noexcept {
        return 2147483647;
    }

    [[nodiscard]] static constexpr int lowest() noexcept {
        return (min) ();
    }

    [[nodiscard]] static constexpr int epsilon() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr int round_error() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr int denorm_min() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr int infinity() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr int quiet_NaN() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr int signaling_NaN() noexcept {
        return 0;
    }

    static constexpr bool is_signed = true;
    static constexpr int digits     = 31;
    static constexpr int digits10   = 9;
};

template <>
class numeric_limits<long> : public _Num_int_base {
public:
    [[nodiscard]] static constexpr long(min)() noexcept {
        return (-2147483647L - 1);
    }

    [[nodiscard]] static constexpr long(max)() noexcept {
        return 2147483647L;
    }

    [[nodiscard]] static constexpr long lowest() noexcept {
        return (min) ();
    }

    [[nodiscard]] static constexpr long epsilon() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr long round_error() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr long denorm_min() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr long infinity() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr long quiet_NaN() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr long signaling_NaN() noexcept {
        return 0;
    }

    static_assert(sizeof(int) == sizeof(long), "LLP64 assumption");
    static constexpr bool is_signed = true;
    static constexpr int digits     = 31;
    static constexpr int digits10   = 9;
};

template <>
class numeric_limits<long long> : public _Num_int_base {
public:
    [[nodiscard]] static constexpr long long(min)() noexcept {
        return (-9223372036854775807i64 - 1);
    }

    [[nodiscard]] static constexpr long long(max)() noexcept {
        return 9223372036854775807i64;
    }

    [[nodiscard]] static constexpr long long lowest() noexcept {
        return (min) ();
    }

    [[nodiscard]] static constexpr long long epsilon() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr long long round_error() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr long long denorm_min() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr long long infinity() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr long long quiet_NaN() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr long long signaling_NaN() noexcept {
        return 0;
    }

    static constexpr bool is_signed = true;
    static constexpr int digits     = 63;
    static constexpr int digits10   = 18;
};


template <>
class numeric_limits<unsigned short> : public _Num_int_base {
public:
    [[nodiscard]] static constexpr unsigned short(min)() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr unsigned short(max)() noexcept {
        return 0xffff;
    }

    [[nodiscard]] static constexpr unsigned short lowest() noexcept {
        return (min) ();
    }

    [[nodiscard]] static constexpr unsigned short epsilon() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr unsigned short round_error() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr unsigned short denorm_min() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr unsigned short infinity() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr unsigned short quiet_NaN() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr unsigned short signaling_NaN() noexcept {
        return 0;
    }

    static constexpr bool is_modulo = true;
    static constexpr int digits     = 16;
    static constexpr int digits10   = 4;
};
#line 723 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"

template <>
class numeric_limits<unsigned int> : public _Num_int_base {
public:
    [[nodiscard]] static constexpr unsigned int(min)() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr unsigned int(max)() noexcept {
        return 0xffffffff;
    }

    [[nodiscard]] static constexpr unsigned int lowest() noexcept {
        return (min) ();
    }

    [[nodiscard]] static constexpr unsigned int epsilon() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr unsigned int round_error() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr unsigned int denorm_min() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr unsigned int infinity() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr unsigned int quiet_NaN() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr unsigned int signaling_NaN() noexcept {
        return 0;
    }

    static constexpr bool is_modulo = true;
    static constexpr int digits     = 32;
    static constexpr int digits10   = 9;
};

template <>
class numeric_limits<unsigned long> : public _Num_int_base {
public:
    [[nodiscard]] static constexpr unsigned long(min)() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr unsigned long(max)() noexcept {
        return 0xffffffffUL;
    }

    [[nodiscard]] static constexpr unsigned long lowest() noexcept {
        return (min) ();
    }

    [[nodiscard]] static constexpr unsigned long epsilon() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr unsigned long round_error() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr unsigned long denorm_min() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr unsigned long infinity() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr unsigned long quiet_NaN() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr unsigned long signaling_NaN() noexcept {
        return 0;
    }

    static_assert(sizeof(unsigned int) == sizeof(unsigned long), "LLP64 assumption");
    static constexpr bool is_modulo = true;
    static constexpr int digits     = 32;
    static constexpr int digits10   = 9;
};

template <>
class numeric_limits<unsigned long long> : public _Num_int_base {
public:
    [[nodiscard]] static constexpr unsigned long long(min)() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr unsigned long long(max)() noexcept {
        return 0xffffffffffffffffui64;
    }

    [[nodiscard]] static constexpr unsigned long long lowest() noexcept {
        return (min) ();
    }

    [[nodiscard]] static constexpr unsigned long long epsilon() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr unsigned long long round_error() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr unsigned long long denorm_min() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr unsigned long long infinity() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr unsigned long long quiet_NaN() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr unsigned long long signaling_NaN() noexcept {
        return 0;
    }

    static constexpr bool is_modulo = true;
    static constexpr int digits     = 64;
    static constexpr int digits10   = 19;
};

template <>
class numeric_limits<float> : public _Num_float_base {
public:
    [[nodiscard]] static constexpr float(min)() noexcept {
        return 1.175494351e-38F;
    }

    [[nodiscard]] static constexpr float(max)() noexcept {
        return 3.402823466e+38F;
    }

    [[nodiscard]] static constexpr float lowest() noexcept {
        return -(max) ();
    }

    [[nodiscard]] static constexpr float epsilon() noexcept {
        return 1.192092896e-07F;
    }

    [[nodiscard]] static constexpr float round_error() noexcept {
        return 0.5F;
    }

    [[nodiscard]] static constexpr float denorm_min() noexcept {
        return 1.401298464e-45F;
    }

    [[nodiscard]] static constexpr float infinity() noexcept {
        return __builtin_huge_valf();
    }

    [[nodiscard]] static constexpr float quiet_NaN() noexcept {
        return __builtin_nanf("0");
    }

    [[nodiscard]] static constexpr float signaling_NaN() noexcept {
        return __builtin_nansf("1");
    }

    static constexpr int digits         = 24;
    static constexpr int digits10       = 6;
    static constexpr int max_digits10   = 9;
    static constexpr int max_exponent   = 128;
    static constexpr int max_exponent10 = 38;
    static constexpr int min_exponent   = (-125);
    static constexpr int min_exponent10 = (-37);
};

template <>
class numeric_limits<double> : public _Num_float_base {
public:
    [[nodiscard]] static constexpr double(min)() noexcept {
        return 2.2250738585072014e-308;
    }

    [[nodiscard]] static constexpr double(max)() noexcept {
        return 1.7976931348623158e+308;
    }

    [[nodiscard]] static constexpr double lowest() noexcept {
        return -(max) ();
    }

    [[nodiscard]] static constexpr double epsilon() noexcept {
        return 2.2204460492503131e-016;
    }

    [[nodiscard]] static constexpr double round_error() noexcept {
        return 0.5;
    }

    [[nodiscard]] static constexpr double denorm_min() noexcept {
        return 4.9406564584124654e-324;
    }

    [[nodiscard]] static constexpr double infinity() noexcept {
        return __builtin_huge_val();
    }

    [[nodiscard]] static constexpr double quiet_NaN() noexcept {
        return __builtin_nan("0");
    }

    [[nodiscard]] static constexpr double signaling_NaN() noexcept {
        return __builtin_nans("1");
    }

    static constexpr int digits         = 53;
    static constexpr int digits10       = 15;
    static constexpr int max_digits10   = 17;
    static constexpr int max_exponent   = 1024;
    static constexpr int max_exponent10 = 308;
    static constexpr int min_exponent   = (-1021);
    static constexpr int min_exponent10 = (-307);
};

template <>
class numeric_limits<long double> : public _Num_float_base {
public:
    [[nodiscard]] static constexpr long double(min)() noexcept {
        return 2.2250738585072014e-308;
    }

    [[nodiscard]] static constexpr long double(max)() noexcept {
        return 1.7976931348623158e+308;
    }

    [[nodiscard]] static constexpr long double lowest() noexcept {
        return -(max) ();
    }

    [[nodiscard]] static constexpr long double epsilon() noexcept {
        return 2.2204460492503131e-016;
    }

    [[nodiscard]] static constexpr long double round_error() noexcept {
        return 0.5L;
    }

    [[nodiscard]] static constexpr long double denorm_min() noexcept {
        return 4.9406564584124654e-324;
    }

    [[nodiscard]] static constexpr long double infinity() noexcept {
        return __builtin_huge_val();
    }

    [[nodiscard]] static constexpr long double quiet_NaN() noexcept {
        return __builtin_nan("0");
    }

    [[nodiscard]] static constexpr long double signaling_NaN() noexcept {
        return __builtin_nans("1");
    }

    static constexpr int digits         = 53;
    static constexpr int digits10       = 15;
    static constexpr int max_digits10   = 2 + 53 * 301L / 1000;
    static constexpr int max_exponent   = 1024;
    static constexpr int max_exponent10 = 308;
    static constexpr int min_exponent   = (-1021);
    static constexpr int min_exponent10 = (-307);
};


template <class _Ty>
[[nodiscard]] constexpr int _Countl_zero_fallback(_Ty _Val) noexcept {
    _Ty _Yy = 0;

    unsigned int _Nn = numeric_limits<_Ty>::digits;
    unsigned int _Cc = numeric_limits<_Ty>::digits / 2;
    do {
        _Yy = static_cast<_Ty>(_Val >> _Cc);
        if (_Yy != 0) {
            _Nn -= _Cc;
            _Val = _Yy;
        }
        _Cc >>= 1;
    } while (_Cc != 0);
    return static_cast<int>(_Nn) - static_cast<int>(_Val);
}


template <class _Ty>
[[nodiscard]] constexpr int _Countr_zero_fallback(const _Ty _Val) noexcept {
    constexpr int _Digits = std::numeric_limits<_Ty>::digits;
    return _Digits - _Countl_zero_fallback(static_cast<_Ty>(static_cast<_Ty>(~_Val) & static_cast<_Ty>(_Val - 1)));
}


template <class _Ty>
[[nodiscard]] constexpr int _Popcount_fallback(_Ty _Val) noexcept {
    constexpr int _Digits = numeric_limits<_Ty>::digits;

    if constexpr (_Digits == 64) {
        
        
        return _Popcount_fallback(static_cast<unsigned long>(_Val))
             + _Popcount_fallback(static_cast<unsigned long>(_Val >> 32));
    }
#line 1043 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"
    
    _Val = static_cast<_Ty>(_Val - ((_Val >> 1) & static_cast<_Ty>(0x5555'5555'5555'5555ull)));
    _Val = static_cast<_Ty>((_Val & static_cast<_Ty>(0x3333'3333'3333'3333ull))
                            + ((_Val >> 2) & static_cast<_Ty>(0x3333'3333'3333'3333ull)));
    _Val = static_cast<_Ty>((_Val + (_Val >> 4)) & static_cast<_Ty>(0x0F0F'0F0F'0F0F'0F0Full));
    
    _Val = static_cast<_Ty>(_Val * static_cast<_Ty>(0x0101'0101'0101'0101ull));
    
    return static_cast<int>(_Val >> (_Digits - 8));
}


#line 1060 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"


extern "C" {
extern int __isa_available;
}


#line 1073 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"

template <class _Ty>
[[nodiscard]] int _Countr_zero_tzcnt(const _Ty _Val) noexcept {
    constexpr int _Digits = numeric_limits<_Ty>::digits;
    constexpr _Ty _Max    = (numeric_limits<_Ty>::max)();

    if constexpr (_Digits <= 32) {
        
        
        return static_cast<int>(_tzcnt_u32(static_cast<unsigned int>(~_Max | _Val)));
    } else {

        const auto _Low = static_cast<unsigned int>(_Val);
        if (_Low == 0) {
            const unsigned int _High = _Val >> 32;
            return static_cast<int>(32 + _tzcnt_u32(_High));
        } else {
            return static_cast<int>(_tzcnt_u32(_Low));
        }


#line 1096 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"
    }
}


template <class _Ty>
[[nodiscard]] int _Countr_zero_bsf(const _Ty _Val) noexcept {
    constexpr int _Digits = numeric_limits<_Ty>::digits;
    constexpr _Ty _Max    = (numeric_limits<_Ty>::max)();

    unsigned long _Result;
    if constexpr (_Digits <= 32) {
        
        
        if (!_BitScanForward(&_Result, static_cast<unsigned int>(~_Max | _Val))) {
            return _Digits;
        }
    } else {

        const auto _Low = static_cast<unsigned int>(_Val);
        if (_BitScanForward(&_Result, _Low)) {
            return static_cast<int>(_Result);
        }

        const unsigned int _High = _Val >> 32;
        if (!_BitScanForward(&_Result, _High)) {
            return _Digits;
        } else {
            return static_cast<int>(_Result + 32);
        }


#line 1133 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"
    }
    return static_cast<int>(_Result);
}

template <class _Ty>
[[nodiscard]] int _Checked_x86_x64_countr_zero(const _Ty _Val) noexcept {


    const bool _Definitely_have_tzcnt = __isa_available >= __ISA_AVAILABLE_AVX2;
    if (_Definitely_have_tzcnt) {
        return _Countr_zero_tzcnt(_Val);
    } else {
        return _Countr_zero_bsf(_Val);
    }
#line 1149 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"
}

#line 1152 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"


#line 1159 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"


template <class _Ty>
[[nodiscard]] int _Unchecked_x86_x64_popcount(const _Ty _Val) noexcept {
    constexpr int _Digits = numeric_limits<_Ty>::digits;
    if constexpr (_Digits <= 16) {
        return static_cast<int>(__popcnt16(_Val));
    } else if constexpr (_Digits == 32) {
        return static_cast<int>(__popcnt(_Val));
    } else {

        return static_cast<int>(__popcnt(_Val >> 32) + __popcnt(static_cast<unsigned int>(_Val)));


#line 1174 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"
    }
}

template <class _Ty>
[[nodiscard]] int _Checked_x86_x64_popcount(const _Ty _Val) noexcept {

    const bool _Definitely_have_popcnt = __isa_available >= __ISA_AVAILABLE_SSE42;
    if (!_Definitely_have_popcnt) {
        return _Popcount_fallback(_Val);
    }
#line 1185 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"
    return _Unchecked_x86_x64_popcount(_Val);
}
#line 1188 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"


#line 1195 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"

template <class _Ty>
constexpr bool _Is_standard_unsigned_integer =
    _Is_any_of_v<remove_cv_t<_Ty>, unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long>;

template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
[[nodiscard]] constexpr int _Countr_zero(const _Ty _Val) noexcept {


    if (!::std:: is_constant_evaluated())
#line 1206 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"
    {
        return _Checked_x86_x64_countr_zero(_Val);
    }
#line 1210 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"
    return _Countr_zero_fallback(_Val);
}

template <class _Ty, class _Fn>
constexpr decltype(auto) _Select_countr_zero_impl(_Fn _Callback) {
    

    if (!::std:: is_constant_evaluated()) {


        const bool _Definitely_have_tzcnt = __isa_available >= __ISA_AVAILABLE_AVX2;
        if (_Definitely_have_tzcnt) {
            return _Callback([](_Ty _Val) { return _Countr_zero_tzcnt(_Val); });
        } else {
            return _Callback([](_Ty _Val) { return _Countr_zero_bsf(_Val); });
        }
#line 1228 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"
    }
#line 1230 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"
    
    return _Callback([](_Ty _Val) { return _Countr_zero_fallback(_Val); });
}

template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> _Enabled = 0>
[[nodiscard]] constexpr int _Popcount(const _Ty _Val) noexcept {


    if (!::std:: is_constant_evaluated())
#line 1240 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"
    {

        return _Checked_x86_x64_popcount(_Val);


#line 1246 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"
    }
#line 1248 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"
    return _Popcount_fallback(_Val);
}

template <class _Ty, class _Fn>
constexpr decltype(auto) _Select_popcount_impl(_Fn _Callback) {
    

    if (!::std:: is_constant_evaluated())
#line 1258 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"
    {


        const bool _Definitely_have_popcnt = __isa_available >= __ISA_AVAILABLE_SSE42;
        if (!_Definitely_have_popcnt) {
            return _Callback([](_Ty _Val) { return _Popcount_fallback(_Val); });
        }
#line 1266 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"
        return _Callback([](_Ty _Val) { return _Unchecked_x86_x64_popcount(_Val); });


#line 1270 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"
    }
#line 1272 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"
    return _Callback([](_Ty _Val) { return _Popcount_fallback(_Val); });
}


}


#pragma warning(pop)
#pragma pack(pop)
#line 1285 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"
#line 1286 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\limits"
#line 18 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\bit"


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {

template <class _To, class _From,
    enable_if_t<conjunction_v<bool_constant<sizeof(_To) == sizeof(_From)>, is_trivially_copyable<_To>,
                    is_trivially_copyable<_From>>,
        int> = 0>
[[nodiscard]] constexpr _To bit_cast(const _From& _Val) noexcept {
    return __builtin_bit_cast(_To, _Val);
}

template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
[[nodiscard]] constexpr int countl_zero(_Ty _Val) noexcept;

template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
[[nodiscard]] constexpr bool has_single_bit(const _Ty _Val) noexcept {
    return _Val != 0 && (_Val & (_Val - 1)) == 0;
}

inline void _Precondition_violation_in_bit_ceil() noexcept {}

template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
[[nodiscard]] constexpr _Ty bit_ceil(const _Ty _Val) noexcept  {
    if (_Val <= 1u) {
        return _Ty{1};
    }

    const int _Num = numeric_limits<_Ty>::digits - ::std:: countl_zero(static_cast<_Ty>(_Val - 1));

    if constexpr (sizeof(_Ty) < sizeof(unsigned int)) { 
        if (::std:: is_constant_evaluated()) {
            
            
            if (_Num == numeric_limits<_Ty>::digits) {
                _Precondition_violation_in_bit_ceil();
            }
        }
    }

    return static_cast<_Ty>(_Ty{1} << _Num);
}

template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
[[nodiscard]] constexpr _Ty bit_floor(const _Ty _Val) noexcept {
    if (_Val == 0) {
        return 0;
    }

    return static_cast<_Ty>(_Ty{1} << (numeric_limits<_Ty>::digits - 1 - ::std:: countl_zero(_Val)));
}

template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
[[nodiscard]] constexpr _Ty bit_width(const _Ty _Val) noexcept {
    return static_cast<_Ty>(numeric_limits<_Ty>::digits - ::std:: countl_zero(_Val));
}

template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
[[nodiscard]] constexpr _Ty rotr(_Ty _Val, int _Rotation) noexcept;

template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
[[nodiscard]] constexpr _Ty rotl(const _Ty _Val, const int _Rotation) noexcept {
    constexpr auto _Digits = numeric_limits<_Ty>::digits;

    if (!::std:: is_constant_evaluated()) {
        if constexpr (_Digits == 64) {
            return _rotl64(_Val, _Rotation);
        } else if constexpr (_Digits == 32) {
            return _rotl(_Val, _Rotation);
        }
        
    }

    const auto _Remainder = _Rotation % _Digits;
    if (_Remainder > 0) {
        return static_cast<_Ty>(
            static_cast<_Ty>(_Val << _Remainder) | static_cast<_Ty>(_Val >> (_Digits - _Remainder)));
    } else if (_Remainder == 0) {
        return _Val;
    } else { 
        return ::std:: rotr(_Val, -_Remainder);
    }
}

template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> _Enabled>
[[nodiscard]] constexpr _Ty rotr(const _Ty _Val, const int _Rotation) noexcept {
    constexpr auto _Digits = numeric_limits<_Ty>::digits;

    if (!::std:: is_constant_evaluated()) {
        if constexpr (_Digits == 64) {
            return _rotr64(_Val, _Rotation);
        } else if constexpr (_Digits == 32) {
            return _rotr(_Val, _Rotation);
        }
        
    }

    const auto _Remainder = _Rotation % _Digits;
    if (_Remainder > 0) {
        return static_cast<_Ty>(
            static_cast<_Ty>(_Val >> _Remainder) | static_cast<_Ty>(_Val << (_Digits - _Remainder)));
    } else if (_Remainder == 0) {
        return _Val;
    } else { 
        return ::std:: rotl(_Val, -_Remainder);
    }
}


extern "C" {
extern int __isa_available;
}

template <class _Ty>
[[nodiscard]] int _Countl_zero_lzcnt(const _Ty _Val) noexcept {
    constexpr int _Digits = numeric_limits<_Ty>::digits;

    if constexpr (_Digits <= 16) {
        return static_cast<int>(__lzcnt16(_Val) - (16 - _Digits));
    } else if constexpr (_Digits == 32) {
        return static_cast<int>(__lzcnt(_Val));
    } else {

        const unsigned int _High = _Val >> 32;
        const auto _Low          = static_cast<unsigned int>(_Val);
        if (_High == 0) {
            return 32 + _Countl_zero_lzcnt(_Low);
        } else {
            return _Countl_zero_lzcnt(_High);
        }


#line 166 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\bit"
    }
}

template <class _Ty>
[[nodiscard]] int _Countl_zero_bsr(const _Ty _Val) noexcept {
    constexpr int _Digits = numeric_limits<_Ty>::digits;

    unsigned long _Result;
    if constexpr (_Digits <= 32) {
        if (!_BitScanReverse(&_Result, _Val)) {
            return _Digits;
        }
    } else {

        const unsigned int _High = _Val >> 32;
        if (_BitScanReverse(&_Result, _High)) {
            return static_cast<int>(31 - _Result);
        }

        const auto _Low = static_cast<unsigned int>(_Val);
        if (!_BitScanReverse(&_Result, _Low)) {
            return _Digits;
        }


#line 194 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\bit"
    }
    return static_cast<int>(_Digits - 1 - _Result);
}

template <class _Ty>
[[nodiscard]] int _Checked_x86_x64_countl_zero(const _Ty _Val) noexcept {


    const bool _Definitely_have_lzcnt = __isa_available >= __ISA_AVAILABLE_AVX2;
    if (_Definitely_have_lzcnt) {
        return _Countl_zero_lzcnt(_Val);
    } else {
        return _Countl_zero_bsr(_Val);
    }
#line 210 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\bit"
}
#line 212 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\bit"


#line 255 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\bit"


[[nodiscard]] constexpr unsigned short _Byteswap_ushort(const unsigned short _Val) noexcept {
    if (::std:: is_constant_evaluated()) {
        return static_cast<unsigned short>((_Val << 8) | (_Val >> 8));
    } else {
        return _byteswap_ushort(_Val);
    }
}

[[nodiscard]] constexpr unsigned long _Byteswap_ulong(const unsigned long _Val) noexcept {
    if (::std:: is_constant_evaluated()) {
        return (_Val << 24) | ((_Val << 8) & 0x00FF'0000) | ((_Val >> 8) & 0x0000'FF00) | (_Val >> 24);
    } else {
        return _byteswap_ulong(_Val);
    }
}

[[nodiscard]] constexpr unsigned long long _Byteswap_uint64(const unsigned long long _Val) noexcept {
    if (::std:: is_constant_evaluated()) {
        return (_Val << 56) | ((_Val << 40) & 0x00FF'0000'0000'0000) | ((_Val << 24) & 0x0000'FF00'0000'0000)
             | ((_Val << 8) & 0x0000'00FF'0000'0000) | ((_Val >> 8) & 0x0000'0000'FF00'0000)
             | ((_Val >> 24) & 0x0000'0000'00FF'0000) | ((_Val >> 40) & 0x0000'0000'0000'FF00) | (_Val >> 56);
    } else {
        return _byteswap_uint64(_Val);
    }
}
#line 283 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\bit"

template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> _Enabled>
[[nodiscard]] constexpr int countl_zero(const _Ty _Val) noexcept {

    if (!::std:: is_constant_evaluated()) {
        return _Checked_x86_x64_countl_zero(_Val);
    }


#line 295 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\bit"

    return _Countl_zero_fallback(_Val);
}

template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
[[nodiscard]] constexpr int countl_one(const _Ty _Val) noexcept {
    return ::std:: countl_zero(static_cast<_Ty>(~_Val));
}

template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
[[nodiscard]] constexpr int countr_zero(const _Ty _Val) noexcept {
    return _Countr_zero(_Val);
}

template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> _Enabled = 0>
[[nodiscard]] constexpr int countr_one(const _Ty _Val) noexcept {
    return _Countr_zero(static_cast<_Ty>(~_Val));
}

template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
[[nodiscard]] constexpr int popcount(const _Ty _Val) noexcept {
    return _Popcount(_Val);
}


template <class _Ty, enable_if_t<is_integral_v<_Ty>, int> = 0>
[[nodiscard]] constexpr _Ty byteswap(const _Ty _Val) noexcept {
    if constexpr (sizeof(_Ty) == 1) {
        return _Val;
    } else if constexpr (sizeof(_Ty) == 2) {
        return static_cast<_Ty>(_Byteswap_ushort(static_cast<unsigned short>(_Val)));
    } else if constexpr (sizeof(_Ty) == 4) {
        return static_cast<_Ty>(_Byteswap_ulong(static_cast<unsigned long>(_Val)));
    } else if constexpr (sizeof(_Ty) == 8) {
        return static_cast<_Ty>(_Byteswap_uint64(static_cast<unsigned long long>(_Val)));
    } else {
        static_assert(_Always_false<_Ty>, "Unexpected integer size");
    }
}
#line 335 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\bit"

enum class endian { little = 0, big = 1, native = little };

}


#pragma warning(pop)
#pragma pack(pop)
#line 344 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\bit"
#line 345 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\bit"
#line 346 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\bit"
#line 17 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\compare"


#line 21 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\compare"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
using _Literal_zero = decltype(nullptr);
using _Compare_t    = signed char;


enum class _Compare_eq : _Compare_t { equal = 0, equivalent = equal };
enum class _Compare_ord : _Compare_t { less = -1, greater = 1 };
enum class _Compare_ncmp : _Compare_t { unordered = -128 };

struct partial_ordering {
    static const partial_ordering less;
    static const partial_ordering equivalent;
    static const partial_ordering greater;
    static const partial_ordering unordered;

    [[nodiscard]] friend constexpr bool operator==(const partial_ordering _Val, _Literal_zero) noexcept {
        return _Val._Value == 0;
    }

    [[nodiscard]] friend constexpr bool operator==(partial_ordering, partial_ordering) noexcept = default;

    [[nodiscard]] friend constexpr bool operator<(const partial_ordering _Val, _Literal_zero) noexcept {
        return _Val._Value == static_cast<_Compare_t>(_Compare_ord::less);
    }

    [[nodiscard]] friend constexpr bool operator>(const partial_ordering _Val, _Literal_zero) noexcept {
        return _Val._Value > 0;
    }

    [[nodiscard]] friend constexpr bool operator<=(const partial_ordering _Val, _Literal_zero) noexcept {
        
        
        return static_cast<signed char>(0 - static_cast<unsigned int>(_Val._Value)) >= 0;
    }

    [[nodiscard]] friend constexpr bool operator>=(const partial_ordering _Val, _Literal_zero) noexcept {
        return _Val._Value >= 0;
    }

    [[nodiscard]] friend constexpr bool operator<(_Literal_zero, const partial_ordering _Val) noexcept {
        return _Val > 0;
    }

    [[nodiscard]] friend constexpr bool operator>(_Literal_zero, const partial_ordering _Val) noexcept {
        return _Val < 0;
    }

    [[nodiscard]] friend constexpr bool operator<=(_Literal_zero, const partial_ordering _Val) noexcept {
        return _Val >= 0;
    }

    [[nodiscard]] friend constexpr bool operator>=(_Literal_zero, const partial_ordering _Val) noexcept {
        return _Val <= 0;
    }

    [[nodiscard]] friend constexpr partial_ordering operator<=>(const partial_ordering _Val, _Literal_zero) noexcept {
        return _Val;
    }

    [[nodiscard]] friend constexpr partial_ordering operator<=>(_Literal_zero, const partial_ordering _Val) noexcept {
        
        
        return {static_cast<_Compare_t>(0 - static_cast<unsigned int>(_Val._Value))};
    }

    _Compare_t _Value;
};

inline constexpr partial_ordering partial_ordering::less{static_cast<_Compare_t>(_Compare_ord::less)};
inline constexpr partial_ordering partial_ordering::equivalent{static_cast<_Compare_t>(_Compare_eq::equivalent)};
inline constexpr partial_ordering partial_ordering::greater{static_cast<_Compare_t>(_Compare_ord::greater)};
inline constexpr partial_ordering partial_ordering::unordered{static_cast<_Compare_t>(_Compare_ncmp::unordered)};

struct weak_ordering {
    static const weak_ordering less;
    static const weak_ordering equivalent;
    static const weak_ordering greater;

    constexpr operator partial_ordering() const noexcept {
        return {static_cast<_Compare_t>(_Value)};
    }

    [[nodiscard]] friend constexpr bool operator==(const weak_ordering _Val, _Literal_zero) noexcept {
        return _Val._Value == 0;
    }

    [[nodiscard]] friend constexpr bool operator==(weak_ordering, weak_ordering) noexcept = default;

    [[nodiscard]] friend constexpr bool operator<(const weak_ordering _Val, _Literal_zero) noexcept {
        return _Val._Value < 0;
    }

    [[nodiscard]] friend constexpr bool operator>(const weak_ordering _Val, _Literal_zero) noexcept {
        return _Val._Value > 0;
    }

    [[nodiscard]] friend constexpr bool operator<=(const weak_ordering _Val, _Literal_zero) noexcept {
        return _Val._Value <= 0;
    }

    [[nodiscard]] friend constexpr bool operator>=(const weak_ordering _Val, _Literal_zero) noexcept {
        return _Val._Value >= 0;
    }

    [[nodiscard]] friend constexpr bool operator<(_Literal_zero, const weak_ordering _Val) noexcept {
        return _Val > 0;
    }

    [[nodiscard]] friend constexpr bool operator>(_Literal_zero, const weak_ordering _Val) noexcept {
        return _Val < 0;
    }

    [[nodiscard]] friend constexpr bool operator<=(_Literal_zero, const weak_ordering _Val) noexcept {
        return _Val >= 0;
    }

    [[nodiscard]] friend constexpr bool operator>=(_Literal_zero, const weak_ordering _Val) noexcept {
        return _Val <= 0;
    }

    [[nodiscard]] friend constexpr weak_ordering operator<=>(const weak_ordering _Val, _Literal_zero) noexcept {
        return _Val;
    }

    [[nodiscard]] friend constexpr weak_ordering operator<=>(_Literal_zero, const weak_ordering _Val) noexcept {
        return {static_cast<_Compare_t>(-_Val._Value)};
    }

    _Compare_t _Value;
};

inline constexpr weak_ordering weak_ordering::less{static_cast<_Compare_t>(_Compare_ord::less)};
inline constexpr weak_ordering weak_ordering::equivalent{static_cast<_Compare_t>(_Compare_eq::equivalent)};
inline constexpr weak_ordering weak_ordering::greater{static_cast<_Compare_t>(_Compare_ord::greater)};

struct strong_ordering {
    static const strong_ordering less;
    static const strong_ordering equal;
    static const strong_ordering equivalent;
    static const strong_ordering greater;

    constexpr operator partial_ordering() const noexcept {
        return {static_cast<_Compare_t>(_Value)};
    }

    constexpr operator weak_ordering() const noexcept {
        return {static_cast<_Compare_t>(_Value)};
    }

    [[nodiscard]] friend constexpr bool operator==(const strong_ordering _Val, _Literal_zero) noexcept {
        return _Val._Value == 0;
    }

    [[nodiscard]] friend constexpr bool operator==(strong_ordering, strong_ordering) noexcept = default;

    [[nodiscard]] friend constexpr bool operator<(const strong_ordering _Val, _Literal_zero) noexcept {
        return _Val._Value < 0;
    }

    [[nodiscard]] friend constexpr bool operator>(const strong_ordering _Val, _Literal_zero) noexcept {
        return _Val._Value > 0;
    }

    [[nodiscard]] friend constexpr bool operator<=(const strong_ordering _Val, _Literal_zero) noexcept {
        return _Val._Value <= 0;
    }

    [[nodiscard]] friend constexpr bool operator>=(const strong_ordering _Val, _Literal_zero) noexcept {
        return _Val._Value >= 0;
    }

    [[nodiscard]] friend constexpr bool operator<(_Literal_zero, const strong_ordering _Val) noexcept {
        return _Val > 0;
    }

    [[nodiscard]] friend constexpr bool operator>(_Literal_zero, const strong_ordering _Val) noexcept {
        return _Val < 0;
    }

    [[nodiscard]] friend constexpr bool operator<=(_Literal_zero, const strong_ordering _Val) noexcept {
        return _Val >= 0;
    }

    [[nodiscard]] friend constexpr bool operator>=(_Literal_zero, const strong_ordering _Val) noexcept {
        return _Val <= 0;
    }

    [[nodiscard]] friend constexpr strong_ordering operator<=>(const strong_ordering _Val, _Literal_zero) noexcept {
        return _Val;
    }

    [[nodiscard]] friend constexpr strong_ordering operator<=>(_Literal_zero, const strong_ordering _Val) noexcept {
        return {static_cast<_Compare_t>(-_Val._Value)};
    }

    _Compare_t _Value;
};

inline constexpr strong_ordering strong_ordering::less{static_cast<_Compare_t>(_Compare_ord::less)};
inline constexpr strong_ordering strong_ordering::equal{static_cast<_Compare_t>(_Compare_eq::equal)};
inline constexpr strong_ordering strong_ordering::equivalent{static_cast<_Compare_t>(_Compare_eq::equivalent)};
inline constexpr strong_ordering strong_ordering::greater{static_cast<_Compare_t>(_Compare_ord::greater)};

[[nodiscard]] constexpr bool is_eq(const partial_ordering _Comp) noexcept {
    return _Comp == 0;
}

[[nodiscard]] constexpr bool is_neq(const partial_ordering _Comp) noexcept {
    return _Comp != 0;
}

[[nodiscard]] constexpr bool is_lt(const partial_ordering _Comp) noexcept {
    return _Comp < 0;
}

[[nodiscard]] constexpr bool is_lteq(const partial_ordering _Comp) noexcept {
    return _Comp <= 0;
}

[[nodiscard]] constexpr bool is_gt(const partial_ordering _Comp) noexcept {
    return _Comp > 0;
}

[[nodiscard]] constexpr bool is_gteq(const partial_ordering _Comp) noexcept {
    return _Comp >= 0;
}

enum _Comparison_category : unsigned char {
    _Comparison_category_none    = 1,
    _Comparison_category_partial = 2,
    _Comparison_category_weak    = 4,
    _Comparison_category_strong  = 0,
};

template <class... _Types>
inline constexpr unsigned char _Classify_category =
    _Comparison_category{(_Classify_category<_Types> | ... | _Comparison_category_strong)};
template <class _Ty>
inline constexpr unsigned char _Classify_category<_Ty> = _Comparison_category_none;
template <>
inline constexpr unsigned char _Classify_category<partial_ordering> = _Comparison_category_partial;
template <>
inline constexpr unsigned char _Classify_category<weak_ordering> = _Comparison_category_weak;
template <>
inline constexpr unsigned char _Classify_category<strong_ordering> = _Comparison_category_strong;

template <class... _Types>
using common_comparison_category_t =
    conditional_t<(_Classify_category<_Types...> & _Comparison_category_none) != 0, void,
        conditional_t<(_Classify_category<_Types...> & _Comparison_category_partial) != 0, partial_ordering,
            conditional_t<(_Classify_category<_Types...> & _Comparison_category_weak) != 0, weak_ordering,
                strong_ordering>>>;

template <class... _Types>
struct common_comparison_category {
    using type = common_comparison_category_t<_Types...>;
};


template <class _Ty, class _Cat>
concept _Compares_as = same_as<common_comparison_category_t<_Ty, _Cat>, _Cat>;

template <class _Ty, class _Cat = partial_ordering>
concept three_way_comparable = _Half_equality_comparable<_Ty, _Ty> && _Half_ordered<_Ty, _Ty>
    && requires(const remove_reference_t<_Ty>& __a, const remove_reference_t<_Ty>& __b) {
        { __a <=> __b } -> _Compares_as<_Cat>;
    };

template <class _Ty1, class _Ty2, class _Cat = partial_ordering>
concept three_way_comparable_with = three_way_comparable<_Ty1, _Cat> && three_way_comparable<_Ty2, _Cat>
    && common_reference_with<const remove_reference_t<_Ty1>&, const remove_reference_t<_Ty2>&>
    && three_way_comparable<common_reference_t<const remove_reference_t<_Ty1>&, const remove_reference_t<_Ty2>&>, _Cat>
    && _Weakly_equality_comparable_with<_Ty1, _Ty2> && _Partially_ordered_with<_Ty1, _Ty2>
    && requires(const remove_reference_t<_Ty1>& __t, const remove_reference_t<_Ty2>& __u) {
        { __t <=> __u } -> _Compares_as<_Cat>;
        { __u <=> __t } -> _Compares_as<_Cat>;
    };

template <class _Ty1, class _Ty2 = _Ty1>
using compare_three_way_result_t =
    decltype(::std:: declval<const remove_reference_t<_Ty1>&>() <=> ::std:: declval<const remove_reference_t<_Ty2>&>());

template <class _Ty1, class _Ty2 = _Ty1>
struct compare_three_way_result {};

template <class _Ty1, class _Ty2>
    requires requires { typename compare_three_way_result_t<_Ty1, _Ty2>; }
struct compare_three_way_result<_Ty1, _Ty2> {
    using type = compare_three_way_result_t<_Ty1, _Ty2>;
};

struct compare_three_way {
    template <class _Ty1, class _Ty2>
        requires three_way_comparable_with<_Ty1, _Ty2>
    [[nodiscard]] constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
        noexcept(noexcept(::std:: forward<_Ty1>(_Left) <=> ::std:: forward<_Ty2>(_Right)))  {
        return ::std:: forward<_Ty1>(_Left) <=> ::std:: forward<_Ty2>(_Right);
    }

    using is_transparent = int;
};


struct _Synth_three_way {
    
    template <class _Ty1, class _Ty2>
    [[nodiscard]] constexpr auto operator()(const _Ty1& _Left, const _Ty2& _Right) const
    requires requires {
        { _Left < _Right } -> _Boolean_testable;
        { _Right < _Left } -> _Boolean_testable;
    }
    
    {
        if constexpr (three_way_comparable_with<_Ty1, _Ty2>) {
            return _Left <=> _Right;
        } else {
            if (_Left < _Right) {
                return weak_ordering::less;
            } else if (_Right < _Left) {
                return weak_ordering::greater;
            } else {
                return weak_ordering::equivalent;
            }
        }
    }
};

template <class _Ty1, class _Ty2 = _Ty1>
using _Synth_three_way_result = decltype(_Synth_three_way{}(::std:: declval<_Ty1&>(), ::std:: declval<_Ty2&>()));


namespace _Strong_order {
    void strong_order(); 

    template <class _Ty1, class _Ty2>
    concept _Has_ADL = requires(_Ty1& _Left, _Ty2& _Right) {
        static_cast<strong_ordering>( strong_order(_Left, _Right));
    };

    template <class _Ty1, class _Ty2>
    concept _Can_compare_three_way = requires(_Ty1& _Left, _Ty2& _Right) {
        static_cast<strong_ordering>(compare_three_way{}(_Left, _Right));
    };

    class _Cpo {
    private:
        enum class _St { _None, _Adl, _Floating, _Three };

        template <class _Ty1, class _Ty2>
        [[nodiscard]] static consteval _Choice_t<_St> _Choose() noexcept {
            if constexpr (!same_as<decay_t<_Ty1>, decay_t<_Ty2>>) {
                return {_St::_None};
            } else if constexpr (_Has_ADL<_Ty1, _Ty2>) {
                return {_St::_Adl, noexcept(static_cast<strong_ordering>(
                                        strong_order(::std:: declval<_Ty1&>(), ::std:: declval<_Ty2&>())))};
            } else if constexpr (floating_point<decay_t<_Ty1>>) {
                return {_St::_Floating, true};
            } else if constexpr (_Can_compare_three_way<_Ty1, _Ty2>) {
                return {_St::_Three, noexcept(static_cast<strong_ordering>(
                                         compare_three_way{}(::std:: declval<_Ty1&>(), ::std:: declval<_Ty2&>())))};
            } else {
                return {_St::_None};
            }
        }

        template <class _Ty1, class _Ty2>
        static constexpr _Choice_t<_St> _Choice = _Choose<_Ty1, _Ty2>();

    public:
        
        template <class _Ty1, class _Ty2>
            requires (_Choice<_Ty1&, _Ty2&>._Strategy != _St::_None)
        [[nodiscard]] constexpr strong_ordering operator()(_Ty1&& _Left, _Ty2&& _Right) const
            noexcept(_Choice<_Ty1&, _Ty2&>._No_throw) {
            
            constexpr _St _Strat = _Choice<_Ty1&, _Ty2&>._Strategy;
            if constexpr (_Strat == _St::_Adl) {
                return static_cast<strong_ordering>( strong_order(_Left, _Right));
            } else if constexpr (_Strat == _St::_Floating) {
                using _Floating_type = decay_t<_Ty1>;
                using _Traits        = _Floating_type_traits<_Floating_type>;
                using _Uint_type     = typename _Traits::_Uint_type;
                using _Sint_type     = make_signed_t<_Uint_type>;

                const auto _Left_uint  = ::std:: bit_cast<_Uint_type>(_Left);
                const auto _Right_uint = ::std:: bit_cast<_Uint_type>(_Right);

                
                if (_Left_uint == _Right_uint) {
                    return strong_ordering::equal;
                }

                
                const _Uint_type _Left_shifted_sign  = _Left_uint & _Traits::_Shifted_sign_mask;
                const _Uint_type _Right_shifted_sign = _Right_uint & _Traits::_Shifted_sign_mask;

                
                const _Uint_type _Left_sign  = _Left_shifted_sign >> _Traits::_Sign_shift;
                const _Uint_type _Right_sign = _Right_shifted_sign >> _Traits::_Sign_shift;

                const _Uint_type _Left_xor  = _Left_shifted_sign - _Left_sign;
                const _Uint_type _Right_xor = _Right_shifted_sign - _Right_sign;

                const _Uint_type _Left_ones_complement_uint  = _Left_uint ^ _Left_xor;
                const _Uint_type _Right_ones_complement_uint = _Right_uint ^ _Right_xor;

                const auto _Left_ones_complement  = static_cast<_Sint_type>(_Left_ones_complement_uint);
                const auto _Right_ones_complement = static_cast<_Sint_type>(_Right_ones_complement_uint);

                
                return _Left_ones_complement <=> _Right_ones_complement;
            } else if constexpr (_Strat == _St::_Three) {
                return static_cast<strong_ordering>(compare_three_way{}(_Left, _Right));
            } else {
                static_assert(_Always_false<_Ty1>, "should be unreachable");
            }
        }
    };
} 

inline namespace _Cpos {
    inline constexpr _Strong_order::_Cpo strong_order;
}

namespace _Weak_order {
    void weak_order(); 

    template <class _Ty1, class _Ty2>
    concept _Has_ADL = requires(_Ty1& _Left, _Ty2& _Right) {
        static_cast<weak_ordering>( weak_order(_Left, _Right));
    };

    template <class _Ty1, class _Ty2>
    concept _Can_compare_three_way = requires(_Ty1& _Left, _Ty2& _Right) {
        static_cast<weak_ordering>(compare_three_way{}(_Left, _Right));
    };

    
    void strong_order(); 

    class _Cpo {
    private:
        enum class _St { _None, _Adl, _Floating, _Three, _Strong };

        template <class _Ty1, class _Ty2>
        [[nodiscard]] static consteval _Choice_t<_St> _Choose() noexcept {
            if constexpr (!same_as<decay_t<_Ty1>, decay_t<_Ty2>>) {
                return {_St::_None};
            } else if constexpr (_Has_ADL<_Ty1, _Ty2>) {
                return {_St::_Adl, noexcept(static_cast<weak_ordering>(
                                        weak_order(::std:: declval<_Ty1&>(), ::std:: declval<_Ty2&>())))};
            } else if constexpr (floating_point<decay_t<_Ty1>>) {
                return {_St::_Floating, true};
            } else if constexpr (_Can_compare_three_way<_Ty1, _Ty2>) {
                return {_St::_Three, noexcept(static_cast<weak_ordering>(
                                         compare_three_way{}(::std:: declval<_Ty1&>(), ::std:: declval<_Ty2&>())))};
            } else if constexpr (_Strong_order::_Has_ADL<_Ty1, _Ty2>) {
                return {_St::_Strong, noexcept(static_cast<weak_ordering>(static_cast<strong_ordering>(
                                           strong_order(
                                              ::std:: declval<_Ty1&>(), ::std:: declval<_Ty2&>()))))};
            } else {
                return {_St::_None};
            }
        }

        template <class _Ty1, class _Ty2>
        static constexpr _Choice_t<_St> _Choice = _Choose<_Ty1, _Ty2>();

    public:
        
        template <class _Ty1, class _Ty2>
            requires (_Choice<_Ty1&, _Ty2&>._Strategy != _St::_None)
        [[nodiscard]] constexpr weak_ordering operator()(_Ty1&& _Left, _Ty2&& _Right) const
            noexcept(_Choice<_Ty1&, _Ty2&>._No_throw) {
            
            constexpr _St _Strat = _Choice<_Ty1&, _Ty2&>._Strategy;
            if constexpr (_Strat == _St::_Adl) {
                return static_cast<weak_ordering>( weak_order(_Left, _Right));
            } else if constexpr (_Strat == _St::_Floating) {
                using _Floating_type = decay_t<_Ty1>;
                using _Traits        = _Floating_type_traits<_Floating_type>;
                using _Uint_type     = typename _Traits::_Uint_type;
                using _Sint_type     = make_signed_t<_Uint_type>;

                auto _Left_uint  = ::std:: bit_cast<_Uint_type>(_Left);
                auto _Right_uint = ::std:: bit_cast<_Uint_type>(_Right);

                
                if (_Left_uint == _Right_uint) {
                    return weak_ordering::equivalent;
                }

                
                const _Uint_type _Left_shifted_sign  = _Left_uint & _Traits::_Shifted_sign_mask;
                const _Uint_type _Right_shifted_sign = _Right_uint & _Traits::_Shifted_sign_mask;

                
                constexpr _Uint_type _Infinity_plus_one = _Traits::_Shifted_exponent_mask + 1;

                const _Uint_type _Left_magnitude  = _Left_uint & ~_Traits::_Shifted_sign_mask;
                const _Uint_type _Right_magnitude = _Right_uint & ~_Traits::_Shifted_sign_mask;

                if (_Left_magnitude > _Infinity_plus_one) {
                    _Left_uint = _Left_shifted_sign | _Infinity_plus_one;
                }

                if (_Right_magnitude > _Infinity_plus_one) {
                    _Right_uint = _Right_shifted_sign | _Infinity_plus_one;
                }

                
                const _Uint_type _Left_sign  = _Left_shifted_sign >> _Traits::_Sign_shift;
                const _Uint_type _Right_sign = _Right_shifted_sign >> _Traits::_Sign_shift;

                const _Uint_type _Left_xor  = _Left_shifted_sign - _Left_sign;
                const _Uint_type _Right_xor = _Right_shifted_sign - _Right_sign;

                const _Uint_type _Left_twos_complement_uint  = (_Left_uint ^ _Left_xor) + _Left_sign;
                const _Uint_type _Right_twos_complement_uint = (_Right_uint ^ _Right_xor) + _Right_sign;

                const auto _Left_twos_complement  = static_cast<_Sint_type>(_Left_twos_complement_uint);
                const auto _Right_twos_complement = static_cast<_Sint_type>(_Right_twos_complement_uint);

                
                return static_cast<weak_ordering>(_Left_twos_complement <=> _Right_twos_complement);
            } else if constexpr (_Strat == _St::_Three) {
                return static_cast<weak_ordering>(compare_three_way{}(_Left, _Right));
            } else if constexpr (_Strat == _St::_Strong) {
                return static_cast<weak_ordering>(
                    static_cast<strong_ordering>( strong_order(_Left, _Right)));
            } else {
                static_assert(_Always_false<_Ty1>, "should be unreachable");
            }
        }
    };
} 

inline namespace _Cpos {
    inline constexpr _Weak_order::_Cpo weak_order;
}

namespace _Partial_order {
    void partial_order(); 

    template <class _Ty1, class _Ty2>
    concept _Has_ADL = requires(_Ty1& _Left, _Ty2& _Right) {
        static_cast<partial_ordering>( partial_order(_Left, _Right));
    };

    template <class _Ty1, class _Ty2>
    concept _Can_compare_three_way = requires(_Ty1& _Left, _Ty2& _Right) {
        static_cast<partial_ordering>(compare_three_way{}(_Left, _Right));
    };

    
    void weak_order(); 
    void strong_order(); 

    class _Cpo {
    private:
        enum class _St { _None, _Adl, _Three, _Weak, _Strong };

        template <class _Ty1, class _Ty2>
        [[nodiscard]] static consteval _Choice_t<_St> _Choose() noexcept {
            if constexpr (!same_as<decay_t<_Ty1>, decay_t<_Ty2>>) {
                return {_St::_None};
            } else if constexpr (_Has_ADL<_Ty1, _Ty2>) {
                return {_St::_Adl, noexcept(static_cast<partial_ordering>(
                                        partial_order(::std:: declval<_Ty1&>(), ::std:: declval<_Ty2&>())))};
            } else if constexpr (_Can_compare_three_way<_Ty1, _Ty2>) {
                return {_St::_Three, noexcept(static_cast<partial_ordering>(
                                         compare_three_way{}(::std:: declval<_Ty1&>(), ::std:: declval<_Ty2&>())))};
            } else if constexpr (_Weak_order::_Has_ADL<_Ty1, _Ty2>) {
                return {_St::_Weak,
                    noexcept(static_cast<partial_ordering>(static_cast<weak_ordering>(
                         weak_order(::std:: declval<_Ty1&>(), ::std:: declval<_Ty2&>()))))};
            } else if constexpr (_Strong_order::_Has_ADL<_Ty1, _Ty2>) {
                return {_St::_Strong, noexcept(static_cast<partial_ordering>(static_cast<strong_ordering>(
                                           strong_order(
                                              ::std:: declval<_Ty1&>(), ::std:: declval<_Ty2&>()))))};
            } else {
                return {_St::_None};
            }
        }

        template <class _Ty1, class _Ty2>
        static constexpr _Choice_t<_St> _Choice = _Choose<_Ty1, _Ty2>();

    public:
        
        template <class _Ty1, class _Ty2>
            requires (_Choice<_Ty1&, _Ty2&>._Strategy != _St::_None)
        [[nodiscard]] constexpr partial_ordering operator()(_Ty1&& _Left, _Ty2&& _Right) const
            noexcept(_Choice<_Ty1&, _Ty2&>._No_throw) {
            
            constexpr _St _Strat = _Choice<_Ty1&, _Ty2&>._Strategy;
            if constexpr (_Strat == _St::_Adl) {
                return static_cast<partial_ordering>( partial_order(_Left, _Right));
            } else if constexpr (_Strat == _St::_Three) {
                return static_cast<partial_ordering>(compare_three_way{}(_Left, _Right));
            } else if constexpr (_Strat == _St::_Weak) {
                return static_cast<partial_ordering>(
                    static_cast<weak_ordering>( weak_order(_Left, _Right)));
            } else if constexpr (_Strat == _St::_Strong) {
                return static_cast<partial_ordering>(
                    static_cast<strong_ordering>( strong_order(_Left, _Right)));
            } else {
                static_assert(_Always_false<_Ty1>, "should be unreachable");
            }
        }
    };
} 

inline namespace _Cpos {
    inline constexpr _Partial_order::_Cpo partial_order;
}

template <class _Ty1, class _Ty2>
concept _Can_fallback_eq_lt = requires(_Ty1& _Left, _Ty2& _Right) {
    { _Left == _Right } -> _Implicitly_convertible_to<bool>;
    { _Left < _Right } -> _Implicitly_convertible_to<bool>;
};

template <class _Ty1, class _Ty2>
concept _Can_strong_order = requires(_Ty1& _Left, _Ty2& _Right) {
    ::std:: strong_order(_Left, _Right);
};

namespace _Compare_strong_order_fallback {
    class _Cpo {
    private:
        enum class _St { _None, _Strong, _Fallback };

        template <class _Ty1, class _Ty2>
        [[nodiscard]] static consteval _Choice_t<_St> _Choose() noexcept {
            if constexpr (!same_as<decay_t<_Ty1>, decay_t<_Ty2>>) {
                return {_St::_None};
            } else if constexpr (_Can_strong_order<_Ty1, _Ty2>) {
                return {_St::_Strong, noexcept(::std:: strong_order(::std:: declval<_Ty1&>(), ::std:: declval<_Ty2&>()))};
            } else if constexpr (_Can_fallback_eq_lt<_Ty1, _Ty2>) {
                return {_St::_Fallback,
                    noexcept(::std:: declval<_Ty1&>() == ::std:: declval<_Ty2&>()  ? strong_ordering::equal
                             : ::std:: declval<_Ty1&>() < ::std:: declval<_Ty2&>() ? strong_ordering::less
                                                                             : strong_ordering::greater)};
            } else {
                return {_St::_None};
            }
        }

        template <class _Ty1, class _Ty2>
        static constexpr _Choice_t<_St> _Choice = _Choose<_Ty1, _Ty2>();

    public:
        
        template <class _Ty1, class _Ty2>
            requires (_Choice<_Ty1&, _Ty2&>._Strategy != _St::_None)
        [[nodiscard]] constexpr strong_ordering operator()(_Ty1&& _Left, _Ty2&& _Right) const
            noexcept(_Choice<_Ty1&, _Ty2&>._No_throw) {
            
            constexpr _St _Strat = _Choice<_Ty1&, _Ty2&>._Strategy;
            if constexpr (_Strat == _St::_Strong) {
                return ::std:: strong_order(_Left, _Right);
            } else if constexpr (_Strat == _St::_Fallback) {
                return _Left == _Right ? strong_ordering::equal
                     : _Left < _Right  ? strong_ordering::less
                                       : strong_ordering::greater;
            } else {
                static_assert(_Always_false<_Ty1>, "should be unreachable");
            }
        }
    };
} 

inline namespace _Cpos {
    inline constexpr _Compare_strong_order_fallback::_Cpo compare_strong_order_fallback;
}

template <class _Ty1, class _Ty2>
concept _Can_weak_order = requires(_Ty1& _Left, _Ty2& _Right) {
    ::std:: weak_order(_Left, _Right);
};

namespace _Compare_weak_order_fallback {
    class _Cpo {
    private:
        enum class _St { _None, _Weak, _Fallback };

        template <class _Ty1, class _Ty2>
        [[nodiscard]] static consteval _Choice_t<_St> _Choose() noexcept {
            if constexpr (!same_as<decay_t<_Ty1>, decay_t<_Ty2>>) {
                return {_St::_None};
            } else if constexpr (_Can_weak_order<_Ty1, _Ty2>) {
                return {_St::_Weak, noexcept(::std:: weak_order(::std:: declval<_Ty1&>(), ::std:: declval<_Ty2&>()))};
            } else if constexpr (_Can_fallback_eq_lt<_Ty1, _Ty2>) {
                return {
                    _St::_Fallback, noexcept(::std:: declval<_Ty1&>() == ::std:: declval<_Ty2&>()  ? weak_ordering::equivalent
                                             : ::std:: declval<_Ty1&>() < ::std:: declval<_Ty2&>() ? weak_ordering::less
                                                                                             : weak_ordering::greater)};
            } else {
                return {_St::_None};
            }
        }

        template <class _Ty1, class _Ty2>
        static constexpr _Choice_t<_St> _Choice = _Choose<_Ty1, _Ty2>();

    public:
        
        template <class _Ty1, class _Ty2>
            requires (_Choice<_Ty1&, _Ty2&>._Strategy != _St::_None)
        [[nodiscard]] constexpr weak_ordering operator()(_Ty1&& _Left, _Ty2&& _Right) const
            noexcept(_Choice<_Ty1&, _Ty2&>._No_throw) {
            
            constexpr _St _Strat = _Choice<_Ty1&, _Ty2&>._Strategy;
            if constexpr (_Strat == _St::_Weak) {
                return ::std:: weak_order(_Left, _Right);
            } else if constexpr (_Strat == _St::_Fallback) {
                return _Left == _Right ? weak_ordering::equivalent
                     : _Left < _Right  ? weak_ordering::less
                                       : weak_ordering::greater;
            } else {
                static_assert(_Always_false<_Ty1>, "should be unreachable");
            }
        }
    };
} 

inline namespace _Cpos {
    inline constexpr _Compare_weak_order_fallback::_Cpo compare_weak_order_fallback;
}

template <class _Ty1, class _Ty2>
concept _Can_partial_order = requires(_Ty1& _Left, _Ty2& _Right) {
    ::std:: partial_order(_Left, _Right);
};

namespace _Compare_partial_order_fallback {
    template <class _Ty1, class _Ty2>
    concept _Can_fallback_eq_lt_twice = requires(_Ty1 & _Left, _Ty2 & _Right) {
        { _Left == _Right } -> _Implicitly_convertible_to<bool>;
        { _Left < _Right } -> _Implicitly_convertible_to<bool>;
        { _Right < _Left } -> _Implicitly_convertible_to<bool>;
    };

    class _Cpo {
    private:
        enum class _St { _None, _Partial, _Fallback };

        template <class _Ty1, class _Ty2>
        [[nodiscard]] static consteval _Choice_t<_St> _Choose() noexcept {
            if constexpr (!same_as<decay_t<_Ty1>, decay_t<_Ty2>>) {
                return {_St::_None};
            } else if constexpr (_Can_partial_order<_Ty1, _Ty2>) {
                return {_St::_Partial, noexcept(::std:: partial_order(::std:: declval<_Ty1&>(), ::std:: declval<_Ty2&>()))};
            } else if constexpr (_Can_fallback_eq_lt_twice<_Ty1, _Ty2>) {
                return {_St::_Fallback,
                    noexcept(::std:: declval<_Ty1&>() == ::std:: declval<_Ty2&>()  ? partial_ordering::equivalent
                             : ::std:: declval<_Ty1&>() < ::std:: declval<_Ty2&>() ? partial_ordering::less
                             : ::std:: declval<_Ty2&>() < ::std:: declval<_Ty1&>() ? partial_ordering::greater
                                                                             : partial_ordering::unordered)};
            } else {
                return {_St::_None};
            }
        }

        template <class _Ty1, class _Ty2>
        static constexpr _Choice_t<_St> _Choice = _Choose<_Ty1, _Ty2>();

    public:
        
        template <class _Ty1, class _Ty2>
            requires (_Choice<_Ty1&, _Ty2&>._Strategy != _St::_None)
        [[nodiscard]] constexpr partial_ordering operator()(_Ty1&& _Left, _Ty2&& _Right) const
            noexcept(_Choice<_Ty1&, _Ty2&>._No_throw) {
            
            constexpr _St _Strat = _Choice<_Ty1&, _Ty2&>._Strategy;
            if constexpr (_Strat == _St::_Partial) {
                return ::std:: partial_order(_Left, _Right);
            } else if constexpr (_Strat == _St::_Fallback) {
                return _Left == _Right ? partial_ordering::equivalent
                     : _Left < _Right  ? partial_ordering::less
                     : _Right < _Left  ? partial_ordering::greater
                                       : partial_ordering::unordered;
            } else {
                static_assert(_Always_false<_Ty1>, "should be unreachable");
            }
        }
    };
} 

inline namespace _Cpos {
    inline constexpr _Compare_partial_order_fallback::_Cpo compare_partial_order_fallback;
}

#line 834 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\compare"
}


#pragma warning(pop)
#pragma pack(pop)
#line 841 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\compare"

#line 843 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\compare"
#line 844 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\compare"
#line 26 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\coroutine"
#line 27 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\coroutine"


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {

template <class _Ret, class = void>
struct _Coroutine_traits {};

template <class _Ret>
struct _Coroutine_traits<_Ret, void_t<typename _Ret::promise_type>> {
    using promise_type = typename _Ret::promise_type;
};

template <class _Ret, class...>
struct coroutine_traits : _Coroutine_traits<_Ret> {};

template <class = void>
struct coroutine_handle;

template <>
struct coroutine_handle<void> {
    constexpr coroutine_handle() noexcept = default;
    constexpr coroutine_handle(nullptr_t) noexcept {}

    coroutine_handle& operator=(nullptr_t) noexcept {
        _Ptr = nullptr;
        return *this;
    }

    [[nodiscard]] constexpr void* address() const noexcept {
        return _Ptr;
    }

    [[nodiscard]] static constexpr coroutine_handle from_address(void* const _Addr) noexcept { 
        coroutine_handle _Result;
        _Result._Ptr = _Addr;
        return _Result;
    }

    constexpr explicit operator bool() const noexcept {
        return _Ptr != nullptr;
    }

    [[nodiscard]] bool done() const noexcept { 
        return __builtin_coro_done(_Ptr);
    }

    void operator()() const {
        __builtin_coro_resume(_Ptr);
    }

    void resume() const {
        __builtin_coro_resume(_Ptr);
    }

    void destroy() const noexcept { 
        __builtin_coro_destroy(_Ptr);
    }

private:
    void* _Ptr = nullptr;
};

template <class _Promise>
struct coroutine_handle {
    constexpr coroutine_handle() noexcept = default;
    constexpr coroutine_handle(nullptr_t) noexcept {}

    [[nodiscard]] static coroutine_handle from_promise(_Promise& _Prom) noexcept { 
        const auto _Prom_ptr  = const_cast<void*>(static_cast<const volatile void*>(::std:: addressof(_Prom)));
        const auto _Frame_ptr = __builtin_coro_promise(_Prom_ptr, 0, true);
        coroutine_handle _Result;
        _Result._Ptr = _Frame_ptr;
        return _Result;
    }

    coroutine_handle& operator=(nullptr_t) noexcept {
        _Ptr = nullptr;
        return *this;
    }

    [[nodiscard]] constexpr void* address() const noexcept {
        return _Ptr;
    }

    [[nodiscard]] static constexpr coroutine_handle from_address(void* const _Addr) noexcept { 
        coroutine_handle _Result;
        _Result._Ptr = _Addr;
        return _Result;
    }

    constexpr operator coroutine_handle<>() const noexcept {
        return coroutine_handle<>::from_address(_Ptr);
    }

    constexpr explicit operator bool() const noexcept {
        return _Ptr != nullptr;
    }

    [[nodiscard]] bool done() const noexcept { 
        return __builtin_coro_done(_Ptr);
    }

    void operator()() const {
        __builtin_coro_resume(_Ptr);
    }

    void resume() const {
        __builtin_coro_resume(_Ptr);
    }

    void destroy() const noexcept { 
        __builtin_coro_destroy(_Ptr);
    }

    [[nodiscard]] _Promise& promise() const noexcept { 
        return *reinterpret_cast<_Promise*>(__builtin_coro_promise(_Ptr, 0, false));
    }

private:
    void* _Ptr = nullptr;
};

[[nodiscard]] constexpr bool operator==(const coroutine_handle<> _Left, const coroutine_handle<> _Right) noexcept {
    return _Left.address() == _Right.address();
}


[[nodiscard]] constexpr strong_ordering operator<=>(
    const coroutine_handle<> _Left, const coroutine_handle<> _Right) noexcept {

    return compare_three_way{}(_Left.address(), _Right.address());


#line 168 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\coroutine"
}


#line 190 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\coroutine"

template <class _Promise>
struct hash<coroutine_handle<_Promise>> {
    [[nodiscard]] size_t operator()(const coroutine_handle<_Promise>& _Coro) const noexcept {
        return _Hash_representation(_Coro.address());
    }
};

struct noop_coroutine_promise {};

template <>
struct coroutine_handle<noop_coroutine_promise> {
    friend coroutine_handle noop_coroutine() noexcept;

    constexpr operator coroutine_handle<>() const noexcept {
        return coroutine_handle<>::from_address(_Ptr);
    }

    constexpr explicit operator bool() const noexcept {
        return true;
    }
    [[nodiscard]] constexpr bool done() const noexcept {
        return false;
    }

    constexpr void operator()() const noexcept {}
    constexpr void resume() const noexcept {}
    constexpr void destroy() const noexcept {}

    [[nodiscard]] noop_coroutine_promise& promise() const noexcept {
        
        return *reinterpret_cast<noop_coroutine_promise*>(__builtin_coro_promise(_Ptr, 0, false));
    }

    [[nodiscard]] constexpr void* address() const noexcept {
        return _Ptr;
    }

private:
    coroutine_handle() noexcept = default;

    void* _Ptr = __builtin_coro_noop();
};

using noop_coroutine_handle = coroutine_handle<noop_coroutine_promise>;

[[nodiscard]] inline noop_coroutine_handle noop_coroutine() noexcept {
    
    return noop_coroutine_handle{};
}

struct suspend_never {
    [[nodiscard]] constexpr bool await_ready() const noexcept {
        return true;
    }

    constexpr void await_suspend(coroutine_handle<>) const noexcept {}
    constexpr void await_resume() const noexcept {}
};

struct suspend_always {
    [[nodiscard]] constexpr bool await_ready() const noexcept {
        return false;
    }

    constexpr void await_suspend(coroutine_handle<>) const noexcept {}
    constexpr void await_resume() const noexcept {}
};

}


#pragma warning(pop)
#pragma pack(pop)

#line 267 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\coroutine"
#line 268 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\coroutine"
#line 269 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\coroutine"
#line 270 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\coroutine"
#line 12 "all-std.cxx"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\any"


#pragma once


#line 15 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\any"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\typeinfo"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\exception"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"


#pragma once


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\crtdbg.h"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime_new_debug.h"


#pragma once


#pragma warning(push)
#pragma warning(disable:   4514 4820 )


extern "C++" {

#pragma pack(push, 8)


    [[nodiscard]]      
    __declspec(allocator) void* __cdecl operator new(
            size_t      _Size,
            int         _BlockUse,
          char const* _FileName,
            int         _LineNumber
        );

    [[nodiscard]]      
    __declspec(allocator) void* __cdecl operator new[](
            size_t      _Size,
            int         _BlockUse,
          char const* _FileName,
            int         _LineNumber
        );

    void __cdecl operator delete(
        void*       _Block,
        int         _BlockUse,
        char const* _FileName,
        int         _LineNumber
        ) noexcept;

    void __cdecl operator delete[](
        void*       _Block,
        int         _BlockUse,
        char const* _FileName,
        int         _LineNumber
        ) noexcept;

#line 56 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime_new_debug.h"


#pragma pack(pop)

} 
#line 63 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime_new_debug.h"

#pragma warning(pop) 
#line 14 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\crtdbg.h"

#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


typedef void* _HFILE; 


typedef int (__cdecl* _CRT_REPORT_HOOK )(int, char*,    int*);
typedef int (__cdecl* _CRT_REPORT_HOOKW)(int, wchar_t*, int*);


typedef int (__cdecl* _CRT_ALLOC_HOOK)(int, void*, size_t, int, long, unsigned char const*, int);


typedef void (__cdecl* _CRT_DUMP_CLIENT)(void*, size_t);


struct _CrtMemBlockHeader;

typedef struct _CrtMemState
{
    struct _CrtMemBlockHeader* pBlockHeader;
    size_t lCounts[5];
    size_t lSizes[5];
    size_t lHighWaterCount;
    size_t lTotalCount;
} _CrtMemState;


#line 239 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\crtdbg.h"


#line 590 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\crtdbg.h"


#line 690 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\crtdbg.h"


    #line 706 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\crtdbg.h"

    
    #line 710 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\crtdbg.h"

    
    #line 714 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\crtdbg.h"

    
#line 771 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\crtdbg.h"


#line 786 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\crtdbg.h"


} __pragma(pack(pop))

#pragma warning(pop) 
#line 817 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\crtdbg.h"
#line 13 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\crtdefs.h"


#line 24 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\crtdefs.h"
        
    #line 26 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\crtdefs.h"
#line 27 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\crtdefs.h"


#line 33 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\crtdefs.h"
        
    #line 35 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\crtdefs.h"
#line 36 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\crtdefs.h"


#line 42 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\crtdefs.h"
        
    #line 44 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\crtdefs.h"
#line 45 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\crtdefs.h"


#line 54 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\crtdefs.h"


#line 57 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\crtdefs.h"
        
        
    #line 60 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\crtdefs.h"
#line 61 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\crtdefs.h"


#line 66 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\crtdefs.h"
        

#line 69 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\crtdefs.h"
            
        #line 71 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\crtdefs.h"
    #line 72 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\crtdefs.h"
#line 73 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\crtdefs.h"


#line 78 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\crtdefs.h"

#line 80 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\crtdefs.h"
        
    #line 82 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\crtdefs.h"
#line 83 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\crtdefs.h"
#line 14 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


#line 31 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"

#line 33 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"


#line 49 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"
#line 50 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"
#line 51 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"


#line 106 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"
#line 107 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"


#line 117 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"

#line 119 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"
#line 120 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"


#line 125 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"

#line 127 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"

#line 129 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"

#line 131 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"


#pragma detect_mismatch("_MSC_VER", "1900")
#line 135 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"


#pragma detect_mismatch("_ITERATOR_DEBUG_LEVEL", "0")
#line 139 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"


#pragma detect_mismatch("RuntimeLibrary", "MT_StaticRelease")


#line 150 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"
#line 151 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"


#line 158 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"
#line 159 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"


#line 163 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"


#line 170 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"
#line 171 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"


#line 201 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"


#line 207 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"


#line 213 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"


#line 220 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"
#line 221 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"


#line 225 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"

#line 227 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\use_ansi.h"


#pragma once


#line 16 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\use_ansi.h"


#line 33 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\use_ansi.h"


#line 37 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\use_ansi.h"


#line 42 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\use_ansi.h"
#line 43 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\use_ansi.h"


#line 48 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\use_ansi.h"

#pragma comment(lib, "libcpmt" "" "")


#line 57 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\use_ansi.h"

#line 59 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\use_ansi.h"

#line 61 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\use_ansi.h"
#line 230 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"


#line 250 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"


#line 257 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"
#line 258 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"


#line 262 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"


#line 269 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"
#line 270 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"


#line 283 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"

#line 285 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"

#line 287 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"
#line 288 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"


#line 295 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"
#line 296 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"


#line 303 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"
#line 304 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"


#line 309 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"

#line 311 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"
#line 312 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"


#line 329 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"

#line 331 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"
#line 332 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"


#line 336 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"


#line 340 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"

namespace std {
enum _Uninitialized { 
    _Noinit
};

class  _Lockit { 
public:


    __thiscall _Lockit() noexcept;
    explicit __thiscall _Lockit(int) noexcept; 
    __thiscall ~_Lockit() noexcept; 
#line 366 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"

    static void __cdecl _Lockit_ctor(int) noexcept;
    static void __cdecl _Lockit_dtor(int) noexcept;

private:
    static void __cdecl _Lockit_ctor(_Lockit*) noexcept;
    static void __cdecl _Lockit_ctor(_Lockit*, int) noexcept;
    static void __cdecl _Lockit_dtor(_Lockit*) noexcept;

public:
     _Lockit(const _Lockit&) = delete;
    _Lockit&  operator=(const _Lockit&) = delete;

private:
    int _Locktype;
};


#line 455 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"

class  _Init_locks { 
public:


    __thiscall _Init_locks() noexcept;
    __thiscall ~_Init_locks() noexcept;
#line 471 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"

private:
    static void __cdecl _Init_locks_ctor(_Init_locks*) noexcept;
    static void __cdecl _Init_locks_dtor(_Init_locks*) noexcept;
};


#line 513 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"
}


#pragma warning(pop)
#pragma pack(pop)
#line 524 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"
#line 525 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\yvals.h"
#line 10 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\exception"


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {


#line 26 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\exception"
 int __cdecl uncaught_exceptions() noexcept;

}


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\malloc.h"


#pragma once


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


#line 29 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\malloc.h"


typedef struct _heapinfo
{
    int* _pentry;
    size_t _size;
    int _useflag;
} _HEAPINFO;


void* __cdecl _alloca(  size_t _Size);


     intptr_t __cdecl _get_heap_handle(void);

     
     int __cdecl _heapmin(void);

    
         int __cdecl _heapwalk(  _HEAPINFO* _EntryInfo);
    #line 69 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\malloc.h"

    
           int __cdecl _heapchk(void);
    #line 73 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\malloc.h"

     int __cdecl _resetstkoflw(void);

    
    #line 85 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\malloc.h"

    static_assert((sizeof(unsigned int) <= 8), "sizeof(unsigned int) <= _ALLOCA_S_MARKER_SIZE");


    #pragma warning(push)
    #pragma warning(disable: 6540) 
                                   

    __inline void* _MarkAllocaS(   void* _Ptr, unsigned int _Marker)
    {
        if (_Ptr)
        {
            *((unsigned int*)_Ptr) = _Marker;
            _Ptr = (char*)_Ptr + 8;
        }
        return _Ptr;
    }

    __inline size_t _MallocaComputeSize(size_t _Size)
    {
        size_t _MarkedSize = _Size + 8;
        return _MarkedSize > _Size ? _MarkedSize : 0;
    }

    #pragma warning(pop)

#line 112 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\malloc.h"


#line 139 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\malloc.h"


#line 144 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\malloc.h"
#line 145 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\malloc.h"

    
    #pragma warning(push)
    #pragma warning(disable: 6014) 
    __inline void __cdecl _freea(    void* _Memory)
    {
        unsigned int _Marker;
        if (_Memory)
        {
            _Memory = (char*)_Memory - 8;
            _Marker = *(unsigned int*)_Memory;
            if (_Marker == 0xDDDD)
            {
                free(_Memory);
            }
            
            else if (_Marker != 0xCCCC)
            {
                ((void)0);
            }
            #line 167 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\malloc.h"
        }
    }
    #pragma warning(pop)

#line 172 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\malloc.h"


#line 178 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\malloc.h"


} __pragma(pack(pop))

#pragma warning(pop) 
#line 185 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\malloc.h"
#line 33 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\exception"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime_exception.h"


#pragma once

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\eh.h"


#pragma once


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_terminate.h"


#pragma once


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


typedef void (__cdecl* terminate_handler )(void);
typedef void (__cdecl* terminate_function)(void);


     __declspec(noreturn) void __cdecl abort();
     __declspec(noreturn) void __cdecl terminate() throw();

    
         terminate_handler __cdecl set_terminate(
              terminate_handler _NewTerminateHandler
            ) throw();

         terminate_handler __cdecl _get_terminate();

    #line 44 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_terminate.h"

#line 46 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_terminate.h"

} __pragma(pack(pop))

#line 50 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_terminate.h"

#pragma warning(pop) 
#line 13 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\eh.h"


#pragma warning(push)
#pragma warning(disable:   4514 4820 )

__pragma(pack(push, 8)) extern "C" {


typedef void (__cdecl* unexpected_handler )(void);
typedef void (__cdecl* unexpected_function)(void);


struct _EXCEPTION_POINTERS;


     __declspec(noreturn) void __cdecl unexpected() noexcept(false);

    
         unexpected_handler __cdecl set_unexpected(
              unexpected_handler _NewUnexpectedHandler
            ) noexcept;

         unexpected_handler __cdecl _get_unexpected() noexcept;

        typedef void (__cdecl* _se_translator_function)(unsigned int, struct _EXCEPTION_POINTERS*);

         _se_translator_function __cdecl _set_se_translator(
              _se_translator_function _NewSETranslator
            );

    #line 52 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\eh.h"

    class type_info;

     int __cdecl _is_exception_typeof(
          type_info const&     _Type,
          _EXCEPTION_POINTERS* _ExceptionPtr
        );

     bool __cdecl __uncaught_exception();
     int  __cdecl __uncaught_exceptions();

#line 64 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\eh.h"

} __pragma(pack(pop))

#pragma warning(pop) 

#line 70 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\eh.h"
#line 11 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime_exception.h"


#pragma warning(push)
#pragma warning(disable:   4514 4820 )

#pragma pack(push, 8)

__pragma(pack(push, 8)) extern "C" {

struct __std_exception_data
{
    char const* _What;
    bool        _DoFree;
};

 void __cdecl __std_exception_copy(
       __std_exception_data const* _From,
      __std_exception_data*       _To
    );

 void __cdecl __std_exception_destroy(
      __std_exception_data* _Data
    );

} __pragma(pack(pop))


namespace std {

#pragma warning(push)
#pragma warning(disable: 4577) 
class exception
{
public:

    exception() noexcept
        : _Data()
    {
    }

    explicit exception(char const* const _Message) noexcept
        : _Data()
    {
        __std_exception_data _InitData = { _Message, true };
        __std_exception_copy(&_InitData, &_Data);
    }

    exception(char const* const _Message, int) noexcept
        : _Data()
    {
        _Data._What = _Message;
    }

    exception(exception const& _Other) noexcept
        : _Data()
    {
        __std_exception_copy(&_Other._Data, &_Data);
    }

    exception& operator=(exception const& _Other) noexcept
    {
        if (this == &_Other)
        {
            return *this;
        }

        __std_exception_destroy(&_Data);
        __std_exception_copy(&_Other._Data, &_Data);
        return *this;
    }

    virtual ~exception() noexcept
    {
        __std_exception_destroy(&_Data);
    }

    [[nodiscard]] virtual char const* what() const
    {
        return _Data._What ? _Data._What : "Unknown exception";
    }

private:

    __std_exception_data _Data;
};

class bad_exception
    : public exception
{
public:

    bad_exception() noexcept
        : exception("bad exception", 1)
    {
    }
};

class bad_alloc
    : public exception
{
public:

    bad_alloc() noexcept
        : exception("bad allocation", 1)
    {
    }

private:

    friend class bad_array_new_length;

    bad_alloc(char const* const _Message) noexcept
        : exception(_Message, 1)
    {
    }
};

class bad_array_new_length
    : public bad_alloc
{
public:

    bad_array_new_length() noexcept
        : bad_alloc("bad array new length")
    {
    }
};

#pragma warning(pop)

} 

#pragma pack(pop)

#pragma warning(pop) 
#line 153 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime_exception.h"
#line 34 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\exception"

namespace std {

using ::terminate;


using ::set_terminate;
using ::terminate_handler;

[[nodiscard]] inline terminate_handler __cdecl get_terminate() noexcept { 
    return _get_terminate();
}
#line 47 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\exception"


#line 60 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\exception"

}


#line 195 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\exception"

 void __cdecl __ExceptionPtrCreate(  void*) noexcept;
 void __cdecl __ExceptionPtrDestroy(  void*) noexcept;
 void __cdecl __ExceptionPtrCopy(  void*,   const void*) noexcept;
 void __cdecl __ExceptionPtrAssign(  void*,   const void*) noexcept;
 bool __cdecl __ExceptionPtrCompare(  const void*,   const void*) noexcept;
 bool __cdecl __ExceptionPtrToBool(  const void*) noexcept;
 void __cdecl __ExceptionPtrSwap(  void*,   void*) noexcept;
 void __cdecl __ExceptionPtrCurrentException(void*) noexcept;
[[noreturn]]  void __cdecl __ExceptionPtrRethrow(  const void*);
 void __cdecl __ExceptionPtrCopyException(
      void*,   const void*,   const void*) noexcept;

namespace std {

class exception_ptr {
public:
    exception_ptr() noexcept {
        __ExceptionPtrCreate(this);
    }

    exception_ptr(nullptr_t) noexcept {
        __ExceptionPtrCreate(this);
    }

    ~exception_ptr() noexcept {
        __ExceptionPtrDestroy(this);
    }

    exception_ptr(const exception_ptr& _Rhs) noexcept {
        __ExceptionPtrCopy(this, &_Rhs);
    }

    exception_ptr& operator=(const exception_ptr& _Rhs) noexcept {
        __ExceptionPtrAssign(this, &_Rhs);
        return *this;
    }

    exception_ptr& operator=(nullptr_t) noexcept {
        exception_ptr _Ptr;
        __ExceptionPtrAssign(this, &_Ptr);
        return *this;
    }

    explicit operator bool() const noexcept {
        return __ExceptionPtrToBool(this);
    }

    static exception_ptr _Current_exception() noexcept {
        exception_ptr _Retval;
        __ExceptionPtrCurrentException(&_Retval);
        return _Retval;
    }

    static exception_ptr _Copy_exception(  void* _Except,   const void* _Ptr) {
        exception_ptr _Retval;
        if (!_Ptr) {
            
            return _Retval;
        }
        __ExceptionPtrCopyException(&_Retval, _Except, _Ptr);
        return _Retval;
    }

    friend void swap(exception_ptr& _Lhs, exception_ptr& _Rhs) noexcept {
        __ExceptionPtrSwap(&_Lhs, &_Rhs);
    }

    [[nodiscard]] friend bool operator==(const exception_ptr& _Lhs, const exception_ptr& _Rhs) noexcept {
        return __ExceptionPtrCompare(&_Lhs, &_Rhs);
    }

    [[nodiscard]] friend bool operator==(const exception_ptr& _Lhs, nullptr_t) noexcept {
        return !_Lhs;
    }


#line 288 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\exception"

private:


    void* _Data1;
    void* _Data2;


};

[[nodiscard]] inline exception_ptr current_exception() noexcept {
    return exception_ptr::_Current_exception();
}

[[noreturn]] inline void rethrow_exception(  exception_ptr _Ptr) {
    __ExceptionPtrRethrow(&_Ptr);
}

template <class _Ex>
void* __GetExceptionInfo(_Ex);

template <class _Ex>
[[nodiscard]] exception_ptr make_exception_ptr(_Ex _Except) noexcept {
    return exception_ptr::_Copy_exception(::std:: addressof(_Except), __GetExceptionInfo(_Except));
}

[[noreturn]] inline void _Throw_bad_array_new_length() {
    throw bad_array_new_length{};
}

class nested_exception { 
public:
    nested_exception() noexcept : _Exc(::std:: current_exception()) {}

    nested_exception(const nested_exception&) noexcept = default;
    nested_exception& operator=(const nested_exception&) noexcept = default;
    virtual ~nested_exception() noexcept {}

    [[noreturn]] void rethrow_nested() const { 
        if (_Exc) {
            ::std:: rethrow_exception(_Exc);
        } else {
            ::std:: terminate();
        }
    }

    [[nodiscard]] exception_ptr nested_ptr() const noexcept { 
        return _Exc;
    }

private:
    exception_ptr _Exc;
};

template <class _Ty, class _Uty>
struct _With_nested : _Uty, nested_exception { 
    explicit _With_nested(_Ty&& _Arg)
        : _Uty(::std:: forward<_Ty>(_Arg)), nested_exception() {} 
};

template <class _Ty>
[[noreturn]] void throw_with_nested(_Ty&& _Arg) { 
    using _Uty = decay_t<_Ty>;

    if constexpr (is_class_v<_Uty> && !is_base_of_v<nested_exception, _Uty> && !is_final_v<_Uty>) {
        
        using _Glued = _With_nested<_Ty, _Uty>;
        throw _Glued(::std:: forward<_Ty>(_Arg));
    } else {
        
        throw ::std:: forward<_Ty>(_Arg);
    }
}


template <class _Ty>
void _Rethrow_if_nested(const _Ty* _Ptr, true_type) { 
    const auto _Nested = dynamic_cast<const nested_exception*>(_Ptr);

    if (_Nested) {
        _Nested->rethrow_nested();
    }
}

template <class _Ty>
void _Rethrow_if_nested(const _Ty*, false_type) {} 

template <class _Ty>
void rethrow_if_nested(const _Ty& _Arg) { 
    bool_constant<
        is_polymorphic_v<_Ty> && (!is_base_of_v<nested_exception, _Ty> || is_convertible_v<_Ty*, nested_exception*>)>
        _Tag;

    _Rethrow_if_nested(::std:: addressof(_Arg), _Tag);
}


#line 390 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\exception"

}


#pragma warning(pop)
#pragma pack(pop)

#line 399 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\exception"
#line 400 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\exception"
#line 13 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\typeinfo"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


#pragma warning(disable : 4275) 

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime_typeinfo.h"


#pragma once


#pragma warning(push)
#pragma warning(disable:   4514 4820 )

#pragma pack(push, 8)


#line 25 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime_typeinfo.h"
    struct __type_info_node;
#line 27 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime_typeinfo.h"


    extern __type_info_node __type_info_root_node;
#line 33 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime_typeinfo.h"


__pragma(pack(push, 8)) extern "C" {

struct __std_type_info_data
{
    const char * _UndecoratedName;
    const char   _DecoratedName[1];
    __std_type_info_data() = delete;
    __std_type_info_data(const __std_type_info_data&) = delete;
    __std_type_info_data(__std_type_info_data&&) = delete;

    __std_type_info_data& operator=(const __std_type_info_data&) = delete;
    __std_type_info_data& operator=(__std_type_info_data&&) = delete;
};

 int __cdecl __std_type_info_compare(
      const __std_type_info_data* _Lhs,
      const __std_type_info_data* _Rhs
    );

 size_t __cdecl __std_type_info_hash(
      const __std_type_info_data* _Data
    );

 const char* __cdecl __std_type_info_name(
      __std_type_info_data* _Data,
      __type_info_node*     _RootNode
    );

} __pragma(pack(pop))


#pragma warning(push)
#pragma warning(disable: 4577) 
class type_info
{
public:

    type_info(const type_info&) = delete;
    type_info& operator=(const type_info&) = delete;

    size_t hash_code() const noexcept
    {
        return __std_type_info_hash(&_Data);
    }

    bool operator==(const type_info& _Other) const noexcept
    {
        return __std_type_info_compare(&_Data, &_Other._Data) == 0;
    }


#line 92 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime_typeinfo.h"

    bool before(const type_info& _Other) const noexcept
    {
        return __std_type_info_compare(&_Data, &_Other._Data) < 0;
    }

    const char* name() const noexcept
    {
        

        return __std_type_info_name(&_Data, &__type_info_root_node);
        #line 105 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime_typeinfo.h"
    }

    const char* raw_name() const noexcept
    {
        return _Data._DecoratedName;
    }

    virtual ~type_info() noexcept;

private:

    mutable __std_type_info_data _Data;
};
#pragma warning(pop)

namespace std {
    using ::type_info;
}


namespace std {

#pragma warning(push)
#pragma warning(disable: 4577) 
class bad_cast
    : public exception
{
public:

    bad_cast() noexcept
        : exception("bad cast", 1)
    {
    }

    static bad_cast __construct_from_string_literal(const char* const _Message) noexcept
    {
        return bad_cast(_Message, 1);
    }

private:

    bad_cast(const char* const _Message, int) noexcept
        : exception(_Message, 1)
    {
    }
};

class bad_typeid
    : public exception
{
public:

    bad_typeid() noexcept
        : exception("bad typeid", 1)
    {
    }

    static bad_typeid __construct_from_string_literal(const char* const _Message) noexcept
    {
        return bad_typeid(_Message, 1);
    }

private:

    friend class __non_rtti_object;

    bad_typeid(const char* const _Message, int) noexcept
        : exception(_Message, 1)
    {
    }
};

class __non_rtti_object
    : public bad_typeid
{
public:

    static __non_rtti_object __construct_from_string_literal(const char* const _Message) noexcept
    {
        return __non_rtti_object(_Message, 1);
    }

private:

    __non_rtti_object(const char* const _Message, int) noexcept
        : bad_typeid(_Message, 1)
    {
    }
};

#pragma warning(pop)
} 

#line 200 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime_typeinfo.h"
#pragma pack(pop)
#pragma warning(pop) 
#line 203 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime_typeinfo.h"
#line 24 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\typeinfo"

namespace std {


constexpr int _Small_object_num_ptrs = 6 + 16 / sizeof(void*);


#line 61 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\typeinfo"

[[noreturn]] inline void _Throw_bad_cast() {
    throw bad_cast{};
}

}


#pragma pack(pop)
#pragma warning(pop)
#line 73 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\typeinfo"
#line 74 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\typeinfo"
#line 18 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\any"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\utility"


#pragma once


#line 17 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\utility"


#line 21 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\utility"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
template <class _Ty, class _Pr>
[[nodiscard]] constexpr const _Ty&(max) (const _Ty& _Left, const _Ty& _Right, _Pr _Pred) noexcept(
    noexcept(_Pred(_Left, _Right)))  {
    
    return _Pred(_Left, _Right) ? _Right : _Left;
}

#pragma warning(push)
#pragma warning(disable : 28285) 
template <class _Ty>
[[nodiscard]]   constexpr const _Ty& 
    (max) (const _Ty& _Left, const _Ty& _Right) noexcept(noexcept(_Left < _Right))  {
    
    return _Left < _Right ? _Right : _Left;
}
#pragma warning(pop)

template <class _Ty, class _Pr>
[[nodiscard]] constexpr _Ty(max)(initializer_list<_Ty>, _Pr); 

template <class _Ty>
[[nodiscard]] constexpr _Ty(max)(initializer_list<_Ty>); 

template <class _Ty, class _Pr>
[[nodiscard]] constexpr const _Ty&(min) (const _Ty& _Left, const _Ty& _Right, _Pr _Pred) noexcept(
    noexcept(_Pred(_Right, _Left)))  {
    
    return _Pred(_Right, _Left) ? _Right : _Left;
}

#pragma warning(push)
#pragma warning(disable : 28285) 
template <class _Ty>
[[nodiscard]]   constexpr const _Ty& 
    (min) (const _Ty& _Left, const _Ty& _Right) noexcept(noexcept(_Right < _Left))  {
    
    return _Right < _Left ? _Right : _Left;
}
#pragma warning(pop)

template <class _Ty, class _Pr>
[[nodiscard]] constexpr _Ty(min)(initializer_list<_Ty>, _Pr); 

template <class _Ty>
[[nodiscard]] constexpr _Ty(min)(initializer_list<_Ty>); 

template <class _FwdIt1, class _FwdIt2>
constexpr void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right) { 
    swap(*_Left, *_Right);
}

template <class _Ty, size_t _Size, enable_if_t<_Is_swappable<_Ty>::value, int> _Enabled>
constexpr void swap(_Ty (&_Left)[_Size], _Ty (&_Right)[_Size]) noexcept(_Is_nothrow_swappable<_Ty>::value) {
    if (&_Left != &_Right) {
        _Ty* _First1 = _Left;
        _Ty* _Last1  = _First1 + _Size;
        _Ty* _First2 = _Right;
        for (; _First1 != _Last1; ++_First1, ++_First2) {
            ::std:: iter_swap(_First1, _First2);
        }
    }
}


template <class _Ty, enable_if_t<is_move_constructible_v<_Ty> && is_move_assignable_v<_Ty>, int> _Enabled>


#line 98 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\utility"
constexpr void swap(_Ty& _Left, _Ty& _Right) noexcept(
    is_nothrow_move_constructible_v<_Ty>&& is_nothrow_move_assignable_v<_Ty>) {
    _Ty _Tmp = ::std:: move(_Left);
    _Left    = ::std:: move(_Right);
    _Right   = ::std:: move(_Tmp);
}

template <class _Ty>
constexpr void _Swap_adl(_Ty& _Left, _Ty& _Right) noexcept(_Is_nothrow_swappable<_Ty>::value) {
    swap(_Left, _Right);
}

struct piecewise_construct_t { 
    explicit piecewise_construct_t() = default;
};

inline constexpr piecewise_construct_t piecewise_construct{};

template <class...>
class tuple;

template <size_t _Index, class... _Types>
[[nodiscard]] constexpr auto&& _Tuple_get(tuple<_Types...>&& _Tuple) noexcept;

template <class _Ty1, class _Ty2>
struct pair { 
    using first_type  = _Ty1;
    using second_type = _Ty2;


    template <class _Uty1 = _Ty1, class _Uty2 = _Ty2,
        enable_if_t<conjunction_v<is_default_constructible<_Uty1>, is_default_constructible<_Uty2>>, int> = 0>
    constexpr explicit(
        !conjunction_v<_Is_implicitly_default_constructible<_Uty1>, _Is_implicitly_default_constructible<_Uty2>>)
        pair() noexcept(
            is_nothrow_default_constructible_v<_Uty1>&& is_nothrow_default_constructible_v<_Uty2>) 
        : first(), second() {}


#line 153 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\utility"


    template <class _Uty1 = _Ty1, class _Uty2 = _Ty2,
        enable_if_t<conjunction_v<is_copy_constructible<_Uty1>, is_copy_constructible<_Uty2>>, int> = 0>
    constexpr explicit(!conjunction_v<is_convertible<const _Uty1&, _Uty1>, is_convertible<const _Uty2&, _Uty2>>)
        pair(const _Ty1& _Val1, const _Ty2& _Val2) noexcept(
            is_nothrow_copy_constructible_v<_Uty1>&& is_nothrow_copy_constructible_v<_Uty2>) 
        : first(_Val1), second(_Val2) {}


#line 179 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\utility"


    template <class _Other1 = _Ty1, class _Other2 = _Ty2,


#line 186 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\utility"
        enable_if_t<conjunction_v<is_constructible<_Ty1, _Other1>, is_constructible<_Ty2, _Other2>>, int> = 0>
    constexpr explicit(!conjunction_v<is_convertible<_Other1, _Ty1>, is_convertible<_Other2, _Ty2>>)
        pair(_Other1&& _Val1, _Other2&& _Val2) noexcept(
            is_nothrow_constructible_v<_Ty1, _Other1>&& is_nothrow_constructible_v<_Ty2, _Other2>) 
        : first(::std:: forward<_Other1>(_Val1)), second(::std:: forward<_Other2>(_Val2)) {
    }


#line 209 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\utility"

    pair(const pair&) = default;
    pair(pair&&)      = default;


    template <class _Other1, class _Other2,
        enable_if_t<conjunction_v<is_constructible<_Ty1, const _Other1&>, is_constructible<_Ty2, const _Other2&>>,
            int> = 0>
    constexpr explicit(!conjunction_v<is_convertible<const _Other1&, _Ty1>, is_convertible<const _Other2&, _Ty2>>)
        pair(const pair<_Other1, _Other2>& _Right) noexcept(is_nothrow_constructible_v<_Ty1, const _Other1&>&&
                is_nothrow_constructible_v<_Ty2, const _Other2&>) 
        : first(_Right.first), second(_Right.second) {}


#line 240 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\utility"


    template <class _Other1, class _Other2,
        enable_if_t<conjunction_v<is_constructible<_Ty1, _Other1>, is_constructible<_Ty2, _Other2>>, int> = 0>
    constexpr explicit(!conjunction_v<is_convertible<_Other1, _Ty1>, is_convertible<_Other2, _Ty2>>)
        pair(pair<_Other1, _Other2>&& _Right) noexcept(
            is_nothrow_constructible_v<_Ty1, _Other1>&& is_nothrow_constructible_v<_Ty2, _Other2>) 
        : first(::std:: forward<_Other1>(_Right.first)), second(::std:: forward<_Other2>(_Right.second)) {}


#line 265 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\utility"

    template <class _Tuple1, class _Tuple2, size_t... _Indexes1, size_t... _Indexes2>
    constexpr pair(_Tuple1& _Val1, _Tuple2& _Val2, index_sequence<_Indexes1...>, index_sequence<_Indexes2...>)
        : first(_Tuple_get<_Indexes1>(::std:: move(_Val1))...), second(_Tuple_get<_Indexes2>(::std:: move(_Val2))...) {}

    template <class... _Types1, class... _Types2>
    constexpr pair(piecewise_construct_t, tuple<_Types1...> _Val1, tuple<_Types2...> _Val2)
        : pair(_Val1, _Val2, index_sequence_for<_Types1...>{}, index_sequence_for<_Types2...>{}) {}

    pair& operator=(const volatile pair&) = delete;

    template <class _Myself = pair,
        enable_if_t<conjunction_v<_Is_copy_assignable_no_precondition_check<typename _Myself::first_type>,
                        _Is_copy_assignable_no_precondition_check<typename _Myself::second_type>>,
            int>            = 0>
    constexpr pair& operator=(_Identity_t<const _Myself&> _Right) noexcept(
        conjunction_v<is_nothrow_copy_assignable<_Ty1>, is_nothrow_copy_assignable<_Ty2>>)  {
        first  = _Right.first;
        second = _Right.second;
        return *this;
    }

    template <class _Myself = pair,
        enable_if_t<conjunction_v<_Is_move_assignable_no_precondition_check<typename _Myself::first_type>,
                        _Is_move_assignable_no_precondition_check<typename _Myself::second_type>>,
            int>            = 0>
    constexpr pair& operator=(_Identity_t<_Myself&&> _Right) noexcept(
        conjunction_v<is_nothrow_move_assignable<_Ty1>, is_nothrow_move_assignable<_Ty2>>)  {
        first  = ::std:: forward<_Ty1>(_Right.first);
        second = ::std:: forward<_Ty2>(_Right.second);
        return *this;
    }

    template <class _Other1, class _Other2,
        enable_if_t<conjunction_v<negation<is_same<pair, pair<_Other1, _Other2>>>, is_assignable<_Ty1&, const _Other1&>,
                        is_assignable<_Ty2&, const _Other2&>>,
            int> = 0>
    constexpr pair& operator=(const pair<_Other1, _Other2>& _Right) noexcept(
        is_nothrow_assignable_v<_Ty1&, const _Other1&>&&
            is_nothrow_assignable_v<_Ty2&, const _Other2&>)  {
        first  = _Right.first;
        second = _Right.second;
        return *this;
    }

    template <class _Other1, class _Other2,
        enable_if_t<conjunction_v<negation<is_same<pair, pair<_Other1, _Other2>>>, is_assignable<_Ty1&, _Other1>,
                        is_assignable<_Ty2&, _Other2>>,
            int> = 0>
    constexpr pair& operator=(pair<_Other1, _Other2>&& _Right) noexcept(
        is_nothrow_assignable_v<_Ty1&, _Other1>&& is_nothrow_assignable_v<_Ty2&, _Other2>)  {
        first  = ::std:: forward<_Other1>(_Right.first);
        second = ::std:: forward<_Other2>(_Right.second);
        return *this;
    }

    constexpr void swap(pair& _Right) noexcept(
        _Is_nothrow_swappable<_Ty1>::value&& _Is_nothrow_swappable<_Ty2>::value) {
        if (this != ::std:: addressof(_Right)) {
            _Swap_adl(first, _Right.first);
            _Swap_adl(second, _Right.second);
        }
    }

    _Ty1 first; 
    _Ty2 second; 
};


template <class _Ty1, class _Ty2>
pair(_Ty1, _Ty2) -> pair<_Ty1, _Ty2>;
#line 337 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\utility"

template <class _Ty1, class _Ty2, enable_if_t<_Is_swappable<_Ty1>::value && _Is_swappable<_Ty2>::value, int> = 0>
constexpr void swap(pair<_Ty1, _Ty2>& _Left, pair<_Ty1, _Ty2>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
    _Left.swap(_Right);
}

template <class _Ty1, class _Ty2>
[[nodiscard]] constexpr bool operator==(const pair<_Ty1, _Ty2>& _Left, const pair<_Ty1, _Ty2>& _Right) {
    return _Left.first == _Right.first && _Left.second == _Right.second;
}


template <class _Ty1, class _Ty2>
[[nodiscard]] constexpr common_comparison_category_t<_Synth_three_way_result<_Ty1>, _Synth_three_way_result<_Ty2>>
    operator<=>(const pair<_Ty1, _Ty2>& _Left, const pair<_Ty1, _Ty2>& _Right) {
    if (auto _Result = _Synth_three_way{}(_Left.first, _Right.first); _Result != 0) {
        return _Result;
    }
    return _Synth_three_way{}(_Left.second, _Right.second);
}


#line 385 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\utility"

template <class _Ty>
struct _Unrefwrap_helper { 
    using type = _Ty;
};

template <class _Ty>
struct _Unrefwrap_helper<reference_wrapper<_Ty>> { 
    using type = _Ty&;
};


template <class _Ty>
using _Unrefwrap_t = typename _Unrefwrap_helper<decay_t<_Ty>>::type;

template <class _Ty1, class _Ty2>
[[nodiscard]] constexpr pair<_Unrefwrap_t<_Ty1>, _Unrefwrap_t<_Ty2>> make_pair(_Ty1&& _Val1, _Ty2&& _Val2) noexcept(
    is_nothrow_constructible_v<_Unrefwrap_t<_Ty1>, _Ty1>&&
        is_nothrow_constructible_v<_Unrefwrap_t<_Ty2>, _Ty2>)  {
    
    using _Mypair = pair<_Unrefwrap_t<_Ty1>, _Unrefwrap_t<_Ty2>>;
    return _Mypair(::std:: forward<_Ty1>(_Val1), ::std:: forward<_Ty2>(_Val2));
}

namespace [[deprecated("warning STL4027: " "The namespace std::rel_ops and its contents are deprecated in C++20. " "Their use is superseded by C++20's <=> operator and automatic rewrites of relational expressions. " "You can define _SILENCE_CXX20_REL_OPS_DEPRECATION_WARNING or " "_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] rel_ops {
    template <class _Ty>
    [[deprecated("warning STL4027: " "The namespace std::rel_ops and its contents are deprecated in C++20. " "Their use is superseded by C++20's <=> operator and automatic rewrites of relational expressions. " "You can define _SILENCE_CXX20_REL_OPS_DEPRECATION_WARNING or " "_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] [[nodiscard]] bool operator!=(const _Ty& _Left, const _Ty& _Right) {
        return !(_Left == _Right);
    }

    template <class _Ty>
    [[deprecated("warning STL4027: " "The namespace std::rel_ops and its contents are deprecated in C++20. " "Their use is superseded by C++20's <=> operator and automatic rewrites of relational expressions. " "You can define _SILENCE_CXX20_REL_OPS_DEPRECATION_WARNING or " "_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] [[nodiscard]] bool operator>(const _Ty& _Left, const _Ty& _Right) {
        return _Right < _Left;
    }

    template <class _Ty>
    [[deprecated("warning STL4027: " "The namespace std::rel_ops and its contents are deprecated in C++20. " "Their use is superseded by C++20's <=> operator and automatic rewrites of relational expressions. " "You can define _SILENCE_CXX20_REL_OPS_DEPRECATION_WARNING or " "_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] [[nodiscard]] bool operator<=(const _Ty& _Left, const _Ty& _Right) {
        return !(_Right < _Left);
    }

    template <class _Ty>
    [[deprecated("warning STL4027: " "The namespace std::rel_ops and its contents are deprecated in C++20. " "Their use is superseded by C++20's <=> operator and automatic rewrites of relational expressions. " "You can define _SILENCE_CXX20_REL_OPS_DEPRECATION_WARNING or " "_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] [[nodiscard]] bool operator>=(const _Ty& _Left, const _Ty& _Right) {
        return !(_Left < _Right);
    }
} 

template <class _Tuple>
struct tuple_size;

template <class _Tuple, class = void>
struct _Tuple_size_sfinae {}; 

template <class _Tuple>
struct _Tuple_size_sfinae<_Tuple, void_t<decltype(tuple_size<_Tuple>::value)>>
    : integral_constant<size_t, tuple_size<_Tuple>::value> {}; 

template <class _Tuple>
struct tuple_size<const _Tuple> : _Tuple_size_sfinae<_Tuple> {}; 

template <class _Tuple>
struct [[deprecated("warning STL4030: " "Some operations on volatile-qualified types in the STL are deprecated in C++20. " "You can define _SILENCE_CXX20_VOLATILE_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] tuple_size<volatile _Tuple> : _Tuple_size_sfinae<_Tuple> {}; 

template <class _Tuple>
struct [[deprecated("warning STL4030: " "Some operations on volatile-qualified types in the STL are deprecated in C++20. " "You can define _SILENCE_CXX20_VOLATILE_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] tuple_size<const volatile _Tuple> : _Tuple_size_sfinae<_Tuple> {}; 

template <class _Ty>
inline constexpr size_t tuple_size_v = tuple_size<_Ty>::value;

template <size_t _Index, class _Tuple>
struct tuple_element;

template <size_t _Index, class _Tuple>
struct [[msvc::known_semantics]] tuple_element<_Index, const _Tuple> : tuple_element<_Index, _Tuple> {
    using _Mybase = tuple_element<_Index, _Tuple>;
    using type    = add_const_t<typename _Mybase::type>;
};

template <size_t _Index, class _Tuple>
struct [[deprecated("warning STL4030: " "Some operations on volatile-qualified types in the STL are deprecated in C++20. " "You can define _SILENCE_CXX20_VOLATILE_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] [[msvc::known_semantics]] tuple_element<_Index, volatile _Tuple>
    : tuple_element<_Index, _Tuple> {
    using _Mybase = tuple_element<_Index, _Tuple>;
    using type    = add_volatile_t<typename _Mybase::type>;
};

template <size_t _Index, class _Tuple>
struct [[deprecated("warning STL4030: " "Some operations on volatile-qualified types in the STL are deprecated in C++20. " "You can define _SILENCE_CXX20_VOLATILE_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] [[msvc::known_semantics]] tuple_element<_Index, const volatile _Tuple>
    : tuple_element<_Index, _Tuple> {
    using _Mybase = tuple_element<_Index, _Tuple>;
    using type    = add_cv_t<typename _Mybase::type>;
};

template <size_t _Index, class _Tuple>
using tuple_element_t = typename tuple_element<_Index, _Tuple>::type;

template <class _Ty, size_t _Size>
class array;

template <class _Ty, size_t _Size>
struct tuple_size<array<_Ty, _Size>> : integral_constant<size_t, _Size> {}; 

template <size_t _Idx, class _Ty, size_t _Size>
struct [[msvc::known_semantics]] tuple_element<_Idx, array<_Ty, _Size>> {
    static_assert(_Idx < _Size, "array index out of bounds");

    using type = _Ty;
};

template <class... _Types>
struct tuple_size<tuple<_Types...>> : integral_constant<size_t, sizeof...(_Types)> {}; 

template <size_t _Index>
struct [[msvc::known_semantics]] tuple_element<_Index, tuple<>> { 
    static_assert(_Always_false<integral_constant<size_t, _Index>>, "tuple index out of bounds");
};

template <class _This, class... _Rest>
struct [[msvc::known_semantics]] tuple_element<0, tuple<_This, _Rest...>> { 
    using type = _This;
    
    using _Ttype = tuple<_This, _Rest...>;
};

template <size_t _Index, class _This, class... _Rest>
struct [[msvc::known_semantics]] tuple_element<_Index, tuple<_This, _Rest...>>
    : tuple_element<_Index - 1, tuple<_Rest...>> {}; 

template <class _Ty1, class _Ty2>
struct tuple_size<pair<_Ty1, _Ty2>> : integral_constant<size_t, 2> {}; 

template <size_t _Idx, class _Ty1, class _Ty2>
struct [[msvc::known_semantics]] tuple_element<_Idx, pair<_Ty1, _Ty2>> {
    static_assert(_Idx < 2, "pair index out of bounds");

    using type = conditional_t<_Idx == 0, _Ty1, _Ty2>;
};

template <class _Ret, class _Pair>
constexpr _Ret _Pair_get(_Pair& _Pr, integral_constant<size_t, 0>) noexcept { 
    return _Pr.first;
}

template <class _Ret, class _Pair>
constexpr _Ret _Pair_get(_Pair& _Pr, integral_constant<size_t, 1>) noexcept { 
    return _Pr.second;
}

template <size_t _Idx, class _Ty1, class _Ty2>
[[nodiscard]] constexpr tuple_element_t<_Idx, pair<_Ty1, _Ty2>>& get(
    pair<_Ty1, _Ty2>& _Pr) noexcept { 
    using _Rtype = tuple_element_t<_Idx, pair<_Ty1, _Ty2>>&;
    return _Pair_get<_Rtype>(_Pr, integral_constant<size_t, _Idx>{});
}

template <class _Ty1, class _Ty2>
[[nodiscard]] constexpr _Ty1& get(pair<_Ty1, _Ty2>& _Pr) noexcept { 
    return ::std:: get<0>(_Pr);
}

template <class _Ty2, class _Ty1>
[[nodiscard]] constexpr _Ty2& get(pair<_Ty1, _Ty2>& _Pr) noexcept { 
    return ::std:: get<1>(_Pr);
}

template <size_t _Idx, class _Ty1, class _Ty2>
[[nodiscard]] constexpr const tuple_element_t<_Idx, pair<_Ty1, _Ty2>>& get(
    const pair<_Ty1, _Ty2>& _Pr) noexcept { 
    using _Ctype = const tuple_element_t<_Idx, pair<_Ty1, _Ty2>>&;
    return _Pair_get<_Ctype>(_Pr, integral_constant<size_t, _Idx>{});
}

template <class _Ty1, class _Ty2>
[[nodiscard]] constexpr const _Ty1& get(
    const pair<_Ty1, _Ty2>& _Pr) noexcept { 
    return ::std:: get<0>(_Pr);
}

template <class _Ty2, class _Ty1>
[[nodiscard]] constexpr const _Ty2& get(
    const pair<_Ty1, _Ty2>& _Pr) noexcept { 
    return ::std:: get<1>(_Pr);
}

template <size_t _Idx, class _Ty1, class _Ty2>
[[nodiscard]] constexpr tuple_element_t<_Idx, pair<_Ty1, _Ty2>>&& get(
    pair<_Ty1, _Ty2>&& _Pr) noexcept { 
    using _RRtype = tuple_element_t<_Idx, pair<_Ty1, _Ty2>>&&;
    return ::std:: forward<_RRtype>(::std:: get<_Idx>(_Pr));
}

template <class _Ty1, class _Ty2>
[[nodiscard]] constexpr _Ty1&& get(pair<_Ty1, _Ty2>&& _Pr) noexcept { 
    return ::std:: get<0>(::std:: move(_Pr));
}

template <class _Ty2, class _Ty1>
[[nodiscard]] constexpr _Ty2&& get(pair<_Ty1, _Ty2>&& _Pr) noexcept { 
    return ::std:: get<1>(::std:: move(_Pr));
}

template <size_t _Idx, class _Ty1, class _Ty2>
[[nodiscard]] constexpr const tuple_element_t<_Idx, pair<_Ty1, _Ty2>>&& get(
    const pair<_Ty1, _Ty2>&& _Pr) noexcept { 
    using _RRtype = const tuple_element_t<_Idx, pair<_Ty1, _Ty2>>&&;
    return ::std:: forward<_RRtype>(::std:: get<_Idx>(_Pr));
}

template <class _Ty1, class _Ty2>
[[nodiscard]] constexpr const _Ty1&& get(
    const pair<_Ty1, _Ty2>&& _Pr) noexcept { 
    return ::std:: get<0>(::std:: move(_Pr));
}

template <class _Ty2, class _Ty1>
[[nodiscard]] constexpr const _Ty2&& get(
    const pair<_Ty1, _Ty2>&& _Pr) noexcept { 
    return ::std:: get<1>(::std:: move(_Pr));
}

template <class _Ty, class _Other = _Ty>
constexpr _Ty exchange(_Ty& _Val, _Other&& _New_val) noexcept(
    conjunction_v<is_nothrow_move_constructible<_Ty>, is_nothrow_assignable<_Ty&, _Other>>) {
    
    _Ty _Old_val = static_cast<_Ty&&>(_Val);
    _Val         = static_cast<_Other&&>(_New_val);
    return _Old_val;
}

template <class _Ty>
[[nodiscard]] constexpr add_const_t<_Ty>& as_const(_Ty& _Val) noexcept { 
    return _Val;
}

template <class _Ty>
void as_const(const _Ty&&) = delete;


struct in_place_t { 
    explicit in_place_t() = default;
};
inline constexpr in_place_t in_place{};

template <class>
struct in_place_type_t { 
    explicit in_place_type_t() = default;
};
template <class _Ty>
inline constexpr in_place_type_t<_Ty> in_place_type{};

template <size_t>
struct in_place_index_t { 
    explicit in_place_index_t() = default;
};
template <size_t _Idx>
inline constexpr in_place_index_t<_Idx> in_place_index{};
#line 640 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\utility"


template <class _Ty>
inline constexpr bool _Is_standard_integer = is_integral_v<_Ty>
    && !_Is_any_of_v<remove_cv_t<_Ty>, bool, char,

        wchar_t,
#line 648 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\utility"

        char8_t,
#line 651 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\utility"
        char16_t, char32_t>;

template <class _Ty1, class _Ty2>
[[nodiscard]] constexpr bool cmp_equal(const _Ty1 _Left, const _Ty2 _Right) noexcept {
    static_assert(_Is_standard_integer<_Ty1> && _Is_standard_integer<_Ty2>,
        "The integer comparison functions only accept standard and extended integer types.");
    if constexpr (is_signed_v<_Ty1> == is_signed_v<_Ty2>) {
        return _Left == _Right;
    } else if constexpr (is_signed_v<_Ty2>) {
        return _Left == static_cast<make_unsigned_t<_Ty2>>(_Right) && _Right >= 0;
    } else {
        return static_cast<make_unsigned_t<_Ty1>>(_Left) == _Right && _Left >= 0;
    }
}

template <class _Ty1, class _Ty2>
[[nodiscard]] constexpr bool cmp_not_equal(const _Ty1 _Left, const _Ty2 _Right) noexcept {
    return !::std:: cmp_equal(_Left, _Right);
}

template <class _Ty1, class _Ty2>
[[nodiscard]] constexpr bool cmp_less(const _Ty1 _Left, const _Ty2 _Right) noexcept {
    static_assert(_Is_standard_integer<_Ty1> && _Is_standard_integer<_Ty2>,
        "The integer comparison functions only accept standard and extended integer types.");
    if constexpr (is_signed_v<_Ty1> == is_signed_v<_Ty2>) {
        return _Left < _Right;
    } else if constexpr (is_signed_v<_Ty2>) {
        return _Right > 0 && _Left < static_cast<make_unsigned_t<_Ty2>>(_Right);
    } else {
        return _Left < 0 || static_cast<make_unsigned_t<_Ty1>>(_Left) < _Right;
    }
}

template <class _Ty1, class _Ty2>
[[nodiscard]] constexpr bool cmp_greater(const _Ty1 _Left, const _Ty2 _Right) noexcept {
    return ::std:: cmp_less(_Right, _Left);
}

template <class _Ty1, class _Ty2>
[[nodiscard]] constexpr bool cmp_less_equal(const _Ty1 _Left, const _Ty2 _Right) noexcept {
    return !::std:: cmp_less(_Right, _Left);
}

template <class _Ty1, class _Ty2>
[[nodiscard]] constexpr bool cmp_greater_equal(const _Ty1 _Left, const _Ty2 _Right) noexcept {
    return !::std:: cmp_less(_Left, _Right);
}

template <class _Ty>
[[nodiscard]] consteval _Ty _Min_limit() noexcept { 
    static_assert(_Is_standard_integer<_Ty>); 
    if constexpr (is_signed_v<_Ty>) {
        constexpr auto _Unsigned_max = static_cast<make_unsigned_t<_Ty>>(-1);
        return static_cast<_Ty>((_Unsigned_max >> 1) + 1); 
    } else {
        return 0;
    }
}

template <class _Ty>
[[nodiscard]] consteval _Ty _Max_limit() noexcept { 
    static_assert(_Is_standard_integer<_Ty>); 
    if constexpr (is_signed_v<_Ty>) {
        constexpr auto _Unsigned_max = static_cast<make_unsigned_t<_Ty>>(-1);
        return static_cast<_Ty>(_Unsigned_max >> 1);
    } else {
        return static_cast<_Ty>(-1);
    }
}

template <class _Rx, class _Ty>
[[nodiscard]] constexpr bool in_range(const _Ty _Value) noexcept {
    static_assert(_Is_standard_integer<_Rx> && _Is_standard_integer<_Ty>,
        "The integer comparison functions only accept standard and extended integer types.");

    constexpr auto _Ty_min = _Min_limit<_Ty>();
    constexpr auto _Rx_min = _Min_limit<_Rx>();

    if constexpr (::std:: cmp_less(_Ty_min, _Rx_min)) {
        if (_Value < _Ty{_Rx_min}) {
            return false;
        }
    }

    constexpr auto _Ty_max = _Max_limit<_Ty>();
    constexpr auto _Rx_max = _Max_limit<_Rx>();

    if constexpr (::std:: cmp_greater(_Ty_max, _Rx_max)) {
        if (_Value > _Ty{_Rx_max}) {
            return false;
        }
    }

    return true;
}
#line 747 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\utility"


template <class _Ty>
[[nodiscard]] constexpr underlying_type_t<_Ty> to_underlying(_Ty _Value) noexcept {
    return static_cast<underlying_type_t<_Ty>>(_Value);
}

[[noreturn]] inline void unreachable() noexcept  {
    __assume(false);


}
#line 761 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\utility"


#line 769 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\utility"

}


#pragma warning(pop)
#pragma pack(pop)
#line 777 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\utility"
#line 778 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\utility"
#line 19 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\any"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\new"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {

struct destroying_delete_t {
    explicit destroying_delete_t() = default;
};
inline constexpr destroying_delete_t destroying_delete{};
#line 28 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\new"


template <class _Ty>
[[nodiscard]] constexpr _Ty* launder(_Ty* _Ptr) noexcept {
    static_assert(!is_function_v<_Ty> && !is_void_v<_Ty>,
        "N4727 21.6.4 [ptr.launder]/3: The program is ill-formed if T is a function type or cv void.");
    return __builtin_launder(_Ptr);
}


inline constexpr size_t hardware_constructive_interference_size = 64;
inline constexpr size_t hardware_destructive_interference_size  = 64;


#line 43 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\new"

#line 45 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\new"


using new_handler = void(__cdecl*)();
#line 50 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\new"

 new_handler __cdecl set_new_handler(  new_handler) noexcept;
[[nodiscard]]  new_handler __cdecl get_new_handler() noexcept;
}


#pragma warning(pop)
#pragma pack(pop)

#line 61 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\new"
#line 62 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\new"
#line 15 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xatomic.h"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


#line 36 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xatomic.h"


#line 49 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xatomic.h"


namespace std {


enum class memory_order : int {
    relaxed,
    consume,
    acquire,
    release,
    acq_rel,
    seq_cst,

    
    memory_order_relaxed = relaxed,
    memory_order_consume = consume,
    memory_order_acquire = acquire,
    memory_order_release = release,
    memory_order_acq_rel = acq_rel,
    memory_order_seq_cst = seq_cst
};
inline constexpr memory_order memory_order_relaxed = memory_order::relaxed;
inline constexpr memory_order memory_order_consume = memory_order::consume;
inline constexpr memory_order memory_order_acquire = memory_order::acquire;
inline constexpr memory_order memory_order_release = memory_order::release;
inline constexpr memory_order memory_order_acq_rel = memory_order::acq_rel;
inline constexpr memory_order memory_order_seq_cst = memory_order::seq_cst;


#line 88 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xatomic.h"

using _Atomic_counter_t = unsigned long;

template <class _Integral, class _Ty>
[[nodiscard]] volatile _Integral* _Atomic_address_as(_Ty& _Source) noexcept {
    
    static_assert(is_integral_v<_Integral>, "Tried to reinterpret memory as non-integral");
    return &reinterpret_cast<volatile _Integral&>(_Source);
}

template <class _Integral, class _Ty>
[[nodiscard]] const volatile _Integral* _Atomic_address_as(const _Ty& _Source) noexcept {
    
    static_assert(is_integral_v<_Integral>, "Tried to reinterpret memory as non-integral");
    return &reinterpret_cast<const volatile _Integral&>(_Source);
}

}


#pragma warning(pop)
#pragma pack(pop)
#line 112 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xatomic.h"
#line 113 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xatomic.h"
#line 16 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cstring"


#pragma once


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"


#pragma once


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_memory.h"


#pragma once


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


 int __cdecl _memicmp(
      void const* _Buf1,
      void const* _Buf2,
                             size_t      _Size
    );

 
 int __cdecl _memicmp_l(
      void const* _Buf1,
      void const* _Buf2,
                             size_t      _Size,
                         _locale_t   _Locale
    );


#line 60 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_memory.h"

    
#line 75 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_memory.h"

#line 77 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_memory.h"


    __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_memccpy" ". See online help for details."))
     void* __cdecl memccpy(
          void*       _Dst,
            void const* _Src,
                                   int         _Val,
                                   size_t      _Size
        );

      __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_memicmp" ". See online help for details."))
     int __cdecl memicmp(
          void const* _Buf1,
          void const* _Buf2,
                                 size_t      _Size
        );

#line 98 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_memory.h"


    extern "C++"  
    inline void* __cdecl memchr(
          void*  _Pv,
                              int    _C,
                              size_t _N
        )
    {
        void const* const _Pvc = _Pv;
        return const_cast<void*>(memchr(_Pvc, _C, _N));
    }

#line 115 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_memory.h"


} __pragma(pack(pop))

#line 121 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_memory.h"

#pragma warning(pop) 
#line 14 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


     errno_t __cdecl strcpy_s(
          char*       _Destination,
                                  rsize_t     _SizeInBytes,
                                char const* _Source
        );

    
     errno_t __cdecl strcat_s(
          char*       _Destination,
                                     rsize_t     _SizeInBytes,
                                   char const* _Source
        );

    
     errno_t __cdecl strerror_s(
          char*  _Buffer,
                                  size_t _SizeInBytes,
                                  int    _ErrorNumber);

    
     errno_t __cdecl strncat_s(
          char*       _Destination,
                                     rsize_t     _SizeInBytes,
               char const* _Source,
                                     rsize_t     _MaxCount
        );

    
     errno_t __cdecl strncpy_s(
          char*       _Destination,
                                  rsize_t     _SizeInBytes,
            char const* _Source,
                                  rsize_t     _MaxCount
        );

     
     char*  __cdecl strtok_s(
                          char*       _String,
                                 char const* _Delimiter,
            char**      _Context
        );

#line 75 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"

 void* __cdecl _memccpy(
      void*       _Dst,
                                   void const* _Src,
                                   int         _Val,
                                   size_t      _MaxCount
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl strcat_s(char (&_Destination)[_Size],   char const* _Source) throw() { return strcat_s(_Destination, _Size, _Source); } }
#line 88 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"


    __declspec(deprecated("This function or variable may be unsafe. Consider using " "strcat_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  char* __cdecl strcat( char *_Destination,  char const* _Source);
#line 96 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"

#line 98 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"

 
int __cdecl strcmp(
      char const* _Str1,
      char const* _Str2
    );

 
 int __cdecl _strcmpi(
      char const* _String1,
      char const* _String2
    );

 
 int __cdecl strcoll(
      char const* _String1,
      char const* _String2
    );

 
 int __cdecl _strcoll_l(
        char const* _String1,
        char const* _String2,
      _locale_t   _Locale
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl strcpy_s(  char (&_Destination)[_Size],   char const* _Source) throw() { return strcpy_s(_Destination, _Size, _Source); } }
#line 129 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "strcpy_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  char* __cdecl strcpy( char *_Destination,  char const* _Source);
#line 135 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"

 
 size_t __cdecl strcspn(
      char const* _Str,
      char const* _Control
    );


#line 146 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"

 
 __declspec(allocator) char* __cdecl _strdup(
      char const* _Source
    );


#line 155 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"

 
  __declspec(deprecated("This function or variable may be unsafe. Consider using " "_strerror_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
 char*  __cdecl _strerror(
      char const* _ErrorMessage
    );


 errno_t __cdecl _strerror_s(
      char*       _Buffer,
                              size_t      _SizeInBytes,
                        char const* _ErrorMessage
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl _strerror_s(char (&_Buffer)[_Size],   char const* _ErrorMessage) throw() { return _strerror_s(_Buffer, _Size, _ErrorMessage); } }
#line 175 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"

 
  __declspec(deprecated("This function or variable may be unsafe. Consider using " "strerror_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
 char* __cdecl strerror(
      int _ErrorMessage
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl strerror_s(char (&_Buffer)[_Size],   int _ErrorMessage) throw() { return strerror_s(_Buffer, _Size, _ErrorMessage); } }
#line 187 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"

 
 int __cdecl _stricmp(
      char const* _String1,
      char const* _String2
    );

 
 int __cdecl _stricoll(
      char const* _String1,
      char const* _String2
    );

 
 int __cdecl _stricoll_l(
        char const* _String1,
        char const* _String2,
      _locale_t   _Locale
    );

 
 int __cdecl _stricmp_l(
        char const* _String1,
        char const* _String2,
      _locale_t   _Locale
    );

 
size_t __cdecl strlen(
      char const* _Str
    );


 errno_t __cdecl _strlwr_s(
      char*  _String,
                          size_t _Size
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl _strlwr_s(  char (&_String)[_Size]) throw() { return _strlwr_s(_String, _Size); } }
#line 229 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "_strlwr_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  char* __cdecl _strlwr( char *_String);
#line 234 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"


 errno_t __cdecl _strlwr_s_l(
      char*     _String,
                          size_t    _Size,
                      _locale_t _Locale
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl _strlwr_s_l(  char (&_String)[_Size],   _locale_t _Locale) throw() { return _strlwr_s_l(_String, _Size, _Locale); } }
#line 247 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "_strlwr_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  char* __cdecl _strlwr_l(  char *_String,   _locale_t _Locale);
#line 254 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"

extern "C++" { template <size_t _Size> inline errno_t __cdecl strncat_s(  char (&_Destination)[_Size],   char const* _Source,   size_t _Count) throw() { return strncat_s(_Destination, _Size, _Source, _Count); } }
#line 261 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "strncat_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  char* __cdecl strncat(  char *_Destination,   char const* _Source,   size_t _Count);
#line 269 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"

 
 int __cdecl strncmp(
      char const* _Str1,
      char const* _Str2,
                            size_t      _MaxCount
    );

 
 int __cdecl _strnicmp(
      char const* _String1,
      char const* _String2,
                            size_t      _MaxCount
    );

 
 int __cdecl _strnicmp_l(
      char const* _String1,
      char const* _String2,
                            size_t      _MaxCount,
                        _locale_t   _Locale
    );

 
 int __cdecl _strnicoll(
      char const* _String1,
      char const* _String2,
                            size_t      _MaxCount
    );

 
 int __cdecl _strnicoll_l(
      char const* _String1,
      char const* _String2,
                            size_t      _MaxCount,
                        _locale_t   _Locale
    );

 
 int __cdecl _strncoll(
      char const* _String1,
      char const* _String2,
                            size_t      _MaxCount
    );

 
 int __cdecl _strncoll_l(
      char const* _String1,
      char const* _String2,
                            size_t      _MaxCount,
                        _locale_t   _Locale
    );

 size_t __cdecl __strncnt(
      char const* _String,
                         size_t      _Count
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl strncpy_s(char (&_Destination)[_Size],   char const* _Source,   size_t _Count) throw() { return strncpy_s(_Destination, _Size, _Source, _Count); } }
#line 333 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "strncpy_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  char* __cdecl strncpy(    char *_Destination,   char const* _Source,   size_t _Count);
#line 341 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"

 
#line 347 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"

#line 351 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"
 size_t __cdecl strnlen(
      char const* _String,
                            size_t      _MaxCount
    );


#line 363 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"
    
#line 367 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"
    static __inline size_t __cdecl strnlen_s(
          char const* _String,
                                size_t      _MaxCount
        )
    {
        return _String == 0 ? 0 : strnlen(_String, _MaxCount);
    }

#line 376 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"


 errno_t __cdecl _strnset_s(
      char*  _String,
                                 size_t _SizeInBytes,
                                 int    _Value,
                                 size_t _MaxCount
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl _strnset_s(  char (&_Destination)[_Size],   int _Value,   size_t _Count) throw() { return _strnset_s(_Destination, _Size, _Value, _Count); } }
#line 391 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "_strnset_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  char* __cdecl _strnset(  char *_Destination,   int _Value,   size_t _Count);
#line 399 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"

 
 char const* __cdecl strpbrk(
      char const* _Str,
      char const* _Control
    );

 char* __cdecl _strrev(
      char* _Str
    );


 errno_t __cdecl _strset_s(
      char*  _Destination,
                                     size_t _DestinationSize,
                                     int    _Value
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl _strset_s(  char (&_Destination)[_Size],   int _Value) throw() { return _strset_s(_Destination, _Size, _Value); } }
#line 422 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "_strset_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  char* __cdecl _strset( char *_Destination,  int _Value);
#line 428 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"

 
 size_t __cdecl strspn(
      char const* _Str,
      char const* _Control
    );

  __declspec(deprecated("This function or variable may be unsafe. Consider using " "strtok_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
 char* __cdecl strtok(
      char*       _String,
             char const* _Delimiter
    );


 errno_t __cdecl _strupr_s(
      char*  _String,
                          size_t _Size
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl _strupr_s(  char (&_String)[_Size]) throw() { return _strupr_s(_String, _Size); } }
#line 451 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "_strupr_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  char* __cdecl _strupr( char *_String);
#line 456 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"


 errno_t __cdecl _strupr_s_l(
      char*     _String,
                          size_t    _Size,
                      _locale_t _Locale
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl _strupr_s_l(  char (&_String)[_Size],   _locale_t _Locale) throw() { return _strupr_s_l(_String, _Size, _Locale); } }
#line 469 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "_strupr_s_l" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  char* __cdecl _strupr_l(  char *_String,   _locale_t _Locale);
#line 476 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"

 
 size_t __cdecl strxfrm(
        char*       _Destination,
                                         char const* _Source,
                 size_t      _MaxCount
    );

 
 size_t __cdecl _strxfrm_l(
        char*       _Destination,
                                         char const* _Source,
                 size_t      _MaxCount,
                                       _locale_t   _Locale
    );


extern "C++"
{
     
    inline char* __cdecl strchr(  char* const _String,   int const _Ch)
    {
        return const_cast<char*>(strchr(static_cast<char const*>(_String), _Ch));
    }

     
    inline char* __cdecl strpbrk(  char* const _String,   char const* const _Control)
    {
        return const_cast<char*>(strpbrk(static_cast<char const*>(_String), _Control));
    }

     
    inline char* __cdecl strrchr(  char* const _String,   int const _Ch)
    {
        return const_cast<char*>(strrchr(static_cast<char const*>(_String), _Ch));
    }

       
    inline char* __cdecl strstr(  char* const _String,   char const* const _SubString)
    {
        return const_cast<char*>(strstr(static_cast<char const*>(_String), _SubString));
    }
}
#line 524 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"


      __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_strdup" ". See online help for details."))
     char* __cdecl strdup(
          char const* _String
        );
    

      __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_strcmpi" ". See online help for details."))
     int __cdecl strcmpi(
          char const* _String1,
          char const* _String2
        );

      __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_stricmp" ". See online help for details."))
     int __cdecl stricmp(
          char const* _String1,
          char const* _String2
        );

    __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_strlwr" ". See online help for details."))
     char* __cdecl strlwr(
          char* _String
        );

      __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_strnicmp" ". See online help for details."))
     int __cdecl strnicmp(
          char const* _String1,
          char const* _String2,
                                size_t      _MaxCount
        );

    __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_strnset" ". See online help for details."))
     char* __cdecl strnset(
          char*  _String,
                                  int    _Value,
                                  size_t _MaxCount
        );

    __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_strrev" ". See online help for details."))
     char* __cdecl strrev(
          char* _String
        );

    __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_strset" ". See online help for details."))
    char* __cdecl strset(
          char* _String,
               int   _Value);

    __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_strupr" ". See online help for details."))
     char* __cdecl strupr(
          char* _String
        );

#line 585 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"


} __pragma(pack(pop))

#pragma warning(pop) 
#line 592 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"
#line 593 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\string.h"
#line 13 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cstring"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
#pragma warning(push)
#pragma warning(disable : 4995) 

using :: size_t;
using :: memchr;
using :: memcmp;
using :: memcpy;
using :: memmove;
using :: memset;
using :: strcat;
using :: strchr;
using :: strcmp;
using :: strcoll;
using :: strcpy;
using :: strcspn;
using :: strerror;
using :: strlen;
using :: strncat;
using :: strncmp;
using :: strncpy;
using :: strpbrk;
using :: strrchr;
using :: strspn;
using :: strstr;
using :: strtok;
using :: strxfrm;

#pragma warning(pop)
}


#pragma warning(pop)
#pragma pack(pop)

#line 58 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cstring"
#line 59 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cstring"
#line 15 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


#line 28 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"


#line 35 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"


#line 41 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"


extern "C" {


__declspec(noalias) void __cdecl __std_reverse_trivially_swappable_1(void* _First, void* _Last) noexcept;
__declspec(noalias) void __cdecl __std_reverse_trivially_swappable_2(void* _First, void* _Last) noexcept;
__declspec(noalias) void __cdecl __std_reverse_trivially_swappable_4(void* _First, void* _Last) noexcept;
__declspec(noalias) void __cdecl __std_reverse_trivially_swappable_8(void* _First, void* _Last) noexcept;
__declspec(noalias) void __cdecl __std_swap_ranges_trivially_swappable_noalias(
    void* _First1, void* _Last1, void* _First2) noexcept;
}
#line 59 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

namespace std {

template <class _To, class _From,
    enable_if_t<conjunction_v<bool_constant<sizeof(_To) == sizeof(_From)>, is_trivially_copyable<_To>,
                    is_trivially_copyable<_From>>,
        int> = 0>
[[nodiscard]] constexpr _To _Bit_cast(const _From& _Val) noexcept {


    return __builtin_bit_cast(_To, _Val);
#line 74 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
}

template <class _Ty>
struct _Get_first_parameter;

template <template <class, class...> class _Ty, class _First, class... _Rest>
struct _Get_first_parameter<_Ty<_First, _Rest...>> { 
    using type = _First;
};

template <class _Newfirst, class _Ty>
struct _Replace_first_parameter;

template <class _Newfirst, template <class, class...> class _Ty, class _First, class... _Rest>
struct _Replace_first_parameter<_Newfirst, _Ty<_First, _Rest...>> { 
    using type = _Ty<_Newfirst, _Rest...>;
};

template <class _Ty, class = void>
struct _Get_element_type {
    using type = typename _Get_first_parameter<_Ty>::type;
};

template <class _Ty>
struct _Get_element_type<_Ty, void_t<typename _Ty::element_type>> {
    using type = typename _Ty::element_type;
};

template <class _Ty, class = void>
struct _Get_ptr_difference_type {
    using type = ptrdiff_t;
};

template <class _Ty>
struct _Get_ptr_difference_type<_Ty, void_t<typename _Ty::difference_type>> {
    using type = typename _Ty::difference_type;
};

template <class _Ty, class _Other, class = void>
struct _Get_rebind_alias {
    using type = typename _Replace_first_parameter<_Other, _Ty>::type;
};

template <class _Ty, class _Other>
struct _Get_rebind_alias<_Ty, _Other, void_t<typename _Ty::template rebind<_Other>>> {
    using type = typename _Ty::template rebind<_Other>;
};

template <class _Iter>
[[nodiscard]] constexpr void* _Voidify_iter(_Iter _It) noexcept {
    if constexpr (is_pointer_v<_Iter>) {
        return const_cast<void*>(static_cast<const volatile void*>(_It));
    } else {
        return const_cast<void*>(static_cast<const volatile void*>(::std:: addressof(*_It)));
    }
}


template <class _Ty, class... _Types,
    class = void_t<decltype(::new (::std:: declval<void*>()) _Ty(::std:: declval<_Types>()...))>>
constexpr _Ty* construct_at(_Ty* const _Location, _Types&&... _Args) noexcept(
    noexcept(::new (_Voidify_iter(_Location)) _Ty(::std:: forward<_Types>(_Args)...)))  {
    return ::new (_Voidify_iter(_Location)) _Ty(::std:: forward<_Types>(_Args)...);
}
#line 139 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class _Ty, class... _Types>
constexpr void _Construct_in_place(_Ty& _Obj, _Types&&... _Args) noexcept(
    is_nothrow_constructible_v<_Ty, _Types...>) {

    if (::std:: is_constant_evaluated()) {
        ::std:: construct_at(::std:: addressof(_Obj), ::std:: forward<_Types>(_Args)...);
    } else
#line 148 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
    {
        ::new (_Voidify_iter(::std:: addressof(_Obj))) _Ty(::std:: forward<_Types>(_Args)...);
    }
}

template <class _Ty>
void _Default_construct_in_place(_Ty& _Obj) noexcept(is_nothrow_default_constructible_v<_Ty>) {
    ::new (_Voidify_iter(::std:: addressof(_Obj))) _Ty;
}

template <class _Ty>
struct pointer_traits {
    using pointer         = _Ty;
    using element_type    = typename _Get_element_type<_Ty>::type;
    using difference_type = typename _Get_ptr_difference_type<_Ty>::type;

    template <class _Other>
    using rebind = typename _Get_rebind_alias<_Ty, _Other>::type;

    using _Reftype = conditional_t<is_void_v<element_type>, char, element_type>&;

    [[nodiscard]] static pointer pointer_to(_Reftype _Val) noexcept(noexcept(_Ty::pointer_to(_Val)))  {
        return _Ty::pointer_to(_Val);
    }
};

template <class _Ty>
struct pointer_traits<_Ty*> {
    using pointer         = _Ty*;
    using element_type    = _Ty;
    using difference_type = ptrdiff_t;

    template <class _Other>
    using rebind = _Other*;

    using _Reftype = conditional_t<is_void_v<_Ty>, char, _Ty>&;

    [[nodiscard]] static constexpr pointer pointer_to(_Reftype _Val) noexcept {
        return ::std:: addressof(_Val);
    }
};


template <class _Ty>
concept _Has_to_address = requires(const _Ty& _Val) {
    typename pointer_traits<_Ty>;
    pointer_traits<_Ty>::to_address(_Val);
};


#line 205 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class _Ty>
[[nodiscard]] constexpr _Ty* to_address(_Ty* const _Val) noexcept {
    static_assert(!is_function_v<_Ty>,
        "N4810 20.10.4 [pointer.conversion]/2: The program is ill-formed if T is a function type.");
    return _Val;
}

template <class _Ptr>
[[nodiscard]] constexpr auto to_address(const _Ptr& _Val) noexcept {
    if constexpr (_Has_to_address<_Ptr>) {
        return pointer_traits<_Ptr>::to_address(_Val);
    } else {
        return ::std:: to_address(_Val.operator->()); 
    }
}

struct identity {
    template <class _Ty>
    [[nodiscard]] constexpr _Ty&& operator()(_Ty&& _Left) const noexcept {
        return ::std:: forward<_Ty>(_Left);
    }

    using is_transparent = int;
};
#line 231 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"


template <class _Fx>
struct _Ref_fn { 
    template <class... _Args>
    constexpr decltype(auto) operator()(_Args&&... _Vals) { 
        if constexpr (is_member_pointer_v<_Fx>) {
            return ::std:: invoke(_Fn, ::std:: forward<_Args>(_Vals)...);
        } else {
            return _Fn(::std:: forward<_Args>(_Vals)...);
        }
    }

    _Fx& _Fn;
};

template <class _Fn>
inline constexpr bool _Pass_functor_by_value_v = conjunction_v<bool_constant<sizeof(_Fn) <= sizeof(void*)>,
    is_trivially_copy_constructible<_Fn>, is_trivially_destructible<_Fn>>;

template <class _Fn, enable_if_t<_Pass_functor_by_value_v<_Fn>, int> = 0> 
constexpr _Fn _Pass_fn(_Fn _Val) { 
    return _Val;
}

template <class _Fn, enable_if_t<!_Pass_functor_by_value_v<_Fn>, int> = 0>
constexpr _Ref_fn<_Fn> _Pass_fn(_Fn& _Val) { 
    return {_Val};
}

struct _Unused_parameter { 
    constexpr _Unused_parameter() noexcept = default;
    template <class _Ty>
    constexpr _Unused_parameter(_Ty&&) noexcept {}
};

using _Any_tag = _Unused_parameter; 

template <class _Ty>
using _Algorithm_int_t = conditional_t<is_integral_v<_Ty>, _Ty, ptrdiff_t>;


struct input_iterator_tag {};

struct output_iterator_tag {};

struct forward_iterator_tag : input_iterator_tag {};

struct bidirectional_iterator_tag : forward_iterator_tag {};

struct random_access_iterator_tag : bidirectional_iterator_tag {};


struct contiguous_iterator_tag : random_access_iterator_tag {};

template <class _Ty>
using _With_reference = _Ty&;

template <class _Ty>
concept _Can_reference = requires {
    typename _With_reference<_Ty>;
};

template <class _Ty>
concept _Dereferenceable = requires(_Ty& __t) {
    { *__t } -> _Can_reference;
};

template <class _Ty>
concept _Has_member_iterator_concept = requires {
    typename _Ty::iterator_concept;
};

template <class _Ty>
concept _Has_member_iterator_category = requires {
    typename _Ty::iterator_category;
};

template <class _Ty>
concept _Has_member_value_type = requires {
    typename _Ty::value_type;
};

template <class _Ty>
concept _Has_member_element_type = requires {
    typename _Ty::element_type;
};

template <class _Ty>
concept _Has_member_difference_type = requires {
    typename _Ty::difference_type;
};

template <class _Ty>
concept _Has_member_pointer = requires {
    typename _Ty::pointer;
};

template <class _Ty>
concept _Has_member_reference = requires {
    typename _Ty::reference;
};

template <class _Ty>
concept _Destructible_object = is_object_v<_Ty> && destructible<_Ty>;

template <class>
struct incrementable_traits {};


template <class _Ty>
    requires is_object_v<_Ty>
struct incrementable_traits<_Ty*> {
    using difference_type = ptrdiff_t;
};


template <class _Ty>
struct incrementable_traits<const _Ty> : incrementable_traits<_Ty> {};

template <_Has_member_difference_type _Ty>
struct incrementable_traits<_Ty> {
    using difference_type = typename _Ty::difference_type;
};

template <class _Ty>
concept _Can_difference = requires(const _Ty& __a, const _Ty& __b) {
    { __a - __b } -> integral;
};


template <class _Ty>
    requires (!_Has_member_difference_type<_Ty> && _Can_difference<_Ty>)
struct incrementable_traits<_Ty> {
    using difference_type = make_signed_t<decltype(::std:: declval<_Ty>() - ::std:: declval<_Ty>())>;
};


template <class _Ty>
concept _Is_from_primary = _Same_impl<typename _Ty::_From_primary, _Ty>;

template <class>
struct iterator_traits;

template <class _Ty>
using iter_difference_t = typename conditional_t<_Is_from_primary<iterator_traits<remove_cvref_t<_Ty>>>,
    incrementable_traits<remove_cvref_t<_Ty>>, iterator_traits<remove_cvref_t<_Ty>>>::difference_type;

template <class>
struct _Cond_value_type {};


template <class _Ty>
    requires is_object_v<_Ty>
struct _Cond_value_type<_Ty> {
    using value_type = remove_cv_t<_Ty>;
};


template <class>
struct indirectly_readable_traits {};

template <class _Ty>
struct indirectly_readable_traits<_Ty*> : _Cond_value_type<_Ty> {};


template <class _Ty>
    requires is_array_v<_Ty>
struct indirectly_readable_traits<_Ty> {
    using value_type = remove_cv_t<remove_extent_t<_Ty>>;
};


template <class _Ty>
struct indirectly_readable_traits<const _Ty> : indirectly_readable_traits<_Ty> {};

template <_Has_member_value_type _Ty>
struct indirectly_readable_traits<_Ty> : _Cond_value_type<typename _Ty::value_type> {};

template <_Has_member_element_type _Ty>
struct indirectly_readable_traits<_Ty> : _Cond_value_type<typename _Ty::element_type> {};


template <_Has_member_value_type _Ty>
    requires _Has_member_element_type<_Ty>
struct indirectly_readable_traits<_Ty> {};

template <_Has_member_value_type _Ty>
    requires _Has_member_element_type<_Ty>
        && same_as<remove_cv_t<typename _Ty::value_type>, remove_cv_t<typename _Ty::element_type>>
struct indirectly_readable_traits<_Ty> : _Cond_value_type<typename _Ty::value_type> {};


template <class _Ty>
using iter_value_t = typename conditional_t<_Is_from_primary<iterator_traits<remove_cvref_t<_Ty>>>,
    indirectly_readable_traits<remove_cvref_t<_Ty>>, iterator_traits<remove_cvref_t<_Ty>>>::value_type;

template <_Dereferenceable _Ty>
using iter_reference_t = decltype(*::std:: declval<_Ty&>());

template <class>
struct _Iterator_traits_base {};

template <class _It>
concept _Has_iter_types = _Has_member_difference_type<_It> && _Has_member_value_type<_It> 
    && _Has_member_reference<_It> && _Has_member_iterator_category<_It>;

template <bool _Has_member_typedef>
struct _Old_iter_traits_pointer {
    template <class _It>
    using _Apply = typename _It::pointer;
};

template <>
struct _Old_iter_traits_pointer<false> {
    template <class>
    using _Apply = void;
};

template <_Has_iter_types _It>
struct _Iterator_traits_base<_It> {
    using iterator_category = typename _It::iterator_category;
    using value_type        = typename _It::value_type;
    using difference_type   = typename _It::difference_type;
    using pointer           = typename _Old_iter_traits_pointer<_Has_member_pointer<_It>>::template _Apply<_It>;
    using reference         = typename _It::reference;
};

template <bool _Has_member_typedef>
struct _Iter_traits_difference {
    template <class _It>
    using _Apply = typename incrementable_traits<_It>::difference_type;
};

template <>
struct _Iter_traits_difference<false> {
    template <class>
    using _Apply = void;
};


template <class _It>
concept _Cpp17_iterator =
    requires(_It __i) {
        { *__i } -> _Can_reference;
        { ++__i } -> same_as<_It&>;
        { *__i++ } -> _Can_reference;
    }
    && copyable<_It>;

template <class _It>
concept _Cpp17_input_iterator = _Cpp17_iterator<_It>
    && equality_comparable<_It>
    && _Has_member_difference_type<incrementable_traits<_It>>
    && _Has_member_value_type<indirectly_readable_traits<_It>>
    && requires(_It __i) {
        typename common_reference_t<iter_reference_t<_It>&&, typename indirectly_readable_traits<_It>::value_type&>;
        typename common_reference_t<decltype(*__i++)&&, typename indirectly_readable_traits<_It>::value_type&>;
        requires signed_integral<typename incrementable_traits<_It>::difference_type>;
    };

template <class _It>
    requires (!_Has_iter_types<_It> && _Cpp17_iterator<_It> && !_Cpp17_input_iterator<_It>)
struct _Iterator_traits_base<_It> {
    using iterator_category = output_iterator_tag;
    using value_type = void;
    using difference_type =
        typename _Iter_traits_difference<_Has_member_difference_type<incrementable_traits<_It>>>::template _Apply<_It>;
    using pointer    = void;
    using reference  = void;
};


enum class _Itraits_pointer_strategy { _Use_void, _Use_member, _Use_decltype };

template <_Itraits_pointer_strategy>
struct _Iter_traits_pointer;

template <>
struct _Iter_traits_pointer<_Itraits_pointer_strategy::_Use_void> {
    template <class>
    using _Apply = void;
};

template <>
struct _Iter_traits_pointer<_Itraits_pointer_strategy::_Use_member> {
    template <class _It>
    using _Apply = typename _It::pointer;
};

template <>
struct _Iter_traits_pointer<_Itraits_pointer_strategy::_Use_decltype> {
    template <class _It>
    using _Apply = decltype(::std:: declval<_It&>().operator->());
};

template <class _Ty>
concept _Has_member_arrow = requires(_Ty&& __t) {
    static_cast<_Ty&&>(__t).operator->();
};

template <bool _Has_member_typedef>
struct _Iter_traits_reference {
    template <class _It>
    using _Apply = typename _It::reference;
};

template <>
struct _Iter_traits_reference<false> {
    template <class _It>
    using _Apply = iter_reference_t<_It>;
};

template <bool _Is_random>
struct _Iter_traits_category4 {
    using type = random_access_iterator_tag;
};

template <>
struct _Iter_traits_category4<false> {
    using type = bidirectional_iterator_tag;
};


template <class _It>
concept _Cpp17_random_delta = totally_ordered<_It>
    && requires(_It __i, typename incrementable_traits<_It>::difference_type __n) {
        { __i += __n } -> same_as<_It&>;
        { __i -= __n } -> same_as<_It&>;
        { __i +  __n } -> same_as<_It>;
        { __n +  __i } -> same_as<_It>;
        { __i -  __n } -> same_as<_It>;
        { __i -  __i } -> same_as<decltype(__n)>;
        {  __i[__n]  } -> convertible_to<iter_reference_t<_It>>;
    };


template <bool _Is_bidi>
struct _Iter_traits_category3 {
    template <class _It>
    using _Apply = typename _Iter_traits_category4<_Cpp17_random_delta<_It>>::type;
};

template <>
struct _Iter_traits_category3<false> {
    template <class>
    using _Apply = forward_iterator_tag;
};

template <class _It>
concept _Cpp17_bidi_delta = requires(_It __i) {
    { --__i } -> same_as<_It&>;
    { __i-- } -> convertible_to<const _It&>;
    requires same_as<decltype(*__i--), iter_reference_t<_It>>;
};

template <bool _Is_forward>
struct _Iter_traits_category2 {
    template <class _It>
    using _Apply = typename _Iter_traits_category3<_Cpp17_bidi_delta<_It>>::template _Apply<_It>;
};

template <>
struct _Iter_traits_category2<false> {
    template <class>
    using _Apply = input_iterator_tag;
};


template <class _It>
concept _Cpp17_forward_delta = constructible_from<_It> && is_lvalue_reference_v<iter_reference_t<_It>>
    && same_as<remove_cvref_t<iter_reference_t<_It>>, typename indirectly_readable_traits<_It>::value_type>
    && requires(_It __i) {
        { __i++ } -> convertible_to<const _It&>;
        requires same_as<decltype(*__i++), iter_reference_t<_It>>;
    };


template <bool _Has_member_typedef>
struct _Iter_traits_category {
    template <class _It>
    using _Apply = typename _It::iterator_category;
};

template <>
struct _Iter_traits_category<false> {
    template <class _It>
    using _Apply = typename _Iter_traits_category2<_Cpp17_forward_delta<_It>>::template _Apply<_It>;
};


template <class _It>
    requires (!_Has_iter_types<_It> && _Cpp17_input_iterator<_It>)
struct _Iterator_traits_base<_It> {
    using iterator_category = typename _Iter_traits_category<_Has_member_iterator_category<_It>>::template _Apply<_It>;
    using value_type        = typename indirectly_readable_traits<_It>::value_type;
    using difference_type   = typename incrementable_traits<_It>::difference_type;
    using pointer           = typename _Iter_traits_pointer<(
        _Has_member_pointer<_It> ? _Itraits_pointer_strategy::_Use_member
                                 : _Has_member_arrow<_It&> ? _Itraits_pointer_strategy::_Use_decltype
                                                       : _Itraits_pointer_strategy::_Use_void)>::template _Apply<_It>;
    using reference         = typename _Iter_traits_reference<_Has_member_reference<_It>>::template _Apply<_It>;
};


template <class _Ty>
struct iterator_traits : _Iterator_traits_base<_Ty> {
    using _From_primary = iterator_traits;
};


template <class _Ty>
    requires is_object_v<_Ty>
struct iterator_traits<_Ty*> {
    
    using iterator_concept  = contiguous_iterator_tag;
    using iterator_category = random_access_iterator_tag;
    using value_type        = remove_cv_t<_Ty>;
    using difference_type   = ptrdiff_t;
    using pointer           = _Ty*;
    using reference         = _Ty&;
};

namespace ranges {
    namespace _Iter_move {
        void iter_move(); 

        
        template <class _Ty>
        concept _Has_ADL = _Has_class_or_enum_type<_Ty> && requires(_Ty&& __t) {
            iter_move(static_cast<_Ty&&>(__t));
        };

        template <class _Ty>
        concept _Can_deref = requires(_Ty&& __t) {
            *static_cast<_Ty&&>(__t);
        };

        class _Cpo {
        private:
            enum class _St { _None, _Custom, _Fallback };

            template <class _Ty>
            [[nodiscard]] static consteval _Choice_t<_St> _Choose() noexcept {
                if constexpr (_Has_ADL<_Ty>) {
                    return {_St::_Custom, noexcept(iter_move(::std:: declval<_Ty>()))};
                } else if constexpr (_Can_deref<_Ty>) {
                    return {_St::_Fallback, noexcept(*::std:: declval<_Ty>())};
                } else {
                    return {_St::_None};
                }
            }

            template <class _Ty>
            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty>();

        public:
            template <class _Ty>
                requires (_Choice<_Ty>._Strategy != _St::_None)
            [[nodiscard]] constexpr decltype(auto) operator()(_Ty&& _Val) const noexcept(_Choice<_Ty>._No_throw) {
                constexpr _St _Strat = _Choice<_Ty>._Strategy;

                if constexpr (_Strat == _St::_Custom) {
                    return iter_move(static_cast<_Ty&&>(_Val));
                } else if constexpr (_Strat == _St::_Fallback) {
                    using _Ref = decltype(*static_cast<_Ty&&>(_Val));
                    if constexpr (is_lvalue_reference_v<_Ref>) {
                        return ::std:: move(*static_cast<_Ty&&>(_Val));
                    } else {
                        return *static_cast<_Ty&&>(_Val);
                    }
                } else {
                    static_assert(_Always_false<_Ty>, "should be unreachable");
                }
            }
        };
        
    } 

    inline namespace _Cpos {
        inline constexpr _Iter_move::_Cpo iter_move;
    }
} 


template <class _Ty>
    requires _Dereferenceable<_Ty> && requires(_Ty& __t) {
        { ::std::ranges:: iter_move(__t) } -> _Can_reference;
    }
using iter_rvalue_reference_t = decltype(::std::ranges:: iter_move(::std:: declval<_Ty&>()));

template <class _It>
concept _Indirectly_readable_impl = requires(const _It __i) {
    typename iter_value_t<_It>;
    typename iter_reference_t<_It>;
    typename iter_rvalue_reference_t<_It>;
    { *__i } -> same_as<iter_reference_t<_It>>;
    { ::std::ranges:: iter_move(__i) } -> same_as<iter_rvalue_reference_t<_It>>;
} && common_reference_with<iter_reference_t<_It>&&, iter_value_t<_It>&>
  && common_reference_with<iter_reference_t<_It>&&, iter_rvalue_reference_t<_It>&&>
  && common_reference_with<iter_rvalue_reference_t<_It>&&, const iter_value_t<_It>&>;

template <class _It>
concept indirectly_readable = _Indirectly_readable_impl<remove_cvref_t<_It>>;


template <indirectly_readable _Ty>
using iter_common_reference_t = common_reference_t<iter_reference_t<_Ty>, iter_value_t<_Ty>&>;

template <class _It, class _Ty>
concept indirectly_writable = requires(_It&& __i, _Ty&& __t) {
    *__i                                                                = static_cast<_Ty&&>(__t);
    *static_cast<_It&&>(__i)                                            = static_cast<_Ty&&>(__t);
    const_cast<const iter_reference_t<_It>&&>(*__i)                     = static_cast<_Ty&&>(__t);
    const_cast<const iter_reference_t<_It>&&>(*static_cast<_It&&>(__i)) = static_cast<_Ty&&>(__t);
};

template <class _Ty>
inline constexpr bool _Integer_class = requires {
    typename _Ty::_Signed_type;
    typename _Ty::_Unsigned_type;
};

template <class _Ty>
concept _Integer_like = _Is_nonbool_integral<remove_cv_t<_Ty>> || _Integer_class<_Ty>;

template <class _Ty>
concept _Signed_integer_like = _Integer_like<_Ty> && static_cast<_Ty>(-1) < static_cast<_Ty>(0);

template <bool _Is_integer_class>
struct _Make_unsigned_like_impl {
    template <class _Ty>
    using _Apply = typename _Ty::_Unsigned_type;
};
template <>
struct _Make_unsigned_like_impl<false> {
    template <class _Ty>
    using _Apply = make_unsigned_t<_Ty>;
};

template <class _Ty>
using _Make_unsigned_like_t = typename _Make_unsigned_like_impl<_Integer_class<_Ty>>::template _Apply<_Ty>;

template <_Integer_like _Ty>
[[nodiscard]] constexpr auto _To_unsigned_like(const _Ty _Value) noexcept {
    return static_cast<_Make_unsigned_like_t<_Ty>>(_Value);
}

template <bool _Is_integer_class>
struct _Make_signed_like_impl {
    template <class _Ty>
    using _Apply = typename _Ty::_Signed_type;
};
template <>
struct _Make_signed_like_impl<false> {
    template <class _Ty>
    using _Apply = make_signed_t<_Ty>;
};

template <class _Ty>
using _Make_signed_like_t = typename _Make_signed_like_impl<_Integer_class<_Ty>>::template _Apply<_Ty>;

template <_Integer_like _Ty>
[[nodiscard]] constexpr auto _To_signed_like(const _Ty _Value) noexcept {
    return static_cast<_Make_signed_like_t<_Ty>>(_Value);
}


template <class _Ty>
concept weakly_incrementable = movable<_Ty>
    && requires(_Ty __i) {
        typename iter_difference_t<_Ty>;
        requires _Signed_integer_like<iter_difference_t<_Ty>>;
        { ++__i } -> same_as<_Ty&>;
        __i++;
    }


    ;

template <class _Ty>
concept incrementable = regular<_Ty> && weakly_incrementable<_Ty> && requires(_Ty __t) {
    { __t++ } -> same_as<_Ty>;
};

template <class _It>
concept input_or_output_iterator = requires(_It __i) { { *__i } -> _Can_reference; }
    && weakly_incrementable<_It>;

template <class _Se, class _It>
concept sentinel_for = semiregular<_Se>
    && input_or_output_iterator<_It>
    && _Weakly_equality_comparable_with<_Se, _It>;


template <class _Se, class _It>
inline constexpr bool disable_sized_sentinel_for = false;


template <class _Se, class _It>
concept sized_sentinel_for = sentinel_for<_Se, _It>
    && !disable_sized_sentinel_for<remove_cv_t<_Se>, remove_cv_t<_It>>
    && requires(const _It& __i, const _Se& __s) {
        { __s - __i } -> same_as<iter_difference_t<_It>>;
        { __i - __s } -> same_as<iter_difference_t<_It>>;
    };


template <bool _Iterator_category_present>
struct _Iter_concept_impl2 {
    template <class _It, class _Traits>
    using _Apply = typename _Traits::iterator_category;
};
template <>
struct _Iter_concept_impl2<false> {
    
    template <class _It, class _Traits>
        requires _Is_from_primary<iterator_traits<_It>>
    using _Apply = random_access_iterator_tag;
    
};

template <bool _Iterator_concept_present>
struct _Iter_concept_impl1 {
    template <class _It, class _Traits>
    using _Apply = typename _Traits::iterator_concept;
};
template <>
struct _Iter_concept_impl1<false> {
    template <class _It, class _Traits>
    using _Apply = typename _Iter_concept_impl2<_Has_member_iterator_category<_Traits>>::template _Apply<_It, _Traits>;
};

template <class _It, class _Traits = conditional_t<_Is_from_primary<iterator_traits<_It>>, _It, iterator_traits<_It>>>
using _Iter_concept =
    typename _Iter_concept_impl1<_Has_member_iterator_concept<_Traits>>::template _Apply<_It, _Traits>;


template <class _It>
concept input_iterator = input_or_output_iterator<_It> && indirectly_readable<_It>
    && requires { typename _Iter_concept<_It>; }
    && derived_from<_Iter_concept<_It>, input_iterator_tag>;

template <class _It, class _Ty>
concept output_iterator = input_or_output_iterator<_It> && indirectly_writable<_It, _Ty>
    && requires(_It __i, _Ty&& __t) {
        *__i++ = static_cast<_Ty&&>(__t);
    };

template <class _It>
concept forward_iterator = input_iterator<_It> && derived_from<_Iter_concept<_It>, forward_iterator_tag>
    && incrementable<_It> && sentinel_for<_It, _It>;

template <class _It>
concept bidirectional_iterator = forward_iterator<_It> && derived_from<_Iter_concept<_It>, bidirectional_iterator_tag>
    && requires(_It __i) {
        { --__i } -> same_as<_It&>;
        { __i-- } -> same_as<_It>;
    };

template <class _It>
concept random_access_iterator = bidirectional_iterator<_It>
    && derived_from<_Iter_concept<_It>, random_access_iterator_tag> && totally_ordered<_It>
    && sized_sentinel_for<_It, _It> && requires(_It __i, const _It __j, const iter_difference_t<_It> __n) {
        { __i += __n } -> same_as<_It&>;
        { __j + __n } -> same_as<_It>;
        { __n + __j } -> same_as<_It>;
        { __i -= __n } -> same_as<_It&>;
        { __j - __n } -> same_as<_It>;
        { __j[__n] } -> same_as<iter_reference_t<_It>>;
    };

template <class _It>
concept contiguous_iterator = random_access_iterator<_It>
    && derived_from<_Iter_concept<_It>, contiguous_iterator_tag>
    && is_lvalue_reference_v<iter_reference_t<_It>>
    && same_as<iter_value_t<_It>, remove_cvref_t<iter_reference_t<_It>>>
    && requires(const _It& __i) {
        { ::std:: to_address(__i) } -> same_as<add_pointer_t<iter_reference_t<_It>>>;
    };

template <class _Fn, class _It>
concept indirectly_unary_invocable = indirectly_readable<_It>
    && copy_constructible<_Fn>
    && invocable<_Fn&, iter_value_t<_It>&>
    && invocable<_Fn&, iter_reference_t<_It>>
    && invocable<_Fn&, iter_common_reference_t<_It>>
    && common_reference_with<
        invoke_result_t<_Fn&, iter_value_t<_It>&>,
        invoke_result_t<_Fn&, iter_reference_t<_It>>>;

template <class _Fn, class _It>
concept indirectly_regular_unary_invocable = indirectly_readable<_It>
    && copy_constructible<_Fn>
    && regular_invocable<_Fn&, iter_value_t<_It>&>
    && regular_invocable<_Fn&, iter_reference_t<_It>>
    && regular_invocable<_Fn&, iter_common_reference_t<_It>>
    && common_reference_with<
        invoke_result_t<_Fn&, iter_value_t<_It>&>,
        invoke_result_t<_Fn&, iter_reference_t<_It>>>;

template <class _Fn, class _It>
concept indirect_unary_predicate = indirectly_readable<_It>
    && copy_constructible<_Fn>
    && predicate<_Fn&, iter_value_t<_It>&>
    && predicate<_Fn&, iter_reference_t<_It>>
    && predicate<_Fn&, iter_common_reference_t<_It>>;

template <class _Fn, class _It1, class _It2>
concept indirect_binary_predicate = indirectly_readable<_It1>
    && indirectly_readable<_It2>
    && copy_constructible<_Fn>
    && predicate<_Fn&, iter_value_t<_It1>&, iter_value_t<_It2>&>
    && predicate<_Fn&, iter_value_t<_It1>&, iter_reference_t<_It2>>
    && predicate<_Fn&, iter_reference_t<_It1>, iter_value_t<_It2>&>
    && predicate<_Fn&, iter_reference_t<_It1>, iter_reference_t<_It2>>
    && predicate<_Fn&, iter_common_reference_t<_It1>, iter_common_reference_t<_It2>>;

template <class _Fn, class _It1, class _It2 = _It1>
concept indirect_equivalence_relation = indirectly_readable<_It1>
    && indirectly_readable<_It2>
    && copy_constructible<_Fn>
    && equivalence_relation<_Fn&, iter_value_t<_It1>&, iter_value_t<_It2>&>
    && equivalence_relation<_Fn&, iter_value_t<_It1>&, iter_reference_t<_It2>>
    && equivalence_relation<_Fn&, iter_reference_t<_It1>, iter_value_t<_It2>&>
    && equivalence_relation<_Fn&, iter_reference_t<_It1>, iter_reference_t<_It2>>
    && equivalence_relation<_Fn&, iter_common_reference_t<_It1>, iter_common_reference_t<_It2>>;

template <class _Fn, class _It1, class _It2 = _It1>
concept indirect_strict_weak_order = indirectly_readable<_It1>
    && indirectly_readable<_It2>
    && copy_constructible<_Fn>
    && strict_weak_order<_Fn&, iter_value_t<_It1>&, iter_value_t<_It2>&>
    && strict_weak_order<_Fn&, iter_value_t<_It1>&, iter_reference_t<_It2>>
    && strict_weak_order<_Fn&, iter_reference_t<_It1>, iter_value_t<_It2>&>
    && strict_weak_order<_Fn&, iter_reference_t<_It1>, iter_reference_t<_It2>>
    && strict_weak_order<_Fn&, iter_common_reference_t<_It1>, iter_common_reference_t<_It2>>;

template <class _Fn, class... _Its>
    requires (indirectly_readable<_Its> && ...)
        && invocable<_Fn, iter_reference_t<_Its>...>
using indirect_result_t = invoke_result_t<_Fn, iter_reference_t<_Its>...>;


#pragma warning(push)
#pragma warning(disable : 5046) 


template <indirectly_readable _It, indirectly_regular_unary_invocable<_It> _Proj>
struct projected {
    using value_type = remove_cvref_t<indirect_result_t<_Proj&, _It>>;


#line 991 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
    indirect_result_t<_Proj&, _It> operator*() const {
        :: abort(); 
    }
#line 995 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
};


#pragma warning(pop)

template <weakly_incrementable _It, class _Proj>
struct incrementable_traits<projected<_It, _Proj>> {
    using difference_type = iter_difference_t<_It>;
};

template <class _In, class _Out>
concept indirectly_movable = indirectly_readable<_In> && indirectly_writable<_Out, iter_rvalue_reference_t<_In>>;


template <class _In, class _Out>
concept indirectly_movable_storable = indirectly_movable<_In, _Out>
    && indirectly_writable<_Out, iter_value_t<_In>>
    && movable<iter_value_t<_In>>
    && constructible_from<iter_value_t<_In>, iter_rvalue_reference_t<_In>>
    && assignable_from<iter_value_t<_In>&, iter_rvalue_reference_t<_In> >;


template <class _In, class _Out>
concept indirectly_copyable = indirectly_readable<_In> && indirectly_writable<_Out, iter_reference_t<_In>>;


template <class _In, class _Out>
concept indirectly_copyable_storable = indirectly_copyable<_In, _Out>
    && indirectly_writable<_Out, iter_value_t<_In>&>
    && indirectly_writable<_Out, const iter_value_t<_In>&>
    && indirectly_writable<_Out, iter_value_t<_In>&&>
    && indirectly_writable<_Out, const iter_value_t<_In>&&>
    && copyable<iter_value_t<_In>>
    && constructible_from<iter_value_t<_In>, iter_reference_t<_In>>
    && assignable_from<iter_value_t<_In>&, iter_reference_t<_In>>;


namespace ranges {
    namespace _Iter_swap {
        template <class _Ty1, class _Ty2>
        void iter_swap(_Ty1, _Ty2) = delete;

        
        template <class _Ty1, class _Ty2>
        concept _Has_ADL = (_Has_class_or_enum_type<_Ty1> || _Has_class_or_enum_type<_Ty2>)
            && requires(_Ty1&& __t1, _Ty2&& __t2) {
                iter_swap(static_cast<_Ty1&&>(__t1), static_cast<_Ty2&&>(__t2));
            };

        template <class _Ty1, class _Ty2>
        concept _Can_swap_references = indirectly_readable<remove_reference_t<_Ty1>>
            && indirectly_readable<remove_reference_t<_Ty2>>
            && swappable_with<iter_reference_t<_Ty1>, iter_reference_t<_Ty2>>;

        template <class _Ty1, class _Ty2>
        concept _Symmetric_indirectly_movable_storable =
               indirectly_movable_storable<remove_reference_t<_Ty1>, remove_reference_t<_Ty2>>
            && indirectly_movable_storable<remove_reference_t<_Ty2>, remove_reference_t<_Ty1>>;
        

        template <class _Xty, class _Yty>
        [[nodiscard]] constexpr iter_value_t<remove_reference_t<_Xty>> _Iter_exchange_move(_Xty&& _XVal,
            _Yty&& _YVal) noexcept(noexcept(iter_value_t<remove_reference_t<_Xty>>(::std::ranges:: iter_move(_XVal)))) {
            iter_value_t<remove_reference_t<_Xty>> _Tmp(::std::ranges:: iter_move(_XVal));
            *_XVal = ::std::ranges:: iter_move(_YVal);
            return _Tmp;
        }

        class _Cpo {
        private:
            enum class _St { _None, _Custom, _Swap, _Exchange };

            template <class _Ty1, class _Ty2>
            [[nodiscard]] static consteval _Choice_t<_St> _Choose() noexcept {
                if constexpr (_Has_ADL<_Ty1, _Ty2>) {
                    return {_St::_Custom, noexcept(iter_swap(::std:: declval<_Ty1>(), ::std:: declval<_Ty2>()))};
                } else if constexpr (_Can_swap_references<_Ty1, _Ty2>) {
                    return {_St::_Swap, noexcept(::std::ranges:: swap(*::std:: declval<_Ty1>(), *::std:: declval<_Ty2>()))};
                } else if constexpr (_Symmetric_indirectly_movable_storable<_Ty1, _Ty2>) {
                    constexpr auto _Nothrow = noexcept(
                        *::std:: declval<_Ty1>() = _Iter_exchange_move(::std:: declval<_Ty2>(), ::std:: declval<_Ty1>()));
                    return {_St::_Exchange, _Nothrow};
                } else {
                    return {_St::_None};
                }
            }

            template <class _Ty1, class _Ty2>
            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty1, _Ty2>();

        public:
            
            template <class _Ty1, class _Ty2>
                requires (_Choice<_Ty1, _Ty2>._Strategy != _St::_None)
            constexpr void operator()(_Ty1&& _Val1, _Ty2&& _Val2) const noexcept(_Choice<_Ty1, _Ty2>._No_throw) {
                constexpr _St _Strat = _Choice<_Ty1, _Ty2>._Strategy;

                if constexpr (_Strat == _St::_Custom) {
                    (void) iter_swap(static_cast<_Ty1&&>(_Val1), static_cast<_Ty2&&>(_Val2));
                } else if constexpr (_Strat == _St::_Swap) {
                    ::std::ranges:: swap(*static_cast<_Ty1&&>(_Val1), *static_cast<_Ty2&&>(_Val2));
                } else if constexpr (_Strat == _St::_Exchange) {
                    *static_cast<_Ty1&&>(_Val1) =
                        _Iter_exchange_move(static_cast<_Ty2&&>(_Val2), static_cast<_Ty1&&>(_Val1));
                } else {
                    static_assert(_Always_false<_Ty1>, "should be unreachable");
                }
            }
            
        };
    } 

    inline namespace _Cpos {
        inline constexpr _Iter_swap::_Cpo iter_swap;
    }
} 


template <class _It1, class _It2 = _It1>
concept indirectly_swappable = indirectly_readable<_It1> && indirectly_readable<_It2>
    && requires(const _It1 __i1, const _It2 __i2) {
        ::std::ranges:: iter_swap(__i1, __i1);
        ::std::ranges:: iter_swap(__i2, __i2);
        ::std::ranges:: iter_swap(__i1, __i2);
        ::std::ranges:: iter_swap(__i2, __i1);
    };

template <class _It1, class _It2, class _Rel, class _Proj1 = identity, class _Proj2 = identity>
concept indirectly_comparable =
    indirect_binary_predicate<_Rel,
        projected<_It1, _Proj1>,
        projected<_It2, _Proj2>>;

template <class _It>
concept permutable = forward_iterator<_It>
    && indirectly_movable_storable<_It, _It>
    && indirectly_swappable<_It, _It>;

namespace ranges { struct less; }
template <class _It1, class _It2, class _Out, class _Pr = ranges::less, class _Pj1 = identity, class _Pj2 = identity>
concept mergeable = input_iterator<_It1> && input_iterator<_It2>
    && weakly_incrementable<_Out>
    && indirectly_copyable<_It1, _Out>
    && indirectly_copyable<_It2, _Out>
    && indirect_strict_weak_order<_Pr, projected<_It1, _Pj1>, projected<_It2, _Pj2>>;


template <class _It, class _Pr = ranges::less, class _Proj = identity>
concept sortable = permutable<_It> && indirect_strict_weak_order<_Pr, projected<_It, _Proj>>;

template <class _Iter>
using _Iter_ref_t = iter_reference_t<_Iter>;

template <class _Iter>
using _Iter_value_t = iter_value_t<_Iter>;

template <class _Iter>
using _Iter_diff_t = iter_difference_t<_Iter>;


#line 1199 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class... _Iters>
using _Common_diff_t = common_type_t<_Iter_diff_t<_Iters>...>;

template <class _Iter>
using _Iter_cat_t = typename iterator_traits<_Iter>::iterator_category;

template <class _Ty, class = void>
inline constexpr bool _Is_iterator_v = false;

template <class _Ty>
inline constexpr bool _Is_iterator_v<_Ty, void_t<_Iter_cat_t<_Ty>>> = true;

template <class _Ty>
struct _Is_iterator : bool_constant<_Is_iterator_v<_Ty>> {};

template <class _Iter>
inline constexpr bool _Is_input_iter_v = is_convertible_v<_Iter_cat_t<_Iter>, input_iterator_tag>;

template <class _Iter>
inline constexpr bool _Is_fwd_iter_v = is_convertible_v<_Iter_cat_t<_Iter>, forward_iterator_tag>;

template <class _Iter>
inline constexpr bool _Is_bidi_iter_v = is_convertible_v<_Iter_cat_t<_Iter>, bidirectional_iterator_tag>;

template <class _Iter>
inline constexpr bool _Is_random_iter_v = is_convertible_v<_Iter_cat_t<_Iter>, random_access_iterator_tag>;

template <class, class = void>
struct _Is_checked_helper {}; 


#line 1237 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class _Iter, class = void>
inline constexpr bool _Allow_inheriting_unwrap_v = true;

template <class _Iter>
inline constexpr bool _Allow_inheriting_unwrap_v<_Iter, void_t<typename _Iter::_Prevent_inheriting_unwrap>> =
    is_same_v<_Iter, typename _Iter::_Prevent_inheriting_unwrap>;

template <class _Iter, class _Sentinel = _Iter, class = void>
inline constexpr bool _Range_verifiable_v = false;

template <class _Iter, class _Sentinel>
inline constexpr bool _Range_verifiable_v<_Iter, _Sentinel,
    void_t<decltype(_Verify_range(::std:: declval<const _Iter&>(), ::std:: declval<const _Sentinel&>()))>> =
    _Allow_inheriting_unwrap_v<_Iter>;

template <class _Iter, class _Sentinel>
constexpr void _Adl_verify_range(const _Iter& _First, const _Sentinel& _Last) {
    
    if constexpr (_Range_verifiable_v<_Iter, _Sentinel>) {
        _Verify_range(_First, _Last);
    }
}

template <class _Iter, class = void>
inline constexpr bool _Unwrappable_v = false;

template <class _Iter>
inline constexpr bool _Unwrappable_v<_Iter,
    void_t<decltype(::std:: declval<_Remove_cvref_t<_Iter>&>()._Seek_to(::std:: declval<_Iter>()._Unwrapped()))>> =
    _Allow_inheriting_unwrap_v<_Remove_cvref_t<_Iter>>;

template <class _Iter>
[[nodiscard]] constexpr decltype(auto) _Get_unwrapped(_Iter&& _It) {
    
    if constexpr (is_pointer_v<decay_t<_Iter>>) { 
        return _It + 0;
    } else if constexpr (_Unwrappable_v<_Iter>) {
        return static_cast<_Iter&&>(_It)._Unwrapped();
    } else {
        return static_cast<_Iter&&>(_It);
    }
}

template <class _Iter>
using _Unwrapped_t = _Remove_cvref_t<decltype(_Get_unwrapped(::std:: declval<_Iter>()))>;

template <class _Iter, class = bool>
inline constexpr bool _Do_unwrap_when_unverified_v = false;

template <class _Iter>
inline constexpr bool
    _Do_unwrap_when_unverified_v<_Iter, decltype(static_cast<bool>(_Iter::_Unwrap_when_unverified))> =
        static_cast<bool>(_Iter::_Unwrap_when_unverified);

template <class _Iter>
inline constexpr bool _Unwrappable_for_unverified_v =
    _Unwrappable_v<_Iter>&& _Do_unwrap_when_unverified_v<_Remove_cvref_t<_Iter>>;

template <class _Iter>
[[nodiscard]] constexpr decltype(auto) _Get_unwrapped_unverified(_Iter&& _It) {
    
    if constexpr (is_pointer_v<decay_t<_Iter>>) { 
        return _It + 0;
    } else if constexpr (_Unwrappable_for_unverified_v<_Iter>) {
        return static_cast<_Iter&&>(_It)._Unwrapped();
    } else {
        return static_cast<_Iter&&>(_It);
    }
}

template <class _Iter>
using _Unwrapped_unverified_t = _Remove_cvref_t<decltype(_Get_unwrapped_unverified(::std:: declval<_Iter>()))>;

struct _Distance_unknown {
    constexpr _Distance_unknown operator-() const noexcept {
        return {};
    }
};

template <class _Diff>
inline constexpr _Diff _Max_possible_v{static_cast<make_unsigned_t<_Diff>>(-1) >> 1};

template <class _Diff>
inline constexpr _Diff _Min_possible_v{-_Max_possible_v<_Diff> - 1};

template <class _Iter, class = void>
inline constexpr bool _Offset_verifiable_v = false;

template <class _Iter>
inline constexpr bool
    _Offset_verifiable_v<_Iter, void_t<decltype(::std:: declval<const _Iter&>()._Verify_offset(_Iter_diff_t<_Iter>{}))>> =
        true;

template <class _Iter>
inline constexpr bool _Unwrappable_for_offset_v =
    _Unwrappable_v<_Iter>&& _Offset_verifiable_v<_Remove_cvref_t<_Iter>>;

template <class _Iter, class _Diff>
[[nodiscard]] constexpr decltype(auto) _Get_unwrapped_n(_Iter&& _It, const _Diff _Off) {
    if constexpr (is_pointer_v<decay_t<_Iter>>) {
        return _It + 0;
    } else if constexpr (_Unwrappable_for_offset_v<_Iter> && is_integral_v<_Diff>) {
        
        using _IDiff     = _Iter_diff_t<_Remove_cvref_t<_Iter>>;
        using _CDiff     = common_type_t<_Diff, _IDiff>;
        const auto _COff = static_cast<_CDiff>(_Off);

        ;
#line 1348 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
        (void) _COff;

        _It._Verify_offset(static_cast<_IDiff>(_Off));
        return static_cast<_Iter&&>(_It)._Unwrapped();
    } else if constexpr (_Unwrappable_for_unverified_v<_Iter>) {
        
        return static_cast<_Iter&&>(_It)._Unwrapped();
    } else {
        
        return static_cast<_Iter&&>(_It);
    }
}

template <class _Iter, class _UIter, class = void>
inline constexpr bool _Wrapped_seekable_v = false;

template <class _Iter, class _UIter>
inline constexpr bool
    _Wrapped_seekable_v<_Iter, _UIter, void_t<decltype(::std:: declval<_Iter&>()._Seek_to(::std:: declval<_UIter>()))>> =
        true;

template <class _Iter, class _UIter>
constexpr void _Seek_wrapped(_Iter& _It, _UIter&& _UIt) {
    if constexpr (_Wrapped_seekable_v<_Iter, _UIter>) {
        _It._Seek_to(::std:: forward<_UIter>(_UIt));
    } else {
        _It = ::std:: forward<_UIter>(_UIt);
    }
}


template <class _Ty, class = void>
struct _Is_allocator : false_type {}; 

template <class _Ty>
struct _Is_allocator<_Ty, void_t<typename _Ty::value_type, decltype(::std:: declval<_Ty&>().deallocate(
                                                               ::std:: declval<_Ty&>().allocate(size_t{1}), size_t{1}))>>
    : true_type {}; 


template <class _Iter>
using _Guide_key_t = remove_const_t<typename iterator_traits<_Iter>::value_type::first_type>;

template <class _Iter>
using _Guide_val_t = typename iterator_traits<_Iter>::value_type::second_type;

template <class _Iter>
using _Guide_pair_t = pair<add_const_t<typename iterator_traits<_Iter>::value_type::first_type>,
    typename iterator_traits<_Iter>::value_type::second_type>;

template <class _Ty>
struct is_execution_policy : false_type {};

template <class _Ty>
inline constexpr bool is_execution_policy_v = is_execution_policy<_Ty>::value;


template <class _ExPo>
using _Enable_if_execution_policy_t = typename remove_reference_t<_ExPo>::_Standard_execution_policy;


#line 1413 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class _Checked, class _Iter>
[[nodiscard]] constexpr auto _Idl_distance(const _Iter& _First, const _Iter& _Last) {
    
    if constexpr (_Is_random_iter_v<_Iter>) {
        return static_cast<_Iter_diff_t<_Checked>>(_Last - _First);
    } else {
        return _Distance_unknown{};
    }
}

template <class _Elem, bool _Is_enum = is_enum_v<_Elem>>
struct _Unwrap_enum { 
    using type = underlying_type_t<_Elem>;
};

template <class _Elem>
struct _Unwrap_enum<_Elem, false> { 
    using type = _Elem;
};

template <class _Elem>
using _Unwrap_enum_t = typename _Unwrap_enum<_Elem>::type;


#line 1488 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"


template <class _InIt, class _Diff>
constexpr void advance(_InIt& _Where, _Diff _Off) { 
    if constexpr (_Is_random_iter_v<_InIt>) {
        _Where += _Off;
    } else {
        if constexpr (is_signed_v<_Diff> && !_Is_bidi_iter_v<_InIt>) {
            ;
        }

        decltype(auto) _UWhere      = _Get_unwrapped_n(::std:: move(_Where), _Off);
        constexpr bool _Need_rewrap = !is_reference_v<decltype(_Get_unwrapped_n(::std:: move(_Where), _Off))>;

        if constexpr (is_signed_v<_Diff> && _Is_bidi_iter_v<_InIt>) {
            for (; _Off < 0; ++_Off) {
                --_UWhere;
            }
        }

        for (; 0 < _Off; --_Off) {
            ++_UWhere;
        }

        if constexpr (_Need_rewrap) {
            _Seek_wrapped(_Where, ::std:: move(_UWhere));
        }
    }
}

template <class _InIt>
[[nodiscard]] constexpr _Iter_diff_t<_InIt> distance(_InIt _First, _InIt _Last) {
    if constexpr (_Is_random_iter_v<_InIt>) {
        return _Last - _First; 
    } else {
        _Adl_verify_range(_First, _Last);
        auto _UFirst             = _Get_unwrapped(_First);
        const auto _ULast        = _Get_unwrapped(_Last);
        _Iter_diff_t<_InIt> _Off = 0;
        for (; _UFirst != _ULast; ++_UFirst) {
            ++_Off;
        }

        return _Off;
    }
}

template <class _InIt>
constexpr _InIt _Next_iter(_InIt _First) { 
    return ++_First;
}

template <class _InIt>
[[nodiscard]] constexpr _InIt next(_InIt _First, _Iter_diff_t<_InIt> _Off = 1) { 
    static_assert(_Is_input_iter_v<_InIt>, "next requires input iterator");

    ::std:: advance(_First, _Off);
    return _First;
}

template <class _BidIt>
constexpr _BidIt _Prev_iter(_BidIt _First) { 
    return --_First;
}

template <class _BidIt>
[[nodiscard]] constexpr _BidIt prev(_BidIt _First, _Iter_diff_t<_BidIt> _Off = 1) { 
    static_assert(_Is_bidi_iter_v<_BidIt>, "prev requires bidirectional iterator");

    ::std:: advance(_First, -_Off);
    return _First;
}

template <class _BidIt>
class reverse_iterator {
public:
    using iterator_type = _BidIt;


    using iterator_concept =
        conditional_t<random_access_iterator<_BidIt>, random_access_iterator_tag, bidirectional_iterator_tag>;
    using iterator_category = conditional_t<derived_from<_Iter_cat_t<_BidIt>, random_access_iterator_tag>,
        random_access_iterator_tag, _Iter_cat_t<_BidIt>>;


#line 1574 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
    using value_type      = _Iter_value_t<_BidIt>;
    using difference_type = _Iter_diff_t<_BidIt>;
    using pointer         = typename iterator_traits<_BidIt>::pointer;
    using reference       = _Iter_ref_t<_BidIt>;

    template <class>
    friend class reverse_iterator;

    constexpr reverse_iterator() = default;

    constexpr explicit reverse_iterator(_BidIt _Right) noexcept(
        is_nothrow_move_constructible_v<_BidIt>) 
        : current(::std:: move(_Right)) {}

    
    template <class _Other>

        requires (!is_same_v<_Other, _BidIt>) && convertible_to<const _Other&, _BidIt>
#line 1593 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
    constexpr reverse_iterator(const reverse_iterator<_Other>& _Right) noexcept(
        is_nothrow_constructible_v<_BidIt, const _Other&>) 
        : current(_Right.current) {}

    template <class _Other>

        requires (!is_same_v<_Other, _BidIt>) && convertible_to<const _Other&, _BidIt>
            && assignable_from<_BidIt&, const _Other&>
#line 1602 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
    constexpr reverse_iterator& operator=(const reverse_iterator<_Other>& _Right) {
        current = _Right.current;
        return *this;
    }
    

    [[nodiscard]] constexpr _BidIt base() const {
        return current;
    }

    [[nodiscard]] constexpr reference operator*() const {
        _BidIt _Tmp = current;
        return *--_Tmp;
    }


    [[nodiscard]] constexpr pointer operator->() const
        requires (is_pointer_v<_BidIt> || requires(const _BidIt __i) { __i.operator->(); }) {
        _BidIt _Tmp = current;
        --_Tmp;
        if constexpr (is_pointer_v<_BidIt>) {
            return _Tmp;
        } else {
            return _Tmp.operator->();
        }
    }
    

#line 1641 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

    constexpr reverse_iterator& operator++() {
        --current;
        return *this;
    }

    constexpr reverse_iterator operator++(int) {
        reverse_iterator _Tmp = *this;
        --current;
        return _Tmp;
    }

    constexpr reverse_iterator& operator--() {
        ++current;
        return *this;
    }

    constexpr reverse_iterator operator--(int) {
        reverse_iterator _Tmp = *this;
        ++current;
        return _Tmp;
    }

    [[nodiscard]] constexpr reverse_iterator operator+(const difference_type _Off) const {
        return reverse_iterator(current - _Off);
    }

    constexpr reverse_iterator& operator+=(const difference_type _Off) {
        current -= _Off;
        return *this;
    }

    [[nodiscard]] constexpr reverse_iterator operator-(const difference_type _Off) const {
        return reverse_iterator(current + _Off);
    }

    constexpr reverse_iterator& operator-=(const difference_type _Off) {
        current += _Off;
        return *this;
    }

    [[nodiscard]] constexpr reference operator[](const difference_type _Off) const {
        return current[static_cast<difference_type>(-_Off - 1)];
    }


    [[nodiscard]] friend constexpr iter_rvalue_reference_t<_BidIt> iter_move(const reverse_iterator& _It) noexcept(
        is_nothrow_copy_constructible_v<_BidIt>&& noexcept(::std::ranges:: iter_move(--::std:: declval<_BidIt&>()))) {
        auto _Tmp = _It.current;
        --_Tmp;
        return ::std::ranges:: iter_move(_Tmp);
    }

    template <indirectly_swappable<_BidIt> _BidIt2>
    friend constexpr void iter_swap(const reverse_iterator& _Left, const reverse_iterator<_BidIt2>& _Right) noexcept(
        is_nothrow_copy_constructible_v<_BidIt>&& is_nothrow_copy_constructible_v<_BidIt2>&& noexcept(
            ::std::ranges:: iter_swap(--::std:: declval<_BidIt&>(), --::std:: declval<_BidIt2&>()))) {
        auto _LTmp = _Left.current;
        auto _RTmp = _Right.base();
        --_LTmp;
        --_RTmp;
        ::std::ranges:: iter_swap(_LTmp, _RTmp);
    }
#line 1705 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

    using _Prevent_inheriting_unwrap = reverse_iterator;

    template <class _BidIt2, enable_if_t<_Range_verifiable_v<_BidIt, _BidIt2>, int> = 0>
    friend constexpr void _Verify_range(const reverse_iterator& _First, const reverse_iterator<_BidIt2>& _Last) {
        _Verify_range(_Last._Get_current(), _First.current); 
    }

    template <class _BidIt2 = _BidIt, enable_if_t<_Offset_verifiable_v<_BidIt2>, int> = 0>
    constexpr void _Verify_offset(const difference_type _Off) const {
        do { if (_Off != _Min_possible_v<difference_type>) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
        current._Verify_offset(-_Off);
    }

    template <class _BidIt2 = _BidIt, enable_if_t<_Unwrappable_v<const _BidIt2&>, int> = 0>
    [[nodiscard]] constexpr reverse_iterator<_Unwrapped_t<const _BidIt2&>> _Unwrapped() const {
        return static_cast<reverse_iterator<_Unwrapped_t<const _BidIt2&>>>(current._Unwrapped());
    }

    static constexpr bool _Unwrap_when_unverified = _Do_unwrap_when_unverified_v<_BidIt>;

    template <class _Src, enable_if_t<_Wrapped_seekable_v<_BidIt, const _Src&>, int> = 0>
    constexpr void _Seek_to(const reverse_iterator<_Src>& _It) {
        current._Seek_to(_It.current);
    }

    [[nodiscard]] constexpr const _BidIt& _Get_current() const noexcept {
        return current;
    }

protected:
    _BidIt current{};
};

template <class _BidIt1, class _BidIt2>
[[nodiscard]] constexpr bool operator==(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right)

    
    requires requires {
        { _Left._Get_current() == _Right._Get_current() } -> _Implicitly_convertible_to<bool>;
    }

#line 1748 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
{ return _Left._Get_current() == _Right._Get_current(); }

template <class _BidIt1, class _BidIt2>
[[nodiscard]] constexpr bool operator!=(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right)

    
    requires requires {
        { _Left._Get_current() != _Right._Get_current() } -> _Implicitly_convertible_to<bool>;
    }

#line 1759 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
{ return _Left._Get_current() != _Right._Get_current(); }

template <class _BidIt1, class _BidIt2>
[[nodiscard]] constexpr bool operator<(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right)

    
    requires requires {
        { _Left._Get_current() > _Right._Get_current() } -> _Implicitly_convertible_to<bool>;
    }

#line 1770 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
{ return _Left._Get_current() > _Right._Get_current(); }

template <class _BidIt1, class _BidIt2>
[[nodiscard]] constexpr bool operator>(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right)

    
    requires requires {
        { _Left._Get_current() < _Right._Get_current() } -> _Implicitly_convertible_to<bool>;
    }

#line 1781 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
{ return _Left._Get_current() < _Right._Get_current(); }

template <class _BidIt1, class _BidIt2>
[[nodiscard]] constexpr bool operator<=(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right)

    
    requires requires {
        { _Left._Get_current() >= _Right._Get_current() } -> _Implicitly_convertible_to<bool>;
    }

#line 1792 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
{ return _Left._Get_current() >= _Right._Get_current(); }

template <class _BidIt1, class _BidIt2>
[[nodiscard]] constexpr bool operator>=(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right)

    
    requires requires {
        { _Left._Get_current() <= _Right._Get_current() } -> _Implicitly_convertible_to<bool>;
    }

#line 1803 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
{ return _Left._Get_current() <= _Right._Get_current(); }


template <class _BidIt1, three_way_comparable_with<_BidIt1> _BidIt2>
[[nodiscard]] constexpr compare_three_way_result_t<_BidIt1, _BidIt2> operator<=>(
    const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right) {
    return _Right._Get_current() <=> _Left._Get_current();
}
#line 1812 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class _BidIt1, class _BidIt2>
[[nodiscard]] constexpr auto operator-(const reverse_iterator<_BidIt1>& _Left, const reverse_iterator<_BidIt2>& _Right)
    -> decltype(_Right._Get_current() - _Left._Get_current()) {
    return _Right._Get_current() - _Left._Get_current();
}

template <class _BidIt>
[[nodiscard]] constexpr reverse_iterator<_BidIt> operator+(
    typename reverse_iterator<_BidIt>::difference_type _Off, const reverse_iterator<_BidIt>& _Right) {
    return _Right + _Off;
}

template <class _BidIt>
[[nodiscard]] constexpr reverse_iterator<_BidIt> make_reverse_iterator(_BidIt _Iter) noexcept(
    is_nothrow_move_constructible_v<_BidIt>)  {
    return reverse_iterator<_BidIt>(::std:: move(_Iter));
}


template <class _BidIt1, class _BidIt2>
    requires (!sized_sentinel_for<_BidIt1, _BidIt2>)
inline constexpr bool disable_sized_sentinel_for<reverse_iterator<_BidIt1>, reverse_iterator<_BidIt2>> = true;

#line 1838 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class _Container>
[[nodiscard]] constexpr auto begin(_Container& _Cont) -> decltype(_Cont.begin()) {
    return _Cont.begin();
}

template <class _Container>
[[nodiscard]] constexpr auto begin(const _Container& _Cont) -> decltype(_Cont.begin()) {
    return _Cont.begin();
}

template <class _Container>
[[nodiscard]] constexpr auto end(_Container& _Cont) -> decltype(_Cont.end()) {
    return _Cont.end();
}

template <class _Container>
[[nodiscard]] constexpr auto end(const _Container& _Cont) -> decltype(_Cont.end()) {
    return _Cont.end();
}

template <class _Ty, size_t _Size>
[[nodiscard]] constexpr _Ty* begin(_Ty (&_Array)[_Size]) noexcept {
    return _Array;
}

template <class _Ty, size_t _Size>
[[nodiscard]] constexpr _Ty* end(_Ty (&_Array)[_Size]) noexcept {
    return _Array + _Size;
}

template <class _Container>
[[nodiscard]] constexpr auto cbegin(const _Container& _Cont) noexcept(noexcept(::std:: begin(_Cont)))
    -> decltype(::std:: begin(_Cont)) {
    return ::std:: begin(_Cont);
}

template <class _Container>
[[nodiscard]] constexpr auto cend(const _Container& _Cont) noexcept(noexcept(::std:: end(_Cont)))
    -> decltype(::std:: end(_Cont)) {
    return ::std:: end(_Cont);
}

template <class _Container>
[[nodiscard]] constexpr auto rbegin(_Container& _Cont) -> decltype(_Cont.rbegin()) {
    return _Cont.rbegin();
}

template <class _Container>
[[nodiscard]] constexpr auto rbegin(const _Container& _Cont) -> decltype(_Cont.rbegin()) {
    return _Cont.rbegin();
}

template <class _Container>
[[nodiscard]] constexpr auto rend(_Container& _Cont) -> decltype(_Cont.rend()) {
    return _Cont.rend();
}

template <class _Container>
[[nodiscard]] constexpr auto rend(const _Container& _Cont) -> decltype(_Cont.rend()) {
    return _Cont.rend();
}

template <class _Ty, size_t _Size>
[[nodiscard]] constexpr reverse_iterator<_Ty*> rbegin(_Ty (&_Array)[_Size]) {
    return reverse_iterator<_Ty*>(_Array + _Size);
}

template <class _Ty, size_t _Size>
[[nodiscard]] constexpr reverse_iterator<_Ty*> rend(_Ty (&_Array)[_Size]) {
    return reverse_iterator<_Ty*>(_Array);
}

template <class _Elem>
[[nodiscard]] constexpr reverse_iterator<const _Elem*> rbegin(initializer_list<_Elem> _Ilist) {
    return reverse_iterator<const _Elem*>(_Ilist.end());
}

template <class _Elem>
[[nodiscard]] constexpr reverse_iterator<const _Elem*> rend(initializer_list<_Elem> _Ilist) {
    return reverse_iterator<const _Elem*>(_Ilist.begin());
}

template <class _Container>
[[nodiscard]] constexpr auto crbegin(const _Container& _Cont) -> decltype(::std:: rbegin(_Cont)) {
    return ::std:: rbegin(_Cont);
}

template <class _Container>
[[nodiscard]] constexpr auto crend(const _Container& _Cont) -> decltype(::std:: rend(_Cont)) {
    return ::std:: rend(_Cont);
}

template <class _Container>
[[nodiscard]] constexpr auto size(const _Container& _Cont) -> decltype(_Cont.size()) {
    return _Cont.size();
}

template <class _Ty, size_t _Size>
[[nodiscard]] constexpr size_t size(const _Ty (&)[_Size]) noexcept {
    return _Size;
}


template <class _Container>
[[nodiscard]] constexpr auto ssize(const _Container& _Cont)
    -> common_type_t<ptrdiff_t, make_signed_t<decltype(_Cont.size())>> {
    using _Common = common_type_t<ptrdiff_t, make_signed_t<decltype(_Cont.size())>>;
    return static_cast<_Common>(_Cont.size());
}

template <class _Ty, ptrdiff_t _Size>
[[nodiscard]] constexpr ptrdiff_t ssize(const _Ty (&)[_Size]) noexcept {
    return _Size;
}
#line 1954 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class _Container>
[[nodiscard]] constexpr auto empty(const _Container& _Cont) -> decltype(_Cont.empty()) {
    return _Cont.empty();
}

template <class _Ty, size_t _Size>
[[nodiscard]] constexpr bool empty(const _Ty (&)[_Size]) noexcept {
    return false;
}

template <class _Elem>
[[nodiscard]] constexpr bool empty(initializer_list<_Elem> _Ilist) noexcept {
    return _Ilist.size() == 0;
}

template <class _Container>
[[nodiscard]] constexpr auto data(_Container& _Cont) -> decltype(_Cont.data()) {
    return _Cont.data();
}

template <class _Container>
[[nodiscard]] constexpr auto data(const _Container& _Cont) -> decltype(_Cont.data()) {
    return _Cont.data();
}

template <class _Ty, size_t _Size>
[[nodiscard]] constexpr _Ty* data(_Ty (&_Array)[_Size]) noexcept {
    return _Array;
}

template <class _Elem>
[[nodiscard]] constexpr const _Elem* data(initializer_list<_Elem> _Ilist) noexcept {
    return _Ilist.begin();
}


template <class _Ty>
[[nodiscard]] _Ty _Fake_decay_copy(_Ty) noexcept;


template <class _Ty1, class _Ty2>
concept _Not_same_as = !same_as<remove_cvref_t<_Ty1>, remove_cvref_t<_Ty2>>;

namespace ranges {
    template <class>
    inline constexpr bool _Has_complete_elements = false;

    
    template <class _Ty>
        requires requires(_Ty& __t) { sizeof(__t[0]); }
    inline constexpr bool _Has_complete_elements<_Ty> = true;
    

    template <class>
    inline constexpr bool enable_borrowed_range = false;

    template <class _Rng>
    concept _Should_range_access = is_lvalue_reference_v<_Rng> || enable_borrowed_range<remove_cvref_t<_Rng>>;

    namespace _Begin {
        template <class _Ty>
        void begin(_Ty&) = delete;
        template <class _Ty>
        void begin(const _Ty&) = delete;

        template <class _Ty>
        concept _Has_member = requires(_Ty __t) {
            { _Fake_decay_copy(__t.begin()) } -> input_or_output_iterator;
        };

        template <class _Ty>
        concept _Has_ADL = _Has_class_or_enum_type<_Ty> && requires(_Ty __t) {
            { _Fake_decay_copy(begin(__t)) } -> input_or_output_iterator;
        };

        class _Cpo {
        private:
            enum class _St { _None, _Array, _Member, _Non_member };

            template <class _Ty>
            [[nodiscard]] static consteval _Choice_t<_St> _Choose() noexcept {
                ;
                if constexpr (is_array_v<remove_reference_t<_Ty>>) {
                    static_assert(_Has_complete_elements<_Ty>,
                        "The range access customization point objects "
                        "std::ranges::begin, std::ranges::end, std::ranges::rbegin, std::ranges::rend, "
                        "and std::ranges::data do not accept arrays with incomplete element types.");
                    return {_St::_Array, true};
                } else if constexpr (_Has_member<_Ty>) {
                    return {_St::_Member, noexcept(_Fake_decay_copy(::std:: declval<_Ty>().begin()))};
                } else if constexpr (_Has_ADL<_Ty>) {
                    return {_St::_Non_member, noexcept(_Fake_decay_copy(begin(::std:: declval<_Ty>())))};
                } else {
                    return {_St::_None};
                }
            }

            template <class _Ty>
            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty>();

        public:
            
            template <_Should_range_access _Ty>
                requires (_Choice<_Ty&>._Strategy != _St::_None)
            [[nodiscard]] constexpr auto operator()(_Ty&& _Val) const noexcept(_Choice<_Ty&>._No_throw) {
                constexpr _St _Strat = _Choice<_Ty&>._Strategy;

                if constexpr (_Strat == _St::_Array) {
                    return _Val;
                } else if constexpr (_Strat == _St::_Member) {
                    return _Val.begin();
                } else if constexpr (_Strat == _St::_Non_member) {
                    return begin(_Val);
                } else {
                    static_assert(_Always_false<_Ty>, "Should be unreachable");
                }
            }
            
        };
    } 

    inline namespace _Cpos {
        inline constexpr _Begin::_Cpo begin;
    }

    template <class _Ty>
    using iterator_t = decltype(::std::ranges:: begin(::std:: declval<_Ty&>()));

    namespace _Unchecked_begin {
        template <class _Ty>
        concept _Has_member = requires(_Ty& __t) {
            { __t._Unchecked_begin() } -> input_or_output_iterator;
        };

        template <class _Ty>
        concept _Can_begin = requires(_Ty& __t) {
            _Get_unwrapped(::std::ranges:: begin(__t));
        };

        class _Cpo {
        private:
            enum class _St { _None, _Member, _Unwrap };

            template <class _Ty>
            [[nodiscard]] static consteval _Choice_t<_St> _Choose() noexcept {
                ;
                if constexpr (_Has_member<_Ty>) {
                    ;
#line 2107 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
                    return {_St::_Member, noexcept(::std:: declval<_Ty>()._Unchecked_begin())};
                } else if constexpr (_Can_begin<_Ty>) {
                    return {_St::_Unwrap, noexcept(_Get_unwrapped(::std::ranges:: begin(::std:: declval<_Ty>())))};
                } else {
                    return {_St::_None};
                }
            }

            template <class _Ty>
            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty>();

        public:
            
            template <_Should_range_access _Ty>
                requires (_Choice<_Ty&>._Strategy != _St::_None)
            [[nodiscard]] constexpr auto operator()(_Ty&& _Val) const noexcept(_Choice<_Ty&>._No_throw) {
                constexpr _St _Strat = _Choice<_Ty&>._Strategy;

                if constexpr (_Strat == _St::_Member) {
                    return _Val._Unchecked_begin();
                } else if constexpr (_Strat == _St::_Unwrap) {
                    return _Get_unwrapped(::std::ranges:: begin(_Val));
                } else {
                    static_assert(_Always_false<_Ty>, "Should be unreachable");
                }
            }
            
        };
    } 

    inline namespace _Cpos {
        inline constexpr _Unchecked_begin::_Cpo _Ubegin;
    }

    namespace _End {
        template <class _Ty>
        void end(_Ty&) = delete;
        template <class _Ty>
        void end(const _Ty&) = delete;

        template <class _Ty>
        concept _Has_member = requires(_Ty __t) {
            { _Fake_decay_copy(__t.end()) } -> sentinel_for<iterator_t<_Ty>>;
        };

        template <class _Ty>
        concept _Has_ADL = _Has_class_or_enum_type<_Ty> && requires(_Ty __t) {
            { _Fake_decay_copy(end(__t)) } -> sentinel_for<iterator_t<_Ty>>;
        };

        class _Cpo {
        private:
            enum class _St { _None, _Array, _Member, _Non_member };

            template <class _Ty>
            [[nodiscard]] static consteval _Choice_t<_St> _Choose() noexcept {
                ;
                using _UnRef = remove_reference_t<_Ty>;

                if constexpr (is_array_v<_UnRef>) {
                    static_assert(_Has_complete_elements<_UnRef>,
                        "The range access customization point objects "
                        "std::ranges::begin, std::ranges::end, std::ranges::rbegin, std::ranges::rend, "
                        "and std::ranges::data do not accept arrays with incomplete element types.");
                    if constexpr (extent_v<_UnRef> != 0) {
                        return {_St::_Array, true};
                    } else {
                        return {_St::_None};
                    }
                } else if constexpr (_Has_member<_Ty>) {
                    return {_St::_Member, noexcept(_Fake_decay_copy(::std:: declval<_Ty>().end()))};
                } else if constexpr (_Has_ADL<_Ty>) {
                    return {_St::_Non_member, noexcept(_Fake_decay_copy(end(::std:: declval<_Ty>())))};
                } else {
                    return {_St::_None};
                }
            }

            template <class _Ty>
            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty>();

        public:
            
            template <_Should_range_access _Ty>
                requires (_Choice<_Ty&>._Strategy != _St::_None)
            [[nodiscard]] constexpr auto operator()(_Ty&& _Val) const noexcept(_Choice<_Ty&>._No_throw) {
                constexpr _St _Strat = _Choice<_Ty&>._Strategy;

                if constexpr (_Strat == _St::_Array) {
                    
                    return _Val + extent_v<remove_reference_t<_Ty&>>;
                } else if constexpr (_Strat == _St::_Member) {
                    return _Val.end();
                } else if constexpr (_Strat == _St::_Non_member) {
                    return end(_Val);
                } else {
                    static_assert(_Always_false<_Ty>, "should be unreachable");
                }
            }
            
        };
    } 

    inline namespace _Cpos {
        inline constexpr _End::_Cpo end;
    }

    namespace _Unchecked_end {
        template <class _Ty>
        concept _Has_member = _Unchecked_begin::_Has_member<_Ty> && requires(_Ty& __t) {
            __t._Unchecked_begin(); 
            { __t._Unchecked_end() } -> sentinel_for<decltype(__t._Unchecked_begin())>;
        };

        template <class _Ty>
        concept _Can_end = requires(_Ty& __t) {
            _Get_unwrapped(::std::ranges:: end(__t));
        };

        class _Cpo {
        private:
            enum class _St { _None, _Member, _Unwrap };

            template <class _Ty>
            [[nodiscard]] static consteval _Choice_t<_St> _Choose() noexcept {
                ;
                if constexpr (_Has_member<_Ty>) {
                    ;
#line 2236 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
                    return {_St::_Member, noexcept(::std:: declval<_Ty>()._Unchecked_end())};
                } else if constexpr (_Can_end<_Ty>) {
                    return {_St::_Unwrap, noexcept(_Get_unwrapped(::std::ranges:: end(::std:: declval<_Ty>())))};
                } else {
                    return {_St::_None};
                }
            }

            template <class _Ty>
            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty>();

        public:
            
            template <_Should_range_access _Ty>
                requires (_Choice<_Ty&>._Strategy != _St::_None)
            [[nodiscard]] constexpr auto operator()(_Ty&& _Val) const noexcept(_Choice<_Ty&>._No_throw) {
                constexpr _St _Strat = _Choice<_Ty&>._Strategy;

                if constexpr (_Strat == _St::_Member) {
                    return _Val._Unchecked_end();
                } else if constexpr (_Strat == _St::_Unwrap) {
                    return _Get_unwrapped(::std::ranges:: end(_Val));
                } else {
                    static_assert(_Always_false<_Ty>, "Should be unreachable");
                }
            }
            
        };
    } 

    inline namespace _Cpos {
        inline constexpr _Unchecked_end::_Cpo _Uend;
    }

    template <class _Rng>
    concept range = requires(_Rng& __r) {
        ::std::ranges:: begin(__r);
        ::std::ranges:: end(__r);
    };

    template <class _Rng>
    concept borrowed_range = range<_Rng> && _Should_range_access<_Rng>;

    template <range _Rng>
    using sentinel_t = decltype(::std::ranges:: end(::std:: declval<_Rng&>()));

    template <range _Rng>
    using range_difference_t = iter_difference_t<iterator_t<_Rng>>;

    template <range _Rng>
    using range_value_t = iter_value_t<iterator_t<_Rng>>;

    template <range _Rng>
    using range_reference_t = iter_reference_t<iterator_t<_Rng>>;

    template <range _Rng>
    using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<_Rng>>;

    struct _Cbegin_fn {
        
        template <class _Ty, class _CTy = _Const_thru_ref<_Ty>>
        [[nodiscard]] constexpr auto operator()(_Ty&& _Val) const
            noexcept(noexcept(::std::ranges:: begin(static_cast<_CTy&&>(_Val))))
            requires requires { ::std::ranges:: begin(static_cast<_CTy&&>(_Val)); } {
            return ::std::ranges:: begin(static_cast<_CTy&&>(_Val));
        }
        
    };

    inline namespace _Cpos {
        inline constexpr _Cbegin_fn cbegin;
    }

    struct _Cend_fn {
        
        template <class _Ty, class _CTy = _Const_thru_ref<_Ty>>
        [[nodiscard]] constexpr auto operator()(_Ty&& _Val) const
            noexcept(noexcept(::std::ranges:: end(static_cast<_CTy&&>(_Val))))
            requires requires { ::std::ranges:: end(static_cast<_CTy&&>(_Val)); } {
            return ::std::ranges:: end(static_cast<_CTy&&>(_Val));
        }
        
    };

    inline namespace _Cpos {
        inline constexpr _Cend_fn cend;
    }

    namespace _Rbegin {
        template <class _Ty>
        void rbegin(_Ty&) = delete;
        template <class _Ty>
        void rbegin(const _Ty&) = delete;

        template <class _Ty>
        concept _Has_member = requires(_Ty __t) {
            { _Fake_decay_copy(__t.rbegin()) } -> input_or_output_iterator;
        };

        template <class _Ty>
        concept _Has_ADL = _Has_class_or_enum_type<_Ty> && requires(_Ty __t) {
            { _Fake_decay_copy(rbegin(__t)) } -> input_or_output_iterator;
        };

        template <class _Ty>
        concept _Can_make_reverse = requires(_Ty __t) {
            { ::std::ranges:: begin(__t) } -> bidirectional_iterator;
            { ::std::ranges:: end(__t) } -> same_as<decltype(::std::ranges:: begin(__t))>;
        };

        class _Cpo {
        private:
            enum class _St { _None, _Member, _Non_member, _Make_reverse };

            template <class _Ty>
            [[nodiscard]] static consteval _Choice_t<_St> _Choose() noexcept {
                ;
                if constexpr (_Has_member<_Ty>) {
                    return {_St::_Member, noexcept(_Fake_decay_copy(::std:: declval<_Ty>().rbegin()))};
                } else if constexpr (_Has_ADL<_Ty>) {
                    return {_St::_Non_member, noexcept(_Fake_decay_copy(rbegin(::std:: declval<_Ty>())))};
                } else if constexpr (_Can_make_reverse<_Ty>) {
                    return {_St::_Make_reverse, noexcept(::std:: make_reverse_iterator(::std::ranges:: end(::std:: declval<_Ty>())))};
                } else {
                    return {_St::_None};
                }
            }

            template <class _Ty>
            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty>();

        public:
            
            template <_Should_range_access _Ty>
                requires (_Choice<_Ty&>._Strategy != _St::_None)
            [[nodiscard]] constexpr auto operator()(_Ty&& _Val) const noexcept(_Choice<_Ty&>._No_throw) {
                constexpr _St _Strat = _Choice<_Ty&>._Strategy;

                if constexpr (_Strat == _St::_Member) {
                    return _Val.rbegin();
                } else if constexpr (_Strat == _St::_Non_member) {
                    return rbegin(_Val);
                } else if constexpr (_Strat == _St::_Make_reverse) {
                    return ::std:: make_reverse_iterator(::std::ranges:: end(_Val));
                } else {
                    static_assert(_Always_false<_Ty>, "should be unreachable");
                }
            }
            
        };
    } 

    inline namespace _Cpos {
        inline constexpr _Rbegin::_Cpo rbegin;
    }

    namespace _Rend {
        template <class _Ty>
        void rend(_Ty&) = delete;
        template <class _Ty>
        void rend(const _Ty&) = delete;

        template <class _Ty>
        concept _Has_member = requires(_Ty __t) {
            { _Fake_decay_copy(__t.rend()) } -> sentinel_for<decltype(::std::ranges:: rbegin(__t))>;
        };

        template <class _Ty>
        concept _Has_ADL = _Has_class_or_enum_type<_Ty> && requires(_Ty __t) {
            { _Fake_decay_copy(rend(__t)) } -> sentinel_for<decltype(::std::ranges:: rbegin(__t))>;
        };

        template <class _Ty>
        concept _Can_make_reverse = requires(_Ty __t) {
            { ::std::ranges:: begin(__t) } -> bidirectional_iterator;
            { ::std::ranges:: end(__t) } -> same_as<decltype(::std::ranges:: begin(__t))>;
        };

        class _Cpo {
        private:
            enum class _St { _None, _Member, _Non_member, _Make_reverse };

            template <class _Ty>
            [[nodiscard]] static consteval _Choice_t<_St> _Choose() noexcept {
                ;
                if constexpr (_Has_member<_Ty>) {
                    return {_St::_Member, noexcept(_Fake_decay_copy(::std:: declval<_Ty>().rend()))};
                } else if constexpr (_Has_ADL<_Ty>) {
                    return {_St::_Non_member, noexcept(_Fake_decay_copy(rend(::std:: declval<_Ty>())))};
                } else if constexpr (_Can_make_reverse<_Ty>) {
                    return {
                        _St::_Make_reverse, noexcept(::std:: make_reverse_iterator(::std::ranges:: begin(::std:: declval<_Ty>())))};
                } else {
                    return {_St::_None};
                }
            }

            template <class _Ty>
            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty>();

        public:
            
            template <_Should_range_access _Ty>
                requires (_Choice<_Ty&>._Strategy != _St::_None)
            [[nodiscard]] constexpr auto operator()(_Ty&& _Val) const noexcept(_Choice<_Ty&>._No_throw) {
                constexpr _St _Strat = _Choice<_Ty&>._Strategy;

                if constexpr (_Strat == _St::_Member) {
                    return _Val.rend();
                } else if constexpr (_Strat == _St::_Non_member) {
                    return rend(_Val);
                } else if constexpr (_Strat == _St::_Make_reverse) {
                    return ::std:: make_reverse_iterator(::std::ranges:: begin(_Val));
                } else {
                    static_assert(_Always_false<_Ty>, "should be unreachable");
                }
            }
            
        };
    } 

    inline namespace _Cpos {
        inline constexpr _Rend::_Cpo rend;
    }

    struct _Crbegin_fn {
        
        template <class _Ty, class _CTy = _Const_thru_ref<_Ty>>
        [[nodiscard]] constexpr auto operator()(_Ty&& _Val) const
            noexcept(noexcept(::std::ranges:: rbegin(static_cast<_CTy&&>(_Val))))
            requires requires { ::std::ranges:: rbegin(static_cast<_CTy&&>(_Val)); } {
            return ::std::ranges:: rbegin(static_cast<_CTy&&>(_Val));
        }
        
    };

    inline namespace _Cpos {
        inline constexpr _Crbegin_fn crbegin;
    }

    struct _Crend_fn {
        
        template <class _Ty, class _CTy = _Const_thru_ref<_Ty>>
        [[nodiscard]] constexpr auto operator()(_Ty&& _Val) const
            noexcept(noexcept(::std::ranges:: rend(static_cast<_CTy&&>(_Val))))
            requires requires { ::std::ranges:: rend(static_cast<_CTy&&>(_Val)); } {
            return ::std::ranges:: rend(static_cast<_CTy&&>(_Val));
        }
        
    };

    inline namespace _Cpos {
        inline constexpr _Crend_fn crend;
    }

    template <class>
    inline constexpr bool disable_sized_range = false;

    namespace _Size {
        template <class _Ty>
        void size(_Ty&) = delete;
        template <class _Ty>
        void size(const _Ty&) = delete;

        template <class _Ty, class _UnCV>
        concept _Has_member = !disable_sized_range<_UnCV> && requires(_Ty __t) {
            { _Fake_decay_copy(__t.size()) } -> _Integer_like;
        };

        template <class _Ty, class _UnCV>
        concept _Has_ADL = _Has_class_or_enum_type<_Ty> && !disable_sized_range<_UnCV> && requires(_Ty __t) {
            { _Fake_decay_copy(size(__t)) } -> _Integer_like;
        };

        template <class _Ty>
        concept _Can_difference = requires(_Ty __t) {
            { ::std::ranges:: begin(__t) } -> forward_iterator;
            { ::std::ranges:: end(__t) } -> sized_sentinel_for<decltype(::std::ranges:: begin(__t))>;
        };

        class _Cpo {
        private:
            enum class _St { _None, _Array, _Member, _Non_member, _Subtract };

            template <class _Ty>
            [[nodiscard]] static consteval _Choice_t<_St> _Choose() noexcept {
                ;
                using _UnCV = remove_cvref_t<_Ty>;

                if constexpr (is_array_v<_UnCV>) {
                    if constexpr (extent_v<_UnCV> != 0) {
                        return {_St::_Array, true};
                    } else {
                        return {_St::_None};
                    }
                } else if constexpr (_Has_member<_Ty, _UnCV>) {
                    return {_St::_Member, noexcept(_Fake_decay_copy(::std:: declval<_Ty>().size()))};
                } else if constexpr (_Has_ADL<_Ty, _UnCV>) {
                    return {_St::_Non_member, noexcept(_Fake_decay_copy(size(::std:: declval<_Ty>())))};
                } else if constexpr (_Can_difference<_Ty>) {
                    return {_St::_Subtract,
                        noexcept(::std::ranges:: end(::std:: declval<_Ty>()) - ::std::ranges:: begin(::std:: declval<_Ty>()))};
                } else {
                    return {_St::_None};
                }
            }

            template <class _Ty>
            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty>();

        public:
            
            template <class _Ty>
                requires (_Choice<_Ty&>._Strategy != _St::_None)
            [[nodiscard]] constexpr auto operator()(_Ty&& _Val) const noexcept(_Choice<_Ty&>._No_throw) {
                constexpr _St _Strat = _Choice<_Ty&>._Strategy;

                if constexpr (_Strat == _St::_Array) {
                    
                    return extent_v<remove_cvref_t<_Ty&>>;
                } else if constexpr (_Strat == _St::_Member) {
                    return _Val.size();
                } else if constexpr (_Strat == _St::_Non_member) {
                    return size(_Val);
                } else if constexpr (_Strat == _St::_Subtract) {
                    const auto _Delta = ::std::ranges:: end(_Val) - ::std::ranges:: begin(_Val);
                    return static_cast<_Make_unsigned_like_t<remove_cv_t<decltype(_Delta)>>>(_Delta);
                } else {
                    static_assert(_Always_false<_Ty>, "should be unreachable");
                }
            }
            
        };
    } 

    inline namespace _Cpos {
        inline constexpr _Size::_Cpo size;
    }

    namespace _Empty {
        template <class _Ty>
        concept _Has_member = requires(_Ty __t) {
            static_cast<bool>(__t.empty());
        };

        template <class _Ty>
        concept _Has_size = requires(_Ty __t) {
            ::std::ranges:: size(__t);
        };

        template <class _Ty>
        concept _Can_begin_end = requires(_Ty __t) {
            { ::std::ranges:: begin(__t) } -> forward_iterator;
            ::std::ranges:: end(__t);
        };

        class _Cpo {
        private:
            enum class _St { _None, _Member, _Size, _Compare };

            template <class _Ty>
            [[nodiscard]] static consteval _Choice_t<_St> _Choose() noexcept {
                ;
                if constexpr (is_unbounded_array_v<remove_reference_t<_Ty>>) {
                    return {_St::_None};
                } else if constexpr (_Has_member<_Ty>) {
                    return {_St::_Member, noexcept(static_cast<bool>(::std:: declval<_Ty>().empty()))};
                } else if constexpr (_Has_size<_Ty>) {
                    return {_St::_Size, noexcept(::std::ranges:: size(::std:: declval<_Ty>()))};
                } else if constexpr (_Can_begin_end<_Ty>) {
                    constexpr auto _Nothrow = noexcept(
                        static_cast<bool>(::std::ranges:: begin(::std:: declval<_Ty>()) == ::std::ranges:: end(::std:: declval<_Ty>())));
                    return {_St::_Compare, _Nothrow};
                } else {
                    return {_St::_None};
                }
            }

            template <class _Ty>
            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty>();

        public:
            
            template <class _Ty>
                requires (_Choice<_Ty&>._Strategy != _St::_None)
            [[nodiscard]] constexpr bool operator()(_Ty&& _Val) const noexcept(_Choice<_Ty&>._No_throw) {
                constexpr _St _Strat = _Choice<_Ty&>._Strategy;

                if constexpr (_Strat == _St::_Member) {
                    return static_cast<bool>(_Val.empty());
                } else if constexpr (_Strat == _St::_Size) {
                    return ::std::ranges:: size(_Val) == 0;
                } else if constexpr (_Strat == _St::_Compare) {
                    return static_cast<bool>(::std::ranges:: begin(_Val) == ::std::ranges:: end(_Val));
                } else {
                    static_assert(_Always_false<_Ty>, "should be unreachable");
                }
            }
            
        };
    } 

    inline namespace _Cpos {
        inline constexpr _Empty::_Cpo empty;
    }

    namespace _Data {
        template <class _Ty>
        concept _Points_to_object = is_pointer_v<_Ty> && is_object_v<remove_pointer_t<_Ty>>;

        template <class _Ty>
        concept _Has_member = requires(_Ty __t) {
            { _Fake_decay_copy(__t.data()) } -> _Points_to_object;
        };

        template <class _Ty>
        concept _Has_contiguous_iterator = requires(_Ty __t) {
            { ::std::ranges:: begin(__t) } -> contiguous_iterator;
        };

        class _Cpo {
        private:
            enum class _St { _None, _Member, _Address };

            template <class _Ty>
            [[nodiscard]] static consteval _Choice_t<_St> _Choose() noexcept {
                ;
                if constexpr (_Has_member<_Ty>) {
                    return {_St::_Member, noexcept(::std:: declval<_Ty>().data())};
                } else if constexpr (_Has_contiguous_iterator<_Ty>) {
                    return {_St::_Address, noexcept(::std:: to_address(::std::ranges:: begin(::std:: declval<_Ty>())))};
                } else {
                    return {_St::_None};
                }
            }

            template <class _Ty>
            static constexpr _Choice_t<_St> _Choice = _Choose<_Ty>();

        public:
            
            template <_Should_range_access _Ty>
                requires (_Choice<_Ty&>._Strategy != _St::_None)
            [[nodiscard]] constexpr auto operator()(_Ty&& _Val) const noexcept(_Choice<_Ty&>._No_throw) {
                constexpr _St _Strat = _Choice<_Ty&>._Strategy;

                if constexpr (_Strat == _St::_Member) {
                    return _Val.data();
                } else if constexpr (_Strat == _St::_Address) {
                    return ::std:: to_address(::std::ranges:: begin(_Val));
                } else {
                    static_assert(_Always_false<_Ty>, "should be unreachable");
                }
            }
            
        };
    } 

    inline namespace _Cpos {
        inline constexpr _Data::_Cpo data;
    }

    struct _Cdata_fn {
        
        template <class _Ty, class _CTy = _Const_thru_ref<_Ty>>
        [[nodiscard]] constexpr auto operator()(_Ty&& _Val) const
            noexcept(noexcept(::std::ranges:: data(static_cast<_CTy&&>(_Val))))
            requires requires { ::std::ranges:: data(static_cast<_CTy&&>(_Val)); } {
            return ::std::ranges:: data(static_cast<_CTy&&>(_Val));
        }
        
    };

    inline namespace _Cpos {
        inline constexpr _Cdata_fn cdata;
    }

    template <class _Rng>
    concept sized_range = range<_Rng> && requires(_Rng& __r) {
        ::std::ranges:: size(__r);
    };

    template <sized_range _Rng>
    using range_size_t = decltype(::std::ranges:: size(::std:: declval<_Rng&>()));

    struct view_base {};

    template <template <class...> class _Template, class... _Args>
    void _Derived_from_specialization_impl(const _Template<_Args...>&);

    template <class _Ty, template <class...> class _Template>
    concept _Derived_from_specialization_of = requires(const _Ty& _Obj) {
        _Derived_from_specialization_impl<_Template>(_Obj);
    };

    template <class _Derived>
        requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
    class view_interface;

    template <class _Ty>
    inline constexpr bool enable_view =
        derived_from<_Ty, view_base> || _Derived_from_specialization_of<_Ty, view_interface>;

    template <class _Ty>
    concept view = range<_Ty> && movable<_Ty> && enable_view<_Ty>;

    template <class _Rng, class _Ty>
    concept output_range = range<_Rng> && output_iterator<iterator_t<_Rng>, _Ty>;

    template <class _Rng>
    concept input_range = range<_Rng> && input_iterator<iterator_t<_Rng>>;

    template <class _Rng>
    concept forward_range = range<_Rng> && forward_iterator<iterator_t<_Rng>>;

    template <class _Rng>
    concept bidirectional_range = range<_Rng> && bidirectional_iterator<iterator_t<_Rng>>;

    template <class _Rng>
    concept random_access_range = range<_Rng> && random_access_iterator<iterator_t<_Rng>>;

    template <class _Rng>
    concept contiguous_range = range<_Rng> && contiguous_iterator<iterator_t<_Rng>> && requires(_Rng& __r) {
        { ::std::ranges:: data(__r) } -> same_as<add_pointer_t<range_reference_t<_Rng>>>;
    };

    class _Not_quite_object {
    public:
        
        
        struct _Construct_tag {
            explicit _Construct_tag() = default;
        };

        _Not_quite_object() = delete;

        constexpr explicit _Not_quite_object(_Construct_tag) noexcept {}

        _Not_quite_object(const _Not_quite_object&) = delete;
        _Not_quite_object& operator=(const _Not_quite_object&) = delete;

        void operator&() const = delete;

    protected:
        ~_Not_quite_object() = default;
    };

    class _Advance_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <input_or_output_iterator _It>
        constexpr void operator()(_It& _Where, iter_difference_t<_It> _Off) const {
            if constexpr (random_access_iterator<_It>) {
                _Where += _Off;
            } else {
                if constexpr (!bidirectional_iterator<_It>) {
                    ;
                }

                decltype(auto) _UWhere      = _Get_unwrapped_n(::std:: move(_Where), _Off);
                constexpr bool _Need_rewrap = !is_reference_v<decltype(_Get_unwrapped_n(::std:: move(_Where), _Off))>;

                if constexpr (bidirectional_iterator<_It>) {
                    for (; _Off < 0; ++_Off) {
                        --_UWhere;
                    }
                }

                for (; _Off > 0; --_Off) {
                    ++_UWhere;
                }

                if constexpr (_Need_rewrap) {
                    _Seek_wrapped(_Where, ::std:: move(_UWhere));
                }
            }
        }

        template <input_or_output_iterator _It, sentinel_for<_It> _Se>
        constexpr void operator()(_It& _Where, _Se _Last) const {
            if constexpr (assignable_from<_It&, _Se>) {
                _Where = static_cast<_Se&&>(_Last);
            } else if constexpr (sized_sentinel_for<_Se, _It>) {
                (*this)(_Where, _Last - _Where);
            } else {
                _Adl_verify_range(_Where, _Last);

                decltype(auto) _UWhere      = _Get_unwrapped(static_cast<_It&&>(_Where));
                constexpr bool _Need_rewrap = !is_reference_v<decltype(_Get_unwrapped(static_cast<_It&&>(_Where)))>;
                decltype(auto) _ULast       = _Get_unwrapped(static_cast<_Se&&>(_Last));

                while (_UWhere != _ULast) {
                    ++_UWhere;
                }

                if constexpr (_Need_rewrap) {
                    _Seek_wrapped(_Where, ::std:: move(_UWhere));
                }
            }
        }

        template <input_or_output_iterator _It, sentinel_for<_It> _Se>
        constexpr iter_difference_t<_It> operator()(_It& _Where, iter_difference_t<_It> _Off, _Se _Last) const {
            if constexpr (sized_sentinel_for<_Se, _It>) {
                const iter_difference_t<_It> _Delta = _Last - _Where;
                if ((_Off < 0 && _Off <= _Delta) || (_Off > 0 && _Off >= _Delta)) {
                    if constexpr (assignable_from<_It&, _Se>) {
                        _Where = static_cast<_Se&&>(_Last);
                    } else {
                        (*this)(_Where, _Delta);
                    }
                    return _Off - _Delta;
                }

                (*this)(_Where, _Off);
                return 0;
            } else {
                
                if constexpr (bidirectional_iterator<_It>) {
                    for (; _Off < 0 && _Where != _Last; ++_Off) {
                        --_Where;
                    }
                } else {
                    ;
                }

                for (; _Off > 0 && _Where != _Last; --_Off) {
                    ++_Where;
                }

                return _Off;
            }
        }
    };

    inline constexpr _Advance_fn advance{_Not_quite_object::_Construct_tag{}};

    class _Distance_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <class _It, sentinel_for<decay_t<_It>> _Se>
        [[nodiscard]] constexpr iter_difference_t<decay_t<_It>> operator()(_It&& _Raw_first, _Se _Last) const
            noexcept(_Nothrow_dist<_It, _Se>)  {
            if constexpr (sized_sentinel_for<_Se, decay_t<_It>>) {
                return _Last - static_cast<const decay_t<_It>&>(_Raw_first); 
            } else {
                auto _First = ::std:: forward<_It>(_Raw_first);
                _Adl_verify_range(_First, _Last);
                return _Distance_unchecked(_Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)));
            }
        }

        template <range _Rng>
        [[nodiscard]] constexpr range_difference_t<_Rng> operator()(_Rng&& _Range) const
            noexcept(_Nothrow_size<_Rng>)  {
            if constexpr (sized_range<_Rng>) {
                return static_cast<range_difference_t<_Rng>>(::std::ranges:: size(_Range));
            } else {
                return _Distance_unchecked(_Ubegin(_Range), _Uend(_Range));
            }
        }

    private:
        template <class _It, class _Se>
        static constexpr bool _Nothrow_dist = false;

        template <class _It, sized_sentinel_for<decay_t<_It>> _Se>
        static constexpr bool _Nothrow_dist<_It, _Se> = noexcept(
            ::std:: declval<_Se&>() - ::std:: declval<const decay_t<_It>&>());

        template <class _It, class _Se>
        [[nodiscard]] static constexpr iter_difference_t<_It> _Distance_unchecked(_It _First, const _Se _Last) noexcept(
            noexcept(++_First != _Last)) {
            ;

            iter_difference_t<_It> _Count = 0;
            for (; _First != _Last; ++_First) {
                ++_Count;
            }

            return _Count;
        }

        template <class _Rng>
        static constexpr bool _Nothrow_size = noexcept(
            _Distance_unchecked(_Ubegin(::std:: declval<_Rng&>()), _Uend(::std:: declval<_Rng&>())));

        template <sized_range _Rng>
        static constexpr bool _Nothrow_size<_Rng> = noexcept(::std::ranges:: size(::std:: declval<_Rng&>()));
    };

    inline constexpr _Distance_fn distance{_Not_quite_object::_Construct_tag{}};

    class _Ssize_fn {
    public:
        
        template <class _Rng>
        [[nodiscard]] constexpr auto operator()(_Rng&& _Range) const requires requires { ::std::ranges:: size(_Range); } {
            using _Sty = _Make_signed_like_t<decltype(::std::ranges:: size(_Range))>;
            using _Ty  = common_type_t<conditional_t<is_integral_v<_Sty>, ptrdiff_t, _Sty>, _Sty>;
            return static_cast<_Ty>(::std::ranges:: size(_Range));
        }
        
    };

    inline namespace _Cpos {
        inline constexpr _Ssize_fn ssize;
    }

    class _Next_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <input_or_output_iterator _It>
        [[nodiscard]] constexpr _It operator()(_It _Where) const {
            ++_Where;
            return _Where;
        }

        template <input_or_output_iterator _It>
        [[nodiscard]] constexpr _It operator()(_It _Where, const iter_difference_t<_It> _Off) const {
            ::std::ranges:: advance(_Where, _Off);
            return _Where;
        }

        template <input_or_output_iterator _It, sentinel_for<_It> _Se>
        [[nodiscard]] constexpr _It operator()(_It _Where, _Se _Last) const {
            ::std::ranges:: advance(_Where, static_cast<_Se&&>(_Last));
            return _Where;
        }

        template <input_or_output_iterator _It, sentinel_for<_It> _Se>
        [[nodiscard]] constexpr _It operator()(_It _Where, const iter_difference_t<_It> _Off, _Se _Last) const {
            ::std::ranges:: advance(_Where, _Off, static_cast<_Se&&>(_Last));
            return _Where;
        }
    };

    inline constexpr _Next_fn next{_Not_quite_object::_Construct_tag{}};

    class _Prev_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <bidirectional_iterator _It>
        [[nodiscard]] constexpr _It operator()(_It _Where) const {
            --_Where;
            return _Where;
        }

        template <bidirectional_iterator _It>
        [[nodiscard]] constexpr _It operator()(_It _Where, const iter_difference_t<_It> _Off) const {
            ;
            ::std::ranges:: advance(_Where, -_Off);
            return _Where;
        }

        template <bidirectional_iterator _It>
        [[nodiscard]] constexpr _It operator()(_It _Where, const iter_difference_t<_It> _Off, _It _Last) const {
            ;
            ::std::ranges:: advance(_Where, -_Off, static_cast<_It&&>(_Last));
            return _Where;
        }
    };

    inline constexpr _Prev_fn prev{_Not_quite_object::_Construct_tag{}};

    template <forward_iterator _It, sentinel_for<_It> _Se>
    [[nodiscard]] constexpr _It _Find_last_iterator(
        const _It& _First, const _Se& _Last, const iter_difference_t<_It> _Count) {
        
        ;
        if constexpr (is_same_v<_It, _Se>) {
            return _Last;
        } else {
            return ::std::ranges:: next(_First, _Count);
        }
    }

    struct equal_to {
        
        template <class _Ty1, class _Ty2>
            requires equality_comparable_with<_Ty1, _Ty2>
        [[nodiscard]] constexpr bool operator()(_Ty1&& _Left, _Ty2&& _Right) const noexcept(noexcept(
            static_cast<bool>(static_cast<_Ty1&&>(_Left) == static_cast<_Ty2&&>(_Right))))  {
            return static_cast<bool>(static_cast<_Ty1&&>(_Left) == static_cast<_Ty2&&>(_Right));
        }
        

        using is_transparent = int;
    };

    struct less {
        
        template <class _Ty1, class _Ty2>
            requires totally_ordered_with<_Ty1, _Ty2>
        [[nodiscard]] constexpr bool operator()(_Ty1&& _Left, _Ty2&& _Right) const noexcept(noexcept(
            static_cast<bool>(static_cast<_Ty1&&>(_Left) < static_cast<_Ty2&&>(_Right))))  {
            return static_cast<bool>(static_cast<_Ty1&&>(_Left) < static_cast<_Ty2&&>(_Right));
        }
        

        using is_transparent = int;
    };

    struct greater {
        
        template <class _Ty1, class _Ty2>
            requires totally_ordered_with<_Ty1, _Ty2>
        [[nodiscard]] constexpr bool operator()(_Ty1&& _Left, _Ty2&& _Right) const noexcept(noexcept(
            static_cast<bool>(static_cast<_Ty2&&>(_Right) < static_cast<_Ty1&&>(_Left))))  {
            return static_cast<bool>(static_cast<_Ty2&&>(_Right) < static_cast<_Ty1&&>(_Left));
        }
        

        using is_transparent = int;
    };

    template <class _Rng>
    concept common_range = range<_Rng> && same_as<iterator_t<_Rng>, sentinel_t<_Rng>>;

    template <class _Ty>
    concept _Can_empty = requires(_Ty __t) {
        ::std::ranges:: empty(__t);
    };

    
    template <class _Derived>
        requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
    class view_interface {
    private:
        [[nodiscard]] constexpr _Derived& _Cast() noexcept {
            static_assert(derived_from<_Derived, view_interface>,
                "view_interface's template argument D must derive from view_interface<D> (N4849 [view.interface]/2).");
            static_assert(view<_Derived>,
                "view_interface's template argument must model the view concept (N4849 [view.interface]/2).");
            return static_cast<_Derived&>(*this);
        }

        [[nodiscard]] constexpr const _Derived& _Cast() const noexcept {
            static_assert(derived_from<_Derived, view_interface>,
                "view_interface's template argument D must derive from view_interface<D> (N4849 [view.interface]/2).");
            static_assert(view<_Derived>,
                "view_interface's template argument must model the view concept (N4849 [view.interface]/2).");
            return static_cast<const _Derived&>(*this);
        }

    public:


        [[nodiscard]] constexpr bool empty() requires forward_range<_Derived>
#line 3096 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
        {
            auto& _Self = _Cast();
            return ::std::ranges:: begin(_Self) == ::std::ranges:: end(_Self);
        }


        [[nodiscard]] constexpr bool empty() const requires forward_range<const _Derived>
#line 3107 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
        {
            auto& _Self = _Cast();
            return ::std::ranges:: begin(_Self) == ::std::ranges:: end(_Self);
        }


        constexpr explicit operator bool() requires _Can_empty<_Derived>
#line 3118 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
        {
            return !::std::ranges:: empty(_Cast());
        }


        constexpr explicit operator bool() const requires _Can_empty<const _Derived>
#line 3128 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
        {
            return !::std::ranges:: empty(_Cast());
        }


        [[nodiscard]] constexpr auto data() requires contiguous_iterator<iterator_t<_Derived>>
#line 3138 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
        {
            return ::std:: to_address(::std::ranges:: begin(_Cast()));
        }


        [[nodiscard]] constexpr auto data() const
            requires range<const _Derived> && contiguous_iterator<iterator_t<const _Derived>>
#line 3150 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
        {
            return ::std:: to_address(::std::ranges:: begin(_Cast()));
        }


        [[nodiscard]] constexpr auto size()
            requires forward_range<_Derived> && sized_sentinel_for<sentinel_t<_Derived>, iterator_t<_Derived>>
#line 3162 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
        {
            auto& _Self = _Cast();
            return ::std::ranges:: end(_Self) - ::std::ranges:: begin(_Self);
        }


        [[nodiscard]] constexpr auto size() const requires forward_range<const _Derived>
            && sized_sentinel_for<sentinel_t<const _Derived>, iterator_t<const _Derived>>
#line 3175 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
        {
            auto& _Self = _Cast();
            return ::std::ranges:: end(_Self) - ::std::ranges:: begin(_Self);
        }


        [[nodiscard]] constexpr decltype(auto) front() requires forward_range<_Derived>
#line 3186 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
        {
            auto& _Self = _Cast();


#line 3191 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
            return *::std::ranges:: begin(_Self);
        }


        [[nodiscard]] constexpr decltype(auto) front() const requires forward_range<const _Derived>
#line 3200 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
        {
            auto& _Self = _Cast();


#line 3205 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
            return *::std::ranges:: begin(_Self);
        }


        [[nodiscard]] constexpr decltype(auto) back() requires bidirectional_range<_Derived> && common_range<_Derived>
#line 3214 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
        {
            auto& _Self = _Cast();


#line 3219 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
            auto _Last = ::std::ranges:: end(_Self);
            return *--_Last;
        }


        [[nodiscard]] constexpr decltype(auto) back() const
            requires bidirectional_range<const _Derived> && common_range<const _Derived>
#line 3231 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
        {
            auto& _Self = _Cast();


#line 3236 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
            auto _Last = ::std::ranges:: end(_Self);
            return *--_Last;
        }

        template <random_access_range _Rng = _Derived>
        [[nodiscard]] constexpr decltype(auto) operator[](const range_difference_t<_Rng> _Idx) {
            auto& _Self = _Cast();


#line 3250 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
            return ::std::ranges:: begin(_Self)[_Idx];
        }

        template <random_access_range _Rng = const _Derived>
        [[nodiscard]] constexpr decltype(auto) operator[](const range_difference_t<_Rng> _Idx) const {
            auto& _Self = _Cast();


#line 3263 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
            return ::std::ranges:: begin(_Self)[_Idx];
        }
    };

    enum class subrange_kind : bool { unsized, sized };
    
} 


template <size_t _Index, class... _Types>
[[nodiscard]] constexpr tuple_element_t<_Index, tuple<_Types...>>& get(tuple<_Types...>& _Tuple) noexcept;
template <size_t _Index, class... _Types>
[[nodiscard]] constexpr const tuple_element_t<_Index, tuple<_Types...>>& get(const tuple<_Types...>& _Tuple) noexcept;
template <size_t _Index, class... _Types>
[[nodiscard]] constexpr tuple_element_t<_Index, tuple<_Types...>>&& get(tuple<_Types...>&& _Tuple) noexcept;
template <size_t _Index, class... _Types>
[[nodiscard]] constexpr const tuple_element_t<_Index, tuple<_Types...>>&& get(const tuple<_Types...>&& _Tuple) noexcept;

namespace ranges {
    
    template <class _From, class _To>
    concept _Uses_nonqualification_pointer_conversion =
        is_pointer_v<_From> && is_pointer_v<_To>
        && !convertible_to<remove_pointer_t<_From>(*)[], remove_pointer_t<_To>(*)[]>;

    template <class _From, class _To>
    concept _Convertible_to_non_slicing = convertible_to<_From, _To>
        && !_Uses_nonqualification_pointer_conversion<decay_t<_From>, decay_t<_To>>;

    template <class _Ty>
    concept _Pair_like = !is_reference_v<_Ty> && requires(_Ty __t) {
        typename tuple_size<_Ty>::type;
        requires derived_from<tuple_size<_Ty>, integral_constant<size_t, 2>>;
        typename tuple_element_t<0, remove_const_t<_Ty>>;
        typename tuple_element_t<1, remove_const_t<_Ty>>;
        { ::std:: get<0>(__t) } -> convertible_to<const tuple_element_t<0, _Ty>&>;
        { ::std:: get<1>(__t) } -> convertible_to<const tuple_element_t<1, _Ty>&>;
    };

    template <class _Ty, class _First, class _Second>
    concept _Pair_like_convertible_from = !range<_Ty> && _Pair_like<_Ty>
        && constructible_from<_Ty, _First, _Second>
        && _Convertible_to_non_slicing<_First, tuple_element_t<0, _Ty>>
        && convertible_to<_Second, tuple_element_t<1, _Ty>>;

    template <input_or_output_iterator _It, sentinel_for<_It> _Se = _It,
        subrange_kind _Ki = sized_sentinel_for<_Se, _It> ? subrange_kind::sized : subrange_kind::unsized>
        requires (_Ki == subrange_kind::sized || !sized_sentinel_for<_Se, _It>)
    class subrange;
    

    template <class _It, class _Se, subrange_kind _Ki,
        bool _Store = _Ki == subrange_kind::sized && !sized_sentinel_for<_Se, _It>>
    class _Subrange_base : public view_interface<subrange<_It, _Se, _Ki>> { 
    protected:
        using _Size_type                  = _Make_unsigned_like_t<iter_difference_t<_It>>;
        static constexpr bool _Store_size = true;

        _Size_type _Size = 0;

    public:
        _Subrange_base() = default;
        constexpr explicit _Subrange_base(const _Size_type& _Size_) noexcept : _Size(_Size_) {}
    };

    template <class _It, class _Se, subrange_kind _Ki>
    class _Subrange_base<_It, _Se, _Ki, false> : public view_interface<subrange<_It, _Se, _Ki>> {
    protected:
        using _Size_type                  = _Make_unsigned_like_t<iter_difference_t<_It>>;
        static constexpr bool _Store_size = false;

    public:
        _Subrange_base() = default;
        constexpr explicit _Subrange_base(const _Size_type&) noexcept {}
    };

    
    template <input_or_output_iterator _It, sentinel_for<_It> _Se, subrange_kind _Ki>
        requires (_Ki == subrange_kind::sized || !sized_sentinel_for<_Se, _It>)
    class subrange : public _Subrange_base<_It, _Se, _Ki> {
        
    private:
        using _Mybase = _Subrange_base<_It, _Se, _Ki>;
        using _Mybase::_Store_size;
        using typename _Mybase::_Size_type;

        
         _It _First{};
         _Se _Last{};
        

        template <class _Rng>
        constexpr subrange(true_type, _Rng&& _Val)
            : subrange(::std:: forward<_Rng>(_Val), static_cast<_Size_type>(::std::ranges:: size(_Val))) {
            
            ;
        }

        template <class _Rng>
        constexpr subrange(false_type, _Rng&& _Val) : subrange(::std::ranges:: begin(_Val), ::std::ranges:: end(_Val)) {
            
            ;
        }

    public:
        
        subrange() requires default_initializable<_It> = default;

        template <_Convertible_to_non_slicing<_It> _It2>
        constexpr subrange(_It2 _First_, _Se _Last_) requires (!_Store_size)
            : _First(::std:: move(_First_)), _Last(::std:: move(_Last_)) {}

        template <_Convertible_to_non_slicing<_It> _It2>
        constexpr subrange(_It2 _First_, _Se _Last_, const _Size_type _Size_) requires (_Ki == subrange_kind::sized)
            : _Mybase(_Size_), _First(::std:: move(_First_)), _Last(::std:: move(_Last_)) {
            if constexpr (sized_sentinel_for<_Se, _It>) {
                ;
#line 3383 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
            }
        }

        template <_Not_same_as<subrange> _Rng>
            requires borrowed_range<_Rng>
                && _Convertible_to_non_slicing<iterator_t<_Rng>, _It>
                && convertible_to<sentinel_t<_Rng>, _Se>
        constexpr subrange(_Rng&& _Val) requires (!_Store_size || sized_range<_Rng>)
            : subrange{bool_constant<_Store_size>{}, ::std:: forward<_Rng>(_Val)} {}

        template <borrowed_range _Rng>
            requires _Convertible_to_non_slicing<iterator_t<_Rng>, _It> && convertible_to<sentinel_t<_Rng>, _Se>
        constexpr subrange(_Rng&& _Val, const _Size_type _Count) requires (_Ki == subrange_kind::sized)
            : subrange{::std::ranges:: begin(_Val), ::std::ranges:: end(_Val), _Count} {}

        template <_Not_same_as<subrange> _Pair_like>
            requires _Pair_like_convertible_from<_Pair_like, const _It&, const _Se&>
        constexpr operator _Pair_like() const {
            return _Pair_like(_First, _Last);
        }
        

        [[nodiscard]] constexpr _It begin() const requires copyable<_It> {
            return _First;
        }
        
        [[nodiscard]] constexpr _It begin() requires (!copyable<_It>) {
            
            return ::std:: move(_First);
        }

        [[nodiscard]] constexpr _Se end() const {
            return _Last;
        }

        [[nodiscard]] constexpr bool empty() const {
            return _First == _Last;
        }

        
        [[nodiscard]] constexpr _Size_type size() const requires (_Ki == subrange_kind::sized) {
            
            if constexpr (_Store_size) {
                return this->_Size;
            } else {
                return static_cast<_Size_type>(_Last - _First);
            }
        }

        [[nodiscard]] constexpr subrange next() const& requires forward_iterator<_It> {
            auto _Tmp = *this;
            if (_Tmp._First != _Tmp._Last) {
                ++_Tmp._First;
                if constexpr (_Store_size) {
                    --_Tmp._Size;
                }
            }
            return _Tmp;
        }
        [[nodiscard]] constexpr subrange next(const iter_difference_t<_It> _Count) const& requires forward_iterator<_It> {
            auto _Tmp = *this;
            _Tmp.advance(_Count);
            return _Tmp;
        }

        [[nodiscard]] constexpr subrange next() && {
            if (_First != _Last) {
                ++_First;
                if constexpr (_Store_size) {
                    --this->_Size;
                }
            }
            return ::std:: move(*this);
        }
        [[nodiscard]] constexpr subrange next(const iter_difference_t<_It> _Count) && {
            advance(_Count);
            return ::std:: move(*this);
        }

        [[nodiscard]] constexpr subrange prev() const requires bidirectional_iterator<_It> {
            auto _Tmp = *this;
            --_Tmp._First;
            if constexpr (_Store_size) {
                ++_Tmp._Size;
            }
            return _Tmp;
        }
        [[nodiscard]] constexpr subrange prev(
            const iter_difference_t<_It> _Count) const requires bidirectional_iterator<_It> {
            auto _Tmp = *this;
            _Tmp.advance(-_Count);
            return _Tmp;
        }

        constexpr subrange& advance(const iter_difference_t<_It> _Count) {
            if constexpr (bidirectional_iterator<_It>) {
                if (_Count < 0) {
                    ::std::ranges:: advance(_First, _Count);
                    if constexpr (_Store_size) {
                        this->_Size += static_cast<_Size_type>(-_Count);
                    }
                    return *this;
                }
            }

            const auto _Remainder = ::std::ranges:: advance(_First, _Count, _Last);
            if constexpr (_Store_size) {
                this->_Size -= static_cast<_Size_type>(_Count - _Remainder);
            }
            return *this;
        }
    };

    template <input_or_output_iterator _It, sentinel_for<_It> _Se>
    subrange(_It, _Se) -> subrange<_It, _Se>;

    template <input_or_output_iterator _It, sentinel_for<_It> _Se>
    subrange(_It, _Se, _Make_unsigned_like_t<iter_difference_t<_It>>) -> subrange<_It, _Se, subrange_kind::sized>;

    template <borrowed_range _Rng>
    subrange(_Rng&&) -> subrange<iterator_t<_Rng>, sentinel_t<_Rng>,
        (sized_range<_Rng> || sized_sentinel_for<sentinel_t<_Rng>, iterator_t<_Rng>>) ? subrange_kind::sized
                                                                                      : subrange_kind::unsized>;

    template <borrowed_range _Rng>
    subrange(_Rng&&, _Make_unsigned_like_t<range_difference_t<_Rng>>)
        -> subrange<iterator_t<_Rng>, sentinel_t<_Rng>, subrange_kind::sized>;

    template <class _It, class _Se, subrange_kind _Ki>
    inline constexpr bool enable_borrowed_range<subrange<_It, _Se, _Ki>> = true;

    
    template <size_t _Idx, class _It, class _Se, subrange_kind _Ki>
        requires ((_Idx == 0 && copyable<_It>) || _Idx == 1)
    [[nodiscard]] constexpr auto get(const subrange<_It, _Se, _Ki>& _Val) {
        if constexpr (_Idx == 0) {
            return _Val.begin();
        } else {
            return _Val.end();
        }
    }

    template <size_t _Idx, class _It, class _Se, subrange_kind _Ki>
        requires (_Idx < 2)
    [[nodiscard]] constexpr auto get(subrange<_It, _Se, _Ki>&& _Val) {
        if constexpr (_Idx == 0) {
            return _Val.begin();
        } else {
            return _Val.end();
        }
    }
    
} 

using ranges::get;

template <class _It, class _Se, ranges::subrange_kind _Ki>
struct tuple_size<ranges::subrange<_It, _Se, _Ki>> : integral_constant<size_t, 2> {};

template <class _It, class _Se, ranges::subrange_kind _Ki>
struct tuple_element<0, ranges::subrange<_It, _Se, _Ki>> {
    using type = _It;
};

template <class _It, class _Se, ranges::subrange_kind _Ki>
struct tuple_element<1, ranges::subrange<_It, _Se, _Ki>> {
    using type = _Se;
};

template <class _It, class _Se, ranges::subrange_kind _Ki>
struct tuple_element<0, const ranges::subrange<_It, _Se, _Ki>> {
    using type = _It;
};

template <class _It, class _Se, ranges::subrange_kind _Ki>
struct tuple_element<1, const ranges::subrange<_It, _Se, _Ki>> {
    using type = _Se;
};

namespace ranges {
    struct dangling {
        constexpr dangling() noexcept = default;
        template <class... _Args>
        constexpr dangling(_Args&&...) noexcept {}
    };

    template <range _Rng>
    using borrowed_iterator_t = conditional_t<borrowed_range<_Rng>, iterator_t<_Rng>, dangling>;

    template <range _Rng>
    using borrowed_subrange_t = conditional_t<borrowed_range<_Rng>, subrange<iterator_t<_Rng>>, dangling>;
} 
#line 3576 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

struct _Container_proxy;
struct _Iterator_base12;

struct _Default_sentinel {}; 


template <semiregular>
class move_sentinel;

template <class>
struct _Move_iterator_category {};


template <class _Iter>
    requires requires { typename _Iter_cat_t<_Iter>; }
struct _Move_iterator_category<_Iter> {
    using iterator_category = conditional_t<derived_from<_Iter_cat_t<_Iter>, random_access_iterator_tag>,
        random_access_iterator_tag, _Iter_cat_t<_Iter>>;
};


#line 3603 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class _Iter>
class move_iterator : public _Move_iterator_category<_Iter> {
public:
    using iterator_type   = _Iter;
    using value_type      = _Iter_value_t<_Iter>;
    using difference_type = _Iter_diff_t<_Iter>;
    using pointer         = _Iter;


    using iterator_concept = input_iterator_tag;
    using reference        = iter_rvalue_reference_t<_Iter>;


#line 3619 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

    constexpr move_iterator() = default;

    constexpr explicit move_iterator(_Iter _Right) noexcept(is_nothrow_move_constructible_v<_Iter>) 
        : _Current(::std:: move(_Right)) {}

    
    template <class _Other>

        requires (!is_same_v<_Other, _Iter>) && convertible_to<const _Other&, _Iter>
#line 3630 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
    constexpr move_iterator(const move_iterator<_Other>& _Right) noexcept(
        is_nothrow_constructible_v<_Iter, const _Other&>) 
        : _Current(_Right.base()) {}

    template <class _Other>

        requires (!is_same_v<_Other, _Iter>) && convertible_to<const _Other&, _Iter>
            && assignable_from<_Iter&, const _Other&>
#line 3639 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
    constexpr move_iterator& operator=(const move_iterator<_Other>& _Right) noexcept(
        is_nothrow_assignable_v<_Iter&, const _Other&>)  {
        _Current = _Right.base();
        return *this;
    }
    

    [[nodiscard]] constexpr const iterator_type& base() const& noexcept {
        return _Current;
    }
    [[nodiscard]] constexpr iterator_type base() && noexcept(is_nothrow_move_constructible_v<_Iter>)  {
        return ::std:: move(_Current);
    }


#line 3658 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

    [[nodiscard]] constexpr reference operator*() const {

        return ::std::ranges:: iter_move(_Current);


#line 3665 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
    }

    [[deprecated("warning STL4031: " "std::move_iterator::operator->() is deprecated in C++20. " "You can define _SILENCE_CXX20_MOVE_ITERATOR_ARROW_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] [[nodiscard]] constexpr pointer operator->() const {
        return _Current;
    }

    constexpr move_iterator& operator++() {
        ++_Current;
        return *this;
    }

    constexpr auto operator++(int) {

        if constexpr (forward_iterator<_Iter>) {
#line 3680 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
            move_iterator _Tmp = *this;
            ++_Current;
            return _Tmp;

        } else {
            ++_Current;
        }
#line 3688 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
    }

    constexpr move_iterator& operator--() {
        --_Current;
        return *this;
    }

    constexpr move_iterator operator--(int) {
        move_iterator _Tmp = *this;
        --_Current;
        return _Tmp;
    }

    template <class _Iter2 = _Iter>
    [[nodiscard]] auto operator==(_Default_sentinel _Sentinel) const noexcept
        -> decltype(::std:: declval<const _Iter2&>() == _Sentinel) {
        return _Current == _Sentinel;
    }

    template <class _Iter2 = _Iter>
    [[nodiscard]] auto operator!=(_Default_sentinel _Sentinel) const noexcept
        -> decltype(::std:: declval<const _Iter2&>() != _Sentinel) {
        return _Current != _Sentinel;
    }

    [[nodiscard]] constexpr move_iterator operator+(const difference_type _Off) const {
        return move_iterator(_Current + _Off);
    }

    constexpr move_iterator& operator+=(const difference_type _Off) {
        _Current += _Off;
        return *this;
    }

    [[nodiscard]] constexpr move_iterator operator-(const difference_type _Off) const {
        return move_iterator(_Current - _Off);
    }

    constexpr move_iterator& operator-=(const difference_type _Off) {
        _Current -= _Off;
        return *this;
    }

    [[nodiscard]] constexpr reference operator[](const difference_type _Off) const {

        return ::std::ranges:: iter_move(_Current + _Off);


#line 3737 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
    }


    template <sentinel_for<_Iter> _Sent>
    [[nodiscard]] friend constexpr bool operator==(const move_iterator& _Left, const move_sentinel<_Sent>& _Right) {
        return _Left._Current == _Right._Get_last();
    }

    template <sized_sentinel_for<_Iter> _Sent>
    [[nodiscard]] friend constexpr difference_type operator-(
        const move_sentinel<_Sent>& _Left, const move_iterator& _Right) {
        return _Left._Get_last() - _Right._Current;
    }

    template <sized_sentinel_for<_Iter> _Sent>
    [[nodiscard]] friend constexpr difference_type operator-(
        const move_iterator& _Left, const move_sentinel<_Sent>& _Right) {
        return _Left._Current - _Right._Get_last();
    }

    [[nodiscard]] friend constexpr reference iter_move(const move_iterator& _It)


        noexcept(noexcept(::std::ranges:: iter_move(_It._Current)))
#line 3763 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
    {
        return ::std::ranges:: iter_move(_It._Current);
    }

    template <indirectly_swappable<_Iter> _Iter2>
    friend constexpr void iter_swap(const move_iterator& _Left, const move_iterator<_Iter2>& _Right)


        noexcept(noexcept(::std::ranges:: iter_swap(_Left._Current, _Right.base())))
#line 3774 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
    {
        ::std::ranges:: iter_swap(_Left._Current, _Right.base());
    }
#line 3778 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

    template <class _Iter2, enable_if_t<_Range_verifiable_v<_Iter, _Iter2>, int> = 0>
    friend constexpr void _Verify_range(const move_iterator& _First, const move_iterator<_Iter2>& _Last) {
        _Verify_range(_First._Current, _Last.base());
    }

    template <sentinel_for<_Iter> _Sent, enable_if_t<_Range_verifiable_v<_Iter, _Sent>, int> = 0>
    friend constexpr void _Verify_range(const move_iterator& _First, const move_sentinel<_Sent>& _Last) {
        _Verify_range(_First._Current, _Last._Get_last());
    }
#line 3789 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

    using _Prevent_inheriting_unwrap = move_iterator;

    template <class _Iter2 = iterator_type, enable_if_t<_Offset_verifiable_v<_Iter2>, int> = 0>
    constexpr void _Verify_offset(const difference_type _Off) const {
        _Current._Verify_offset(_Off);
    }

    template <class _Iter2 = iterator_type, enable_if_t<_Unwrappable_v<const _Iter2&>, int> = 0>
    [[nodiscard]] constexpr move_iterator<_Unwrapped_t<const _Iter2&>> _Unwrapped() const& {
        return static_cast<move_iterator<_Unwrapped_t<const _Iter2&>>>(_Current._Unwrapped());
    }
    template <class _Iter2 = iterator_type, enable_if_t<_Unwrappable_v<_Iter2>, int> = 0>
    [[nodiscard]] constexpr move_iterator<_Unwrapped_t<_Iter2>> _Unwrapped() && {
        return static_cast<move_iterator<_Unwrapped_t<_Iter2>>>(::std:: move(_Current)._Unwrapped());
    }

    static constexpr bool _Unwrap_when_unverified = _Do_unwrap_when_unverified_v<iterator_type>;

    template <class _Src, enable_if_t<_Wrapped_seekable_v<iterator_type, const _Src&>, int> = 0>
    constexpr void _Seek_to(const move_iterator<_Src>& _It) {
        _Current._Seek_to(_It.base());
    }
    template <class _Src, enable_if_t<_Wrapped_seekable_v<iterator_type, _Src>, int> = 0>
    constexpr void _Seek_to(move_iterator<_Src>&& _It) {
        _Current._Seek_to(::std:: move(_It).base());
    }

private:
    iterator_type _Current{};
};

template <class _Iter1, class _Iter2>
[[nodiscard]] constexpr bool operator==(const move_iterator<_Iter1>& _Left, const move_iterator<_Iter2>& _Right)

    
    requires requires {
        { _Left.base() == _Right.base() } -> _Implicitly_convertible_to<bool>;
    }

#line 3830 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
{ return _Left.base() == _Right.base(); }


#line 3838 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class _Iter1, class _Iter2>
[[nodiscard]] constexpr bool operator<(const move_iterator<_Iter1>& _Left, const move_iterator<_Iter2>& _Right)

    
    requires requires {
        { _Left.base() < _Right.base() } -> _Implicitly_convertible_to<bool>;
    }

#line 3848 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
{ return _Left.base() < _Right.base(); }

template <class _Iter1, class _Iter2>
[[nodiscard]] constexpr bool operator>(const move_iterator<_Iter1>& _Left, const move_iterator<_Iter2>& _Right)

    
    requires requires { _Right < _Left; }

#line 3857 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
{ return _Right < _Left; }

template <class _Iter1, class _Iter2>
[[nodiscard]] constexpr bool operator<=(const move_iterator<_Iter1>& _Left, const move_iterator<_Iter2>& _Right)

    
    requires requires { _Right < _Left; }

#line 3866 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
{ return !(_Right < _Left); }

template <class _Iter1, class _Iter2>
[[nodiscard]] constexpr bool operator>=(const move_iterator<_Iter1>& _Left, const move_iterator<_Iter2>& _Right)

    
    requires requires { _Left < _Right; }

#line 3875 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
{ return !(_Left < _Right); }


template <class _Iter1, three_way_comparable_with<_Iter1> _Iter2>
[[nodiscard]] constexpr compare_three_way_result_t<_Iter1, _Iter2> operator<=>(
    const move_iterator<_Iter1>& _Left, const move_iterator<_Iter2>& _Right) {
    return _Left.base() <=> _Right.base();
}
#line 3884 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class _Iter1, class _Iter2>
[[nodiscard]] constexpr auto operator-(const move_iterator<_Iter1>& _Left, const move_iterator<_Iter2>& _Right)
    -> decltype(_Left.base() - _Right.base()) {
    return _Left.base() - _Right.base();
}

template <class _Iter>
[[nodiscard]] constexpr move_iterator<_Iter> operator+(
    typename move_iterator<_Iter>::difference_type _Off, const move_iterator<_Iter>& _Right)

    
    requires requires {
        { _Right.base() + _Off } -> same_as<_Iter>;
    }

#line 3901 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
{ return move_iterator<_Iter>{_Right.base() + _Off}; }

template <class _Iter>
[[nodiscard]] constexpr move_iterator<_Iter> make_move_iterator(_Iter _It) { 
    return move_iterator<_Iter>(::std:: move(_It));
}


struct default_sentinel_t {};

inline constexpr default_sentinel_t default_sentinel{};

struct unreachable_sentinel_t;
namespace _Unreachable_sentinel_detail {
    struct _Base {
        template <weakly_incrementable _Winc>
        [[nodiscard]] friend constexpr bool operator==(const unreachable_sentinel_t&, const _Winc&) noexcept {
            return false;
        }
    };
} 
struct unreachable_sentinel_t : _Unreachable_sentinel_detail::_Base {}; 

inline constexpr unreachable_sentinel_t unreachable_sentinel{};
#line 3926 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"


template <class _Iter>
inline constexpr bool _Iterator_is_contiguous = contiguous_iterator<_Iter>;

template <class _Iter>
[[nodiscard]] constexpr auto _To_address(const _Iter& _Val) noexcept {
    ;
    return ::std:: to_address(_Val);
}


#line 3951 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class _Iter>
[[nodiscard]] constexpr auto _To_address(const move_iterator<_Iter>& _Val) noexcept {
    return _To_address(_Val.base());
}


template <class _Iter1, class _Iter2>
inline constexpr bool _Iterators_are_contiguous =
    _Iterator_is_contiguous<_Iter1>&& _Iterator_is_contiguous<_Iter2>;

template <class _Iter>
inline constexpr bool _Iterator_is_volatile = is_volatile_v<remove_reference_t<_Iter_ref_t<_Iter>>>;

template <class _Source, class _Dest>
inline constexpr bool _Is_pointer_address_convertible = is_void_v<_Source> || is_void_v<_Dest>
            
            || is_same_v<remove_cv_t<_Source>, remove_cv_t<_Dest>>

            || is_pointer_interconvertible_base_of_v<_Dest, _Source>
#line 3973 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
        ;

template <class _Source, class _Dest, class _SourceRef, class _DestRef>
struct _Trivial_cat {
    using _USource = _Unwrap_enum_t<_Source>;
    using _UDest   = _Unwrap_enum_t<_Dest>;

    static constexpr bool _Same_size_and_compatible =
        sizeof(_Source) == sizeof(_Dest)
        
        
        && is_same_v<bool, _USource> >= is_same_v<bool, _UDest> 
        && (is_same_v<_USource, _UDest> || (is_integral_v<_USource> && is_integral_v<_UDest>)
            || (is_floating_point_v<_USource> && is_floating_point_v<_UDest>) );

    static constexpr bool _Bitcopy_constructible =
        _Same_size_and_compatible && is_trivially_constructible_v<_Dest, _SourceRef>;

    static constexpr bool _Bitcopy_assignable =
        _Same_size_and_compatible && is_trivially_assignable_v<_DestRef, _SourceRef>;
};

template <class _Source, class _Dest, class _SourceRef, class _DestRef>
struct _Trivial_cat<_Source*, _Dest*, _SourceRef, _DestRef> {
    static constexpr bool _Bitcopy_constructible =
        _Is_pointer_address_convertible<_Source, _Dest> && is_trivially_constructible_v<_Dest*, _SourceRef>;

    static constexpr bool _Bitcopy_assignable =
        _Is_pointer_address_convertible<_Source, _Dest> && is_trivially_assignable_v<_DestRef, _SourceRef>;
};

struct _False_trivial_cat {
    static constexpr bool _Bitcopy_constructible = false;
    static constexpr bool _Bitcopy_assignable    = false;
};

template <class _SourceIt, class _DestIt,
    bool _Are_contiguous = _Iterators_are_contiguous<_SourceIt, _DestIt> 
                        && !_Iterator_is_volatile<_SourceIt> && !_Iterator_is_volatile<_DestIt>>
struct _Iter_move_cat : _Trivial_cat<_Iter_value_t<_SourceIt>, _Iter_value_t<_DestIt>,
                            remove_reference_t<_Iter_ref_t<_SourceIt>>&&, _Iter_ref_t<_DestIt>> {};

template <class _SourceIt, class _DestIt>
struct _Iter_move_cat<_SourceIt, _DestIt, false> : _False_trivial_cat {};

template <class _SourceIt, class _DestIt>
struct _Iter_move_cat<move_iterator<_SourceIt>, _DestIt, false> : _Iter_move_cat<_SourceIt, _DestIt> {};

template <class _SourceIt, class _DestIt,
    bool _Are_contiguous = _Iterators_are_contiguous<_SourceIt, _DestIt> 
                        && !_Iterator_is_volatile<_SourceIt> && !_Iterator_is_volatile<_DestIt>>
struct _Iter_copy_cat
    : _Trivial_cat<_Iter_value_t<_SourceIt>, _Iter_value_t<_DestIt>, _Iter_ref_t<_SourceIt>, _Iter_ref_t<_DestIt>> {};

template <class _SourceIt, class _DestIt>
struct _Iter_copy_cat<_SourceIt, _DestIt, false> : _False_trivial_cat {};

template <class _SourceIt, class _DestIt>
struct _Iter_copy_cat<move_iterator<_SourceIt>, _DestIt, false> : _Iter_move_cat<_SourceIt, _DestIt> {};

template <class _CtgIt, class _OutCtgIt>
_OutCtgIt _Copy_memmove(_CtgIt _First, _CtgIt _Last, _OutCtgIt _Dest) {
    auto _FirstPtr              = _To_address(_First);
    auto _LastPtr               = _To_address(_Last);
    auto _DestPtr               = _To_address(_Dest);
    const char* const _First_ch = const_cast<const char*>(reinterpret_cast<const volatile char*>(_FirstPtr));
    const char* const _Last_ch  = const_cast<const char*>(reinterpret_cast<const volatile char*>(_LastPtr));
    char* const _Dest_ch        = const_cast<char*>(reinterpret_cast<const volatile char*>(_DestPtr));
    const auto _Count           = static_cast<size_t>(_Last_ch - _First_ch);
    :: memmove(_Dest_ch, _First_ch, _Count);
    if constexpr (is_pointer_v<_OutCtgIt>) {
        return reinterpret_cast<_OutCtgIt>(_Dest_ch + _Count);
    } else {
        return _Dest + (_LastPtr - _FirstPtr);
    }
}

template <class _It, bool _RequiresMutable = false>
inline constexpr bool _Is_vb_iterator = false;

template <class _InIt, class _OutIt>
constexpr _OutIt _Copy_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest) {
    
    
    if constexpr (_Iter_copy_cat<_InIt, _OutIt>::_Bitcopy_assignable) {

        if (!::std:: is_constant_evaluated())
#line 4062 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
        {
            return _Copy_memmove(_First, _Last, _Dest);
        }
    }

    for (; _First != _Last; ++_Dest, (void) ++_First) {
        *_Dest = *_First;
    }

    return _Dest;
}

template <class _InIt, class _OutIt>
constexpr _OutIt copy(_InIt _First, _InIt _Last, _OutIt _Dest) { 
    _Adl_verify_range(_First, _Last);
    const auto _UFirst = _Get_unwrapped(_First);
    const auto _ULast  = _Get_unwrapped(_Last);
    const auto _UDest  = _Get_unwrapped_n(_Dest, _Idl_distance<_InIt>(_UFirst, _ULast));
    _Seek_wrapped(_Dest, _Copy_unchecked(_UFirst, _ULast, _UDest));
    return _Dest;
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt2 copy(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest) noexcept  {
    
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: copy(_First, _Last, _Dest);
}
#line 4094 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"


namespace ranges {
    template <class _To, class _From>
    concept _Convertible_from = convertible_to<_From, _To>;

    template <class _In, class _Out>
    struct in_out_result {
         _In in;
         _Out out;

        template <_Convertible_from<const _In&> _IIn, _Convertible_from<const _Out&> _OOut>
        constexpr operator in_out_result<_IIn, _OOut>() const& {
            return {in, out};
        }

        template <_Convertible_from<_In> _IIn, _Convertible_from<_Out> _OOut>
        constexpr operator in_out_result<_IIn, _OOut>() && {
            return {::std:: move(in), ::std:: move(out)};
        }
    };

    template <class _In, class _Out>
    using copy_result = in_out_result<_In, _Out>;

    
    template <input_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out>
        requires indirectly_copyable<_It, _Out>
    [[nodiscard]] constexpr copy_result<_It, _Out> _Copy_unchecked(_It _First, _Se _Last, _Out _Result) {
        
        if constexpr (_Iter_copy_cat<_It, _Out>::_Bitcopy_assignable && sized_sentinel_for<_Se, _It>) {
            if (!::std:: is_constant_evaluated()) {
                auto _Final = ::std::ranges:: next(_First, ::std:: move(_Last));
                _Result     = _Copy_memmove(::std:: move(_First), _Final, ::std:: move(_Result));
                return {::std:: move(_Final), ::std:: move(_Result)};
            }
        }

        for (; _First != _Last; ++_First, (void) ++_Result) {
            *_Result = *_First;
        }

        return {::std:: move(_First), ::std:: move(_Result)};
    }

    class _Copy_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out>
            requires indirectly_copyable<_It, _Out>
        constexpr copy_result<_It, _Out> operator()(_It _First, _Se _Last, _Out _Result) const {
            _Adl_verify_range(_First, _Last);
            auto _UResult = ::std::ranges:: _Copy_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)), ::std:: move(_Result));
            _Seek_wrapped(_First, ::std:: move(_UResult.in));
            return {::std:: move(_First), ::std:: move(_UResult.out)};
        }

        template <input_range _Rng, weakly_incrementable _Out>
            requires indirectly_copyable<iterator_t<_Rng>, _Out>
        constexpr copy_result<borrowed_iterator_t<_Rng>, _Out> operator()(_Rng&& _Range, _Out _Result) const {
            auto _First = ::std::ranges:: begin(_Range);
            auto _UResult =
                ::std::ranges:: _Copy_unchecked(_Get_unwrapped(::std:: move(_First)), _Uend(_Range), ::std:: move(_Result));
            _Seek_wrapped(_First, ::std:: move(_UResult.in));
            return {::std:: move(_First), ::std:: move(_UResult.out)};
        }
        
    };

    inline constexpr _Copy_fn copy{_Not_quite_object::_Construct_tag{}};
} 
#line 4169 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class _InIt, class _Diff, class _OutIt>
constexpr _OutIt copy_n(_InIt _First, _Diff _Count_raw, _OutIt _Dest) {
    
    _Algorithm_int_t<_Diff> _Count = _Count_raw;
    if (0 < _Count) {
        auto _UFirst = _Get_unwrapped_n(_First, _Count);
        auto _UDest  = _Get_unwrapped_n(_Dest, _Count);
        if constexpr (_Iter_copy_cat<decltype(_UFirst), decltype(_UDest)>::_Bitcopy_assignable) {

            if (!::std:: is_constant_evaluated())
#line 4181 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
            {
                _UDest = _Copy_memmove(_UFirst, _UFirst + _Count, _UDest);
                _Seek_wrapped(_Dest, _UDest);
                return _Dest;
            }
        }

        for (;;) {
            *_UDest = *_UFirst;
            ++_UDest;
            --_Count;
            if (_Count == 0) { 
                               
                break;
            }

            ++_UFirst;
        }

        _Seek_wrapped(_Dest, _UDest);
    }

    return _Dest;
}


template <class _ExPo, class _FwdIt1, class _Diff, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt2 copy_n(_ExPo&&, _FwdIt1 _First, _Diff _Count_raw, _FwdIt2 _Dest) noexcept  {
    
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: copy_n(_First, _Count_raw, _Dest);
}
#line 4216 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class _CtgIt1, class _CtgIt2>
_CtgIt2 _Copy_backward_memmove(_CtgIt1 _First, _CtgIt1 _Last, _CtgIt2 _Dest) {
    
    auto _FirstPtr              = _To_address(_First);
    auto _LastPtr               = _To_address(_Last);
    auto _DestPtr               = _To_address(_Dest);
    const char* const _First_ch = const_cast<const char*>(reinterpret_cast<const volatile char*>(_FirstPtr));
    const char* const _Last_ch  = const_cast<const char*>(reinterpret_cast<const volatile char*>(_LastPtr));
    char* const _Dest_ch        = const_cast<char*>(reinterpret_cast<const volatile char*>(_DestPtr));
    const auto _Count           = static_cast<size_t>(_Last_ch - _First_ch);
    auto _Result                = :: memmove(_Dest_ch - _Count, _First_ch, _Count);
    if constexpr (is_pointer_v<_CtgIt2>) {
        return static_cast<_CtgIt2>(_Result);
    } else {
        return _Dest - (_LastPtr - _FirstPtr);
    }
}

template <class _BidIt1, class _BidIt2>
_BidIt2 _Copy_backward_memmove(move_iterator<_BidIt1> _First, move_iterator<_BidIt1> _Last, _BidIt2 _Dest) {
    return _Copy_backward_memmove(_First.base(), _Last.base(), _Dest);
}

template <class _BidIt1, class _BidIt2>
[[nodiscard]] constexpr _BidIt2 _Copy_backward_unchecked(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest) {
    
    if constexpr (_Iter_copy_cat<_BidIt1, _BidIt2>::_Bitcopy_assignable) {

        if (!::std:: is_constant_evaluated())
#line 4247 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
        {
            return _Copy_backward_memmove(_First, _Last, _Dest);
        }
    }

    while (_First != _Last) {
        *--_Dest = *--_Last;
    }

    return _Dest;
}

template <class _BidIt1, class _BidIt2>
constexpr _BidIt2 copy_backward(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest) {
    
    _Adl_verify_range(_First, _Last);
    const auto _UFirst = _Get_unwrapped(_First);
    const auto _ULast  = _Get_unwrapped(_Last);
    const auto _UDest  = _Get_unwrapped_n(_Dest, -_Idl_distance<_BidIt1>(_UFirst, _ULast));
    _Seek_wrapped(_Dest, _Copy_backward_unchecked(_UFirst, _ULast, _UDest));
    return _Dest;
}


template <class _ExPo, class _BidIt1, class _BidIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
_BidIt2 copy_backward(_ExPo&&, _BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest) noexcept  {
    
    
    return ::std:: copy_backward(_First, _Last, _Dest);
}
#line 4278 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class _InIt, class _OutIt>
constexpr _OutIt _Move_unchecked(_InIt _First, _InIt _Last, _OutIt _Dest) {
    
    
    if constexpr (_Iter_move_cat<_InIt, _OutIt>::_Bitcopy_assignable) {

        if (!::std:: is_constant_evaluated())
#line 4287 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
        {
            return _Copy_memmove(_First, _Last, _Dest);
        }
    }

    for (; _First != _Last; ++_Dest, (void) ++_First) {
        *_Dest = ::std:: move(*_First);
    }

    return _Dest;
}

template <class _InIt, class _OutIt>
constexpr _OutIt move(_InIt _First, _InIt _Last, _OutIt _Dest) {
    
    _Adl_verify_range(_First, _Last);
    const auto _UFirst = _Get_unwrapped(_First);
    const auto _ULast  = _Get_unwrapped(_Last);
    const auto _UDest  = _Get_unwrapped_n(_Dest, _Idl_distance<_InIt>(_UFirst, _ULast));
    _Seek_wrapped(_Dest, _Move_unchecked(_UFirst, _ULast, _UDest));
    return _Dest;
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt2 move(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest) noexcept  {
    
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: move(_First, _Last, _Dest);
}
#line 4320 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class _BidIt1, class _BidIt2>
constexpr _BidIt2 _Move_backward_unchecked(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest) {
    
    
    if constexpr (_Iter_move_cat<_BidIt1, _BidIt2>::_Bitcopy_assignable) {

        if (!::std:: is_constant_evaluated())
#line 4329 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
        {
            return _Copy_backward_memmove(_First, _Last, _Dest);
        }
    }

    while (_First != _Last) {
        *--_Dest = ::std:: move(*--_Last);
    }

    return _Dest;
}

template <class _BidIt1, class _BidIt2>
constexpr _BidIt2 move_backward(_BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest) {
    
    _Adl_verify_range(_First, _Last);
    const auto _UFirst = _Get_unwrapped(_First);
    const auto _ULast  = _Get_unwrapped(_Last);
    const auto _UDest  = _Get_unwrapped_n(_Dest, -_Idl_distance<_BidIt1>(_UFirst, _ULast));
    _Seek_wrapped(_Dest, _Move_backward_unchecked(_UFirst, _ULast, _UDest));
    return _Dest;
}


template <class _ExPo, class _BidIt1, class _BidIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
_BidIt2 move_backward(_ExPo&&, _BidIt1 _First, _BidIt1 _Last, _BidIt2 _Dest) noexcept  {
    
    
    return ::std:: move_backward(_First, _Last, _Dest);
}
#line 4360 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"


template <class _Ty>
struct _Is_character : false_type {}; 

template <>
struct _Is_character<char> : true_type {}; 

template <>
struct _Is_character<signed char> : true_type {}; 

template <>
struct _Is_character<unsigned char> : true_type {}; 


template <>
struct _Is_character<char8_t> : true_type {}; 
#line 4378 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class _Ty>
struct _Is_character_or_bool : _Is_character<_Ty>::type {};

template <>
struct _Is_character_or_bool<bool> : true_type {};

template <class _Ty>
struct _Is_character_or_byte_or_bool : _Is_character_or_bool<_Ty>::type {};


template <>
struct _Is_character_or_byte_or_bool<byte> : true_type {};
#line 4392 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"


template <class _FwdIt, class _Ty, bool = _Iterator_is_contiguous<_FwdIt>>
inline constexpr bool _Fill_memset_is_safe = conjunction_v<is_scalar<_Ty>,
    _Is_character_or_byte_or_bool<_Unwrap_enum_t<remove_reference_t<_Iter_ref_t<_FwdIt>>>>,
    negation<is_volatile<remove_reference_t<_Iter_ref_t<_FwdIt>>>>, is_assignable<_Iter_ref_t<_FwdIt>, const _Ty&>>;

template <class _FwdIt, class _Ty>
inline constexpr bool _Fill_memset_is_safe<_FwdIt, _Ty, false> = false;

template <class _FwdIt, class _Ty, bool = _Iterator_is_contiguous<_FwdIt>>
inline constexpr bool _Fill_zero_memset_is_safe =
    conjunction_v<is_scalar<_Ty>, is_scalar<_Iter_value_t<_FwdIt>>, negation<is_member_pointer<_Iter_value_t<_FwdIt>>>,
        negation<is_volatile<remove_reference_t<_Iter_ref_t<_FwdIt>>>>, is_assignable<_Iter_ref_t<_FwdIt>, const _Ty&>>;

template <class _FwdIt, class _Ty>
inline constexpr bool _Fill_zero_memset_is_safe<_FwdIt, _Ty, false> = false;

template <class _CtgIt, class _Ty>
void _Fill_memset(_CtgIt _Dest, const _Ty _Val, const size_t _Count) {
    
    _Iter_value_t<_CtgIt> _Dest_val = _Val;
    :: memset(_To_address(_Dest), static_cast<unsigned char>(_Dest_val), _Count);
}

template <class _CtgIt>
void _Fill_zero_memset(_CtgIt _Dest, const size_t _Count) {
    :: memset(_To_address(_Dest), 0, _Count * sizeof(_Iter_value_t<_CtgIt>));
}

template <class _Ty>
[[nodiscard]] bool _Is_all_bits_zero(const _Ty& _Val) {
    
    ;
    if constexpr (is_same_v<_Ty, nullptr_t>) {
        return true;
    } else {
        constexpr _Ty _Zero{};
        return :: memcmp(&_Val, &_Zero, sizeof(_Ty)) == 0;
    }
}

template <class _FwdIt, class _Ty>
constexpr void fill(const _FwdIt _First, const _FwdIt _Last, const _Ty& _Val) {
    
    _Adl_verify_range(_First, _Last);
    if constexpr (_Is_vb_iterator<_FwdIt, true>) {
        _Fill_vbool(_First, _Last, _Val);
    } else {
        auto _UFirst      = _Get_unwrapped(_First);
        const auto _ULast = _Get_unwrapped(_Last);

        if (!::std:: is_constant_evaluated())
#line 4447 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
        {
            if constexpr (_Fill_memset_is_safe<decltype(_UFirst), _Ty>) {
                _Fill_memset(_UFirst, _Val, static_cast<size_t>(_ULast - _UFirst));
                return;
            } else if constexpr (_Fill_zero_memset_is_safe<decltype(_UFirst), _Ty>) {
                if (_Is_all_bits_zero(_Val)) {
                    _Fill_zero_memset(_UFirst, static_cast<size_t>(_ULast - _UFirst));
                    return;
                }
            }
        }

        for (; _UFirst != _ULast; ++_UFirst) {
            *_UFirst = _Val;
        }
    }
}


template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
void fill(_ExPo&&, _FwdIt _First, _FwdIt _Last, const _Ty& _Val) noexcept  {
    
    
    static_assert(_Is_fwd_iter_v<_FwdIt>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: fill(_First, _Last, _Val);
}
#line 4474 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class _OutIt, class _Diff, class _Ty>
constexpr _OutIt fill_n(_OutIt _Dest, const _Diff _Count_raw, const _Ty& _Val) {
    
    _Algorithm_int_t<_Diff> _Count = _Count_raw;
    if (0 < _Count) {
        if constexpr (_Is_vb_iterator<_OutIt, true>) {
            const auto _Last = _Dest + static_cast<typename _OutIt::difference_type>(_Count);
            _Fill_vbool(_Dest, _Last, _Val);
            return _Last;
        } else {
            auto _UDest = _Get_unwrapped_n(_Dest, _Count);

            if (!::std:: is_constant_evaluated())
#line 4489 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
            {
                if constexpr (_Fill_memset_is_safe<decltype(_UDest), _Ty>) {
                    _Fill_memset(_UDest, _Val, static_cast<size_t>(_Count));
                    _Seek_wrapped(_Dest, _UDest + _Count);
                    return _Dest;
                } else if constexpr (_Fill_zero_memset_is_safe<decltype(_UDest), _Ty>) {
                    if (_Is_all_bits_zero(_Val)) {
                        _Fill_zero_memset(_UDest, static_cast<size_t>(_Count));
                        _Seek_wrapped(_Dest, _UDest + _Count);
                        return _Dest;
                    }
                }
            }

            for (; 0 < _Count; --_Count, (void) ++_UDest) {
                *_UDest = _Val;
            }

            _Seek_wrapped(_Dest, _UDest);
        }
    }
    return _Dest;
}


template <class _ExPo, class _FwdIt, class _Diff, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt fill_n(_ExPo&&, _FwdIt _Dest, _Diff _Count_raw, const _Ty& _Val) noexcept  {
    
    
    static_assert(_Is_fwd_iter_v<_FwdIt>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: fill_n(_Dest, _Count_raw, _Val);
}
#line 4522 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"


namespace ranges {
    class _Fill_n_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <class _Ty, output_iterator<const _Ty&> _It>
        constexpr _It operator()(_It _First, iter_difference_t<_It> _Count, const _Ty& _Value) const {
            if (_Count > 0) {
                auto _UFirst = _Get_unwrapped_n(::std:: move(_First), _Count);
                if (!::std:: is_constant_evaluated()) {
                    if constexpr (_Fill_memset_is_safe<decltype(_UFirst), _Ty>) {
                        _Fill_memset(_UFirst, _Value, static_cast<size_t>(_Count));
                        _Seek_wrapped(_First, _UFirst + _Count); 
                        return _First;
                    } else if constexpr (_Fill_zero_memset_is_safe<decltype(_UFirst), _Ty>) {
                        if (_Is_all_bits_zero(_Value)) {
                            _Fill_zero_memset(_UFirst, static_cast<size_t>(_Count));
                            _Seek_wrapped(_First, _UFirst + _Count); 
                            return _First;
                        }
                    }
                }

                for (; _Count > 0; ++_UFirst, (void) --_Count) {
                    *_UFirst = _Value;
                }

                _Seek_wrapped(_First, ::std:: move(_UFirst));
            }

            return _First;
        }
    };

    inline constexpr _Fill_n_fn fill_n{_Not_quite_object::_Construct_tag{}};
} 
#line 4561 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class _Ty1, class _Ty2, class = void>
inline constexpr bool _Can_compare_with_operator_equal = false;

template <class _Ty1, class _Ty2>
inline constexpr bool
    _Can_compare_with_operator_equal<_Ty1, _Ty2, void_t<decltype(::std:: declval<_Ty1&>() == ::std:: declval<_Ty2&>())>> =
        true;

template <class _Ty1, class _Ty2>
inline constexpr bool _Is_pointer_address_comparable =
    _Can_compare_with_operator_equal<_Ty1*,
        _Ty2*> && (_Is_pointer_address_convertible<_Ty1, _Ty2> || _Is_pointer_address_convertible<_Ty2, _Ty1>);


#pragma warning(push)
#pragma warning(disable : 4806) 
template <class _Elem1, class _Elem2,
    bool = sizeof(_Elem1) == sizeof(_Elem2) && is_integral_v<_Elem1>&& is_integral_v<_Elem2>>
inline constexpr bool _Can_memcmp_elements =
    is_same_v<_Elem1, bool> || is_same_v<_Elem2, bool> || static_cast<_Elem1>(-1) == static_cast<_Elem2>(-1);
#pragma warning(pop)


template <>
inline constexpr bool _Can_memcmp_elements<byte, byte, false> = true;
#line 4597 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"


template <class _Ty1, class _Ty2>
inline constexpr bool _Can_memcmp_elements<_Ty1*, _Ty2*, false> = _Is_pointer_address_comparable<_Ty1, _Ty2>;

template <class _Elem1, class _Elem2>
inline constexpr bool _Can_memcmp_elements<_Elem1, _Elem2, false> = false;


template <class _Elem1, class _Elem2, class _Pr>
inline constexpr bool _Can_memcmp_elements_with_pred = false;


template <class _Elem1, class _Elem2, class _Elem3>
inline constexpr bool _Can_memcmp_elements_with_pred<_Elem1, _Elem2, equal_to<_Elem3>> =
    _Iter_copy_cat<_Elem1*, _Elem3*>::_Bitcopy_constructible&& _Iter_copy_cat<_Elem2*,
        _Elem3*>::_Bitcopy_constructible&& _Can_memcmp_elements<remove_cv_t<_Elem3>, remove_cv_t<_Elem3>>;


template <class _Elem1, class _Elem2>
inline constexpr bool _Can_memcmp_elements_with_pred<_Elem1, _Elem2, equal_to<>> =
    _Can_memcmp_elements<_Elem1, _Elem2>;


template <class _Elem1, class _Elem2>
inline constexpr bool _Can_memcmp_elements_with_pred<_Elem1, _Elem2, ::std::ranges:: equal_to> =
    _Can_memcmp_elements<_Elem1, _Elem2>;
#line 4630 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"


template <class _Iter1, class _Iter2, class _Pr>
inline constexpr bool _Equal_memcmp_is_safe_helper =
    _Iterators_are_contiguous<_Iter1, _Iter2> 
    && !_Iterator_is_volatile<_Iter1> && !_Iterator_is_volatile<_Iter2> 
    && _Can_memcmp_elements_with_pred<_Iter_value_t<_Iter1>, _Iter_value_t<_Iter2>, _Pr>;

template <class _Iter1, class _Iter2, class _Pr>
inline constexpr bool _Equal_memcmp_is_safe =
    _Equal_memcmp_is_safe_helper<remove_const_t<_Iter1>, remove_const_t<_Iter2>, _Pr>;

template <class _CtgIt1, class _CtgIt2>
[[nodiscard]] int _Memcmp_ranges(_CtgIt1 _First1, _CtgIt1 _Last1, _CtgIt2 _First2) {
    ;
    const auto _First1_ch = reinterpret_cast<const char*>(_To_address(_First1));
    const auto _Last1_ch  = reinterpret_cast<const char*>(_To_address(_Last1));
    const auto _First2_ch = reinterpret_cast<const char*>(_To_address(_First2));
    return :: memcmp(_First1_ch, _First2_ch, static_cast<size_t>(_Last1_ch - _First1_ch));
}

template <class _CtgIt1, class _CtgIt2>
[[nodiscard]] int _Memcmp_count(_CtgIt1 _First1, _CtgIt2 _First2, const size_t _Count) {
    ;
    const auto _First1_ch = reinterpret_cast<const char*>(_To_address(_First1));
    const auto _First2_ch = reinterpret_cast<const char*>(_To_address(_First2));
    return :: memcmp(_First1_ch, _First2_ch, _Count * sizeof(_Iter_value_t<_CtgIt1>));
}

template <class _InIt1, class _InIt2, class _Pr>
[[nodiscard]] constexpr bool equal(const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, _Pr _Pred) {
    
    _Adl_verify_range(_First1, _Last1);
    auto _UFirst1      = _Get_unwrapped(_First1);
    const auto _ULast1 = _Get_unwrapped(_Last1);
    auto _UFirst2      = _Get_unwrapped_n(_First2, _Idl_distance<_InIt1>(_UFirst1, _ULast1));
    if constexpr (_Equal_memcmp_is_safe<decltype(_UFirst1), decltype(_UFirst2), _Pr>) {

        if (!::std:: is_constant_evaluated())
#line 4672 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
        {
            return _Memcmp_ranges(_UFirst1, _ULast1, _UFirst2) == 0;
        }
    }

    for (; _UFirst1 != _ULast1; ++_UFirst1, (void) ++_UFirst2) {
        if (!_Pred(*_UFirst1, *_UFirst2)) {
            return false;
        }
    }

    return true;
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] bool equal(_ExPo&& _Exec, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2,
    _Pr _Pred) noexcept; 
#line 4691 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class _InIt1, class _InIt2>
[[nodiscard]] constexpr bool equal(const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2) {
    
    return ::std:: equal(_First1, _Last1, _First2, equal_to<>{});
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] bool equal(_ExPo&& _Exec, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2) noexcept
 {
    
    return ::std:: equal(::std:: forward<_ExPo>(_Exec), _First1, _Last1, _First2, equal_to{});
}
#line 4706 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class _InIt1, class _InIt2, class _Pr>
[[nodiscard]] constexpr bool equal(
    const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, const _InIt2 _Last2, _Pr _Pred) {
    
    _Adl_verify_range(_First1, _Last1);
    _Adl_verify_range(_First2, _Last2);
    auto _UFirst1      = _Get_unwrapped(_First1);
    const auto _ULast1 = _Get_unwrapped(_Last1);
    auto _UFirst2      = _Get_unwrapped(_First2);
    const auto _ULast2 = _Get_unwrapped(_Last2);
    if constexpr (_Is_random_iter_v<_InIt1> && _Is_random_iter_v<_InIt2>) {
        if (_ULast1 - _UFirst1 != _ULast2 - _UFirst2) {
            return false;
        }

        return ::std:: equal(_UFirst1, _ULast1, _UFirst2, _Pass_fn(_Pred));
    } else {
        for (;;) {
            if (_UFirst1 == _ULast1) {
                return _UFirst2 == _ULast2;
            }

            if (_UFirst2 == _ULast2) {
                return false;
            }

            if (!_Pred(*_UFirst1, *_UFirst2)) {
                return false;
            }

            ++_UFirst1;
            ++_UFirst2;
        }
    }
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] bool equal(_ExPo&& _Exec, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2,
    const _FwdIt2 _Last2, _Pr _Pred) noexcept; 
#line 4748 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class _InIt1, class _InIt2>
[[nodiscard]] constexpr bool equal(
    const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, const _InIt2 _Last2) {
    
    return ::std:: equal(_First1, _Last1, _First2, _Last2, equal_to<>{});
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] bool equal(_ExPo&& _Exec, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2,
    const _FwdIt2 _Last2) noexcept  {
    
    return ::std:: equal(::std:: forward<_ExPo>(_Exec), _First1, _Last1, _First2, _Last2, equal_to{});
}
#line 4764 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"


namespace ranges {
    template <forward_range _Rng, class _It>
    [[nodiscard]] constexpr iterator_t<_Rng> _Rewrap_iterator(_Rng&& _Range, _It&& _Val) {
        ;

        if constexpr (is_same_v<remove_cvref_t<_It>, iterator_t<_Rng>>) {
            return ::std:: forward<_It>(_Val);
        } else {
            auto _Result = ::std::ranges:: begin(_Range);
            _Result._Seek_to(::std:: forward<_It>(_Val));
            return _Result;
        }
    }

    template <class _In1, class _In2>
    struct in_in_result {
         _In1 in1;
         _In2 in2;

        template <_Convertible_from<const _In1&> _IIn1, _Convertible_from<const _In2&> _IIn2>
        constexpr operator in_in_result<_IIn1, _IIn2>() const& {
            return {in1, in2};
        }

        template <_Convertible_from<_In1> _IIn1, _Convertible_from<_In2> _IIn2>
        constexpr operator in_in_result<_IIn1, _IIn2>() && {
            return {::std:: move(in1), ::std:: move(in2)};
        }
    };

    template <class _In1, class _In2>
    using mismatch_result = in_in_result<_In1, _In2>;

    
    template <input_iterator _It1, input_iterator _It2, class _Pr, class _Pj1, class _Pj2>
        requires indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
    [[nodiscard]] constexpr mismatch_result<_It1, _It2> _Mismatch_n(
        _It1 _First1, _It2 _First2, iter_difference_t<_It1> _Count, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
        
        ;
        for (; _Count != 0; ++_First1, (void) ++_First2, --_Count) {
            if (!::std:: invoke(_Pred, ::std:: invoke(_Proj1, *_First1), ::std:: invoke(_Proj2, *_First2))) {
                break;
            }
        }

        return {::std:: move(_First1), ::std:: move(_First2)};
    }

    
    template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2, class _Pr,
        class _Pj1, class _Pj2>
        requires indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
    [[nodiscard]] constexpr mismatch_result<_It1, _It2> _Mismatch_4(
        _It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
        

        for (; _First1 != _Last1 && _First2 != _Last2; ++_First1, (void) ++_First2) {
            if (!::std:: invoke(_Pred, ::std:: invoke(_Proj1, *_First1), ::std:: invoke(_Proj2, *_First2))) {
                break;
            }
        }

        return {::std:: move(_First1), ::std:: move(_First2)};
    }

    class _Mismatch_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2,
            class _Pr = ranges::equal_to, class _Pj1 = identity, class _Pj2 = identity>
            requires indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
        [[nodiscard]] constexpr mismatch_result<_It1, _It2> operator()(_It1 _First1, _Se1 _Last1,
            _It2 _First2, _Se2 _Last2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            
            _Adl_verify_range(_First1, _Last1);
            _Adl_verify_range(_First2, _Last2);

            if constexpr (sized_sentinel_for<_Se1, _It1> && sized_sentinel_for<_Se2, _It2>) {
                iter_difference_t<_It1> _Count1       = _Last1 - _First1;
                const iter_difference_t<_It2> _Count2 = _Last2 - _First2;
                if (_Count1 > _Count2) {
                    _Count1 = static_cast<decltype(_Count1)>(_Count2);
                }

                auto _Result = ::std::ranges:: _Mismatch_n(_Get_unwrapped(::std:: move(_First1)),
                    _Get_unwrapped(::std:: move(_First2)), _Count1, _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
                _Seek_wrapped(_First1, ::std:: move(_Result.in1));
                _Seek_wrapped(_First2, ::std:: move(_Result.in2));
                return {::std:: move(_First1), ::std:: move(_First2)};
            } else {
                auto _Result = ::std::ranges:: _Mismatch_4(_Get_unwrapped(::std:: move(_First1)),
                    _Get_unwrapped(::std:: move(_Last1)), _Get_unwrapped(::std:: move(_First2)),
                    _Get_unwrapped(::std:: move(_Last2)), _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
                _Seek_wrapped(_First1, ::std:: move(_Result.in1));
                _Seek_wrapped(_First2, ::std:: move(_Result.in2));
                return {::std:: move(_First1), ::std:: move(_First2)};
            }
        }

        
        template <input_range _Rng1, input_range _Rng2, class _Pr = ranges::equal_to, class _Pj1 = identity,
            class _Pj2 = identity>
            requires indirectly_comparable<iterator_t<_Rng1>, iterator_t<_Rng2>, _Pr, _Pj1, _Pj2>
        [[nodiscard]] constexpr mismatch_result<borrowed_iterator_t<_Rng1>, borrowed_iterator_t<_Rng2>> operator()(
            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            
            if constexpr (sized_range<_Rng1> && sized_range<_Rng2>) {
                range_difference_t<_Rng1> _Count1       = ::std::ranges:: distance(_Range1);
                const range_difference_t<_Rng2> _Count2 = ::std::ranges:: distance(_Range2);
                if (_Count1 > _Count2) {
                    _Count1 = static_cast<range_difference_t<_Rng1>>(_Count2);
                }

                auto _First1 = ::std::ranges:: begin(_Range1);
                auto _First2 = ::std::ranges:: begin(_Range2);
                auto _Result = ::std::ranges:: _Mismatch_n(_Get_unwrapped(::std:: move(_First1)),
                    _Get_unwrapped(::std:: move(_First2)), _Count1, _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
                _Seek_wrapped(_First1, ::std:: move(_Result.in1));
                _Seek_wrapped(_First2, ::std:: move(_Result.in2));
                return {::std:: move(_First1), ::std:: move(_First2)};
            } else {
                auto _First1 = ::std::ranges:: begin(_Range1);
                auto _First2 = ::std::ranges:: begin(_Range2);
                auto _Result = ::std::ranges:: _Mismatch_4(_Get_unwrapped(::std:: move(_First1)), _Uend(_Range1),
                    _Get_unwrapped(::std:: move(_First2)), _Uend(_Range2), _Pass_fn(_Pred), _Pass_fn(_Proj1),
                    _Pass_fn(_Proj2));
                _Seek_wrapped(_First1, ::std:: move(_Result.in1));
                _Seek_wrapped(_First2, ::std:: move(_Result.in2));
                return {::std:: move(_First1), ::std:: move(_First2)};
            }
        }
    };

    inline constexpr _Mismatch_fn mismatch{_Not_quite_object::_Construct_tag{}};
} 
#line 4905 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class _Elem1, class _Elem2>
inline constexpr bool _Lex_compare_memcmp_classify_elements = conjunction_v<_Is_character_or_bool<_Elem1>,
    _Is_character_or_bool<_Elem2>, is_unsigned<_Elem1>, is_unsigned<_Elem2>>;


template <>
inline constexpr bool _Lex_compare_memcmp_classify_elements<byte, byte> = true;
#line 4914 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class _Elem1, class _Elem2, class _Pr>
struct _Lex_compare_memcmp_classify_pred {
    using _Pred = void;
};

template <class _Elem1, class _Elem2, class _Elem3>
struct _Lex_compare_memcmp_classify_pred<_Elem1, _Elem2, less<_Elem3>> {
    using _Pred = conditional_t<_Lex_compare_memcmp_classify_elements<_Elem3, _Elem3> 
                                    && _Iter_copy_cat<_Elem1*, _Elem3*>::_Bitcopy_constructible
                                    && _Iter_copy_cat<_Elem2*, _Elem3*>::_Bitcopy_constructible,
        less<int>, void>;
};

template <class _Elem1, class _Elem2>
struct _Lex_compare_memcmp_classify_pred<_Elem1, _Elem2, less<>> {
    using _Pred = conditional_t<_Lex_compare_memcmp_classify_elements<_Elem1, _Elem2>, less<int>, void>;
};

template <class _Elem1, class _Elem2, class _Elem3>
struct _Lex_compare_memcmp_classify_pred<_Elem1, _Elem2, greater<_Elem3>> {
    using _Pred = conditional_t<_Lex_compare_memcmp_classify_elements<_Elem3, _Elem3> 
                                    && _Iter_copy_cat<_Elem1*, _Elem3*>::_Bitcopy_constructible
                                    && _Iter_copy_cat<_Elem2*, _Elem3*>::_Bitcopy_constructible,
        greater<int>, void>;
};

template <class _Elem1, class _Elem2>
struct _Lex_compare_memcmp_classify_pred<_Elem1, _Elem2, greater<>> {
    using _Pred = conditional_t<_Lex_compare_memcmp_classify_elements<_Elem1, _Elem2>, greater<int>, void>;
};


template <class _Elem1, class _Elem2>
struct _Lex_compare_memcmp_classify_pred<_Elem1, _Elem2, ::std::ranges:: less> {
    using _Pred = conditional_t<_Lex_compare_memcmp_classify_elements<_Elem1, _Elem2>, less<int>, void>;
};

template <class _Elem1, class _Elem2>
struct _Lex_compare_memcmp_classify_pred<_Elem1, _Elem2, ::std::ranges:: greater> {
    using _Pred = conditional_t<_Lex_compare_memcmp_classify_elements<_Elem1, _Elem2>, greater<int>, void>;
};
#line 4957 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class _It1, class _It2, class _Pr>
using _Lex_compare_memcmp_classify =
    conditional_t<_Iterators_are_contiguous<_It1, _It2> && !_Iterator_is_volatile<_It1> && !_Iterator_is_volatile<_It2>,
        typename _Lex_compare_memcmp_classify_pred<_Iter_value_t<_It1>, _Iter_value_t<_It2>, _Pr>::_Pred, void>;

template <class _InIt1, class _InIt2, class _Pr>
[[nodiscard]] constexpr bool lexicographical_compare(
    const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, const _InIt2 _Last2, _Pr _Pred) {
    
    _Adl_verify_range(_First1, _Last1);
    _Adl_verify_range(_First2, _Last2);
    auto _UFirst1      = _Get_unwrapped(_First1);
    const auto _ULast1 = _Get_unwrapped(_Last1);
    auto _UFirst2      = _Get_unwrapped(_First2);
    const auto _ULast2 = _Get_unwrapped(_Last2);

    using _Memcmp_pred = _Lex_compare_memcmp_classify<decltype(_UFirst1), decltype(_UFirst2), _Pr>;
    if constexpr (!is_void_v<_Memcmp_pred>) {

        if (!::std:: is_constant_evaluated())
#line 4979 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
        {
            const auto _Num1 = static_cast<size_t>(_ULast1 - _UFirst1);
            const auto _Num2 = static_cast<size_t>(_ULast2 - _UFirst2);
            const int _Ans   = _Memcmp_count(_UFirst1, _UFirst2, (::std:: min)(_Num1, _Num2));
            return _Memcmp_pred{}(_Ans, 0) || (_Ans == 0 && _Num1 < _Num2);
        }
    }

    for (; _UFirst1 != _ULast1 && _UFirst2 != _ULast2; ++_UFirst1, (void) ++_UFirst2) { 
        if (static_cast<bool>(_Pred(*_UFirst1, *_UFirst2))) {
            return true;
        } else if (_Pred(*_UFirst2, *_UFirst1)) {
            return false;
        }
    }

    return _UFirst1 == _ULast1 && _UFirst2 != _ULast2;
}

template <class _InIt1, class _InIt2>
[[nodiscard]] constexpr bool lexicographical_compare(
    const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, const _InIt2 _Last2) {
    
    return ::std:: lexicographical_compare(_First1, _Last1, _First2, _Last2, less<>{});
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] bool lexicographical_compare(_ExPo&&, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2,
    const _FwdIt2 _Last2, _Pr _Pred) noexcept  {
    
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: lexicographical_compare(_First1, _Last1, _First2, _Last2, _Pass_fn(_Pred));
}

template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] bool lexicographical_compare(_ExPo&&, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2,
    const _FwdIt2 _Last2) noexcept  {
    
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: lexicographical_compare(_First1, _Last1, _First2, _Last2);
}
#line 5026 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"


template <class _Elem1, class _Elem2, class _Cmp>
struct _Lex_compare_three_way_memcmp_classify_comp {
    using _Comp = void;
};

template <class _Elem1, class _Elem2>
struct _Lex_compare_three_way_memcmp_classify_comp<_Elem1, _Elem2, compare_three_way> {
    using _Comp = conditional_t<_Lex_compare_memcmp_classify_elements<_Elem1,
                                    _Elem2> && three_way_comparable_with<const _Elem1&, const _Elem2&>,
        compare_three_way, void>;
};

template <class _Elem1, class _Elem2>
struct _Lex_compare_three_way_memcmp_classify_comp<_Elem1, _Elem2, _Strong_order::_Cpo> {
    using _Comp =
        conditional_t<_Lex_compare_memcmp_classify_elements<_Elem1, _Elem2> && _Can_strong_order<_Elem1, _Elem2>,
            _Strong_order::_Cpo, void>;
};

template <class _Elem1, class _Elem2>
struct _Lex_compare_three_way_memcmp_classify_comp<_Elem1, _Elem2, _Weak_order::_Cpo> {
    using _Comp =
        conditional_t<_Lex_compare_memcmp_classify_elements<_Elem1, _Elem2> && _Can_weak_order<_Elem1, _Elem2>,
            _Weak_order::_Cpo, void>;
};

template <class _Elem1, class _Elem2>
struct _Lex_compare_three_way_memcmp_classify_comp<_Elem1, _Elem2, _Partial_order::_Cpo> {
    using _Comp =
        conditional_t<_Lex_compare_memcmp_classify_elements<_Elem1, _Elem2> && _Can_partial_order<_Elem1, _Elem2>,
            _Partial_order::_Cpo, void>;
};

template <class _It1, class _It2, class _Cmp>
using _Lex_compare_three_way_memcmp_classify =
    conditional_t<_Iterators_are_contiguous<_It1, _It2> && !_Iterator_is_volatile<_It1> && !_Iterator_is_volatile<_It2>,
        typename _Lex_compare_three_way_memcmp_classify_comp<_Iter_value_t<_It1>, _Iter_value_t<_It2>, _Cmp>::_Comp,
        void>;

template <class _InIt1, class _InIt2, class _Cmp>
[[nodiscard]] constexpr auto lexicographical_compare_three_way(const _InIt1 _First1, const _InIt1 _Last1,
    const _InIt2 _First2, const _InIt2 _Last2, _Cmp _Comp) -> decltype(_Comp(*_First1, *_First2)) {
    _Adl_verify_range(_First1, _Last1);
    _Adl_verify_range(_First2, _Last2);
    auto _UFirst1      = _Get_unwrapped(_First1);
    const auto _ULast1 = _Get_unwrapped(_Last1);
    auto _UFirst2      = _Get_unwrapped(_First2);
    const auto _ULast2 = _Get_unwrapped(_Last2);

    using _Memcmp_pred = _Lex_compare_three_way_memcmp_classify<decltype(_UFirst1), decltype(_UFirst2), _Cmp>;
    if constexpr (!is_void_v<_Memcmp_pred>) {
        if (!::std:: is_constant_evaluated()) {
            const auto _Num1 = static_cast<size_t>(_ULast1 - _UFirst1);
            const auto _Num2 = static_cast<size_t>(_ULast2 - _UFirst2);
            const int _Ans   = _Memcmp_count(_UFirst1, _UFirst2, (::std:: min)(_Num1, _Num2));
            if (_Ans == 0) {
                return _Num1 <=> _Num2;
            } else {
                return _Memcmp_pred{}(_Ans, 0);
            }
        }
    }

    for (;;) {
        if (_UFirst1 == _ULast1) {
            return _UFirst2 == _ULast2 ? strong_ordering::equal : strong_ordering::less;
        }

        if (_UFirst2 == _ULast2) {
            return strong_ordering::greater;
        }

        if (const auto _CmpResult = _Comp(*_UFirst1, *_UFirst2); _CmpResult != 0) {
            return _CmpResult;
        }

        ++_UFirst1;
        ++_UFirst2;
    }
}

template <class _InIt1, class _InIt2>
[[nodiscard]] constexpr auto lexicographical_compare_three_way(
    const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, const _InIt2 _Last2) {
    return ::std:: lexicographical_compare_three_way(_First1, _Last1, _First2, _Last2, compare_three_way{});
}
#line 5115 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class _InIt, class _Ty>
[[nodiscard]] constexpr bool _Within_limits(const _InIt&, const _Ty& _Val) {
    
    if constexpr (is_same_v<_Ty, bool>) {
        return true;
    }

    else if constexpr (is_same_v<_Ty, byte>) {
        return true;
    }
#line 5127 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
    else {
        using _Elem = _Iter_value_t<_InIt>;
        ;
        if constexpr (is_same_v<_Elem, bool>) {
            return _Val == true || _Val == false;
        } else if constexpr (is_signed_v<_Elem>) {
            if constexpr (is_signed_v<_Ty>) {
                
                return (-128) <= _Val && _Val <= 127;
            } else {
                if constexpr (-1 == static_cast<_Ty>(-1)) {
                    
                    return _Val <= 127 || static_cast<_Ty>((-128)) <= _Val;
                } else {
                    
                    return _Val <= 127;
                }
            }
        } else {
            if constexpr (is_signed_v<_Ty>) {
                
                return 0 <= _Val && _Val <= 0xff;
            } else {
                
                return _Val <= 0xff;
            }
        }
    }
}

template <class _Iter, class _Ty>
inline constexpr bool _Memchr_in_find_is_safe =
    _Iterator_is_contiguous<_Iter>&&
        disjunction_v<conjunction<is_integral<_Ty>, _Is_character_or_bool<_Iter_value_t<_Iter>>>

            ,
            conjunction<is_same<_Ty, byte>, is_same<_Iter_value_t<_Iter>, byte>>
#line 5165 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
            > && !is_volatile_v<remove_reference_t<_Iter_ref_t<_Iter>>>;

template <class _InIt, class _Ty>
[[nodiscard]] constexpr _InIt _Find_unchecked(_InIt _First, const _InIt _Last, const _Ty& _Val) {
    
    
    if (!::std:: is_constant_evaluated())
#line 5174 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
    {
        if constexpr (_Memchr_in_find_is_safe<_InIt, _Ty>) {
            
            if (!_Within_limits(_First, _Val)) {
                return _Last;
            }
            const auto _First_ptr = _To_address(_First);
            const auto _Result    = static_cast<remove_reference_t<_Iter_ref_t<_InIt>>*>(
                :: memchr(_First_ptr, static_cast<unsigned char>(_Val), static_cast<size_t>(_Last - _First)));
            if constexpr (is_pointer_v<_InIt>) {
                return _Result ? _Result : _Last;
            } else {
                return _Result ? _First + (_Result - _First_ptr) : _Last;
            }
        }
    }

    for (; _First != _Last; ++_First) {
        if (*_First == _Val) {
            break;
        }
    }

    return _First;
}

template <class _InIt, class _Ty>
[[nodiscard]] constexpr _InIt find(_InIt _First, const _InIt _Last, const _Ty& _Val) { 
    _Adl_verify_range(_First, _Last);
    if constexpr (_Is_vb_iterator<_InIt> && is_same_v<_Ty, bool>) {
        return _Find_vbool(_First, _Last, _Val);
    } else {
        _Seek_wrapped(_First, _Find_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last), _Val));
        return _First;
    }
}


template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _FwdIt find(_ExPo&& _Exec, _FwdIt _First, const _FwdIt _Last, const _Ty& _Val) noexcept; 
#line 5215 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"


namespace ranges {
    template <class _Se, class _It>
    concept _Sized_or_unreachable_sentinel_for = sized_sentinel_for<_Se, _It> || same_as<_Se, unreachable_sentinel_t>;

    
    template <class _Rng>
    concept _Sized_or_infinite_range = range<_Rng>
                                    && (sized_range<_Rng> || same_as<sentinel_t<_Rng>, unreachable_sentinel_t>);

    
    template <input_iterator _It, sentinel_for<_It> _Se, class _Ty, class _Pj = identity>
        requires indirect_binary_predicate<ranges::equal_to, projected<_It, _Pj>, const _Ty*>
    [[nodiscard]] constexpr _It _Find_unchecked(_It _First, const _Se _Last, const _Ty& _Val, _Pj _Proj = {}) {
        
        constexpr bool _Is_sized = sized_sentinel_for<_Se, _It>;
        if constexpr (_Memchr_in_find_is_safe<_It,
                          _Ty> && _Sized_or_unreachable_sentinel_for<_Se, _It> && same_as<_Pj, identity>) {
            if (!::std:: is_constant_evaluated()) {
                if (!_Within_limits(_First, _Val)) {
                    if constexpr (_Is_sized) {
                        return ::std::ranges:: next(::std:: move(_First), _Last);
                    } else {
                        ;
#line 5241 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
                    }
                }

                size_t _Count;
                if constexpr (_Is_sized) {
                    _Count = static_cast<size_t>(_Last - _First);
                } else {
                    _Count = 0xffffffffui32;
                }
                const auto _First_ptr = ::std:: to_address(_First);
                const auto _Result    = static_cast<remove_reference_t<_Iter_ref_t<_It>>*>(
                    :: memchr(_First_ptr, static_cast<unsigned char>(_Val), _Count));
                if (_Result) {
                    if constexpr (is_pointer_v<_It>) {
                        return _Result;
                    } else {
                        return ::std::ranges:: next(::std:: move(_First), _Result - _First_ptr);
                    }
                } else {
                    return ::std::ranges:: next(::std:: move(_First), _Last);
                }
            }
        }

        for (; _First != _Last; ++_First) {
            if (::std:: invoke(_Proj, *_First) == _Val) {
                break;
            }
        }

        return _First;
    }

    class _Find_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It, sentinel_for<_It> _Se, class _Ty, class _Pj = identity>
            requires indirect_binary_predicate<ranges::equal_to, projected<_It, _Pj>, const _Ty*>
        [[nodiscard]] constexpr _It operator()(_It _First, _Se _Last, const _Ty& _Val, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            auto _UResult = ::std::ranges:: _Find_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)), _Val, _Pass_fn(_Proj));

            _Seek_wrapped(_First, ::std:: move(_UResult));
            return _First;
        }

        template <input_range _Rng, class _Ty, class _Pj = identity>
            requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Rng>, _Pj>, const _Ty*>
        [[nodiscard]] constexpr borrowed_iterator_t<_Rng> operator()(
            _Rng&& _Range, const _Ty& _Val, _Pj _Proj = {}) const {
            auto _First = ::std::ranges:: begin(_Range);
            auto _UResult =
                ::std::ranges:: _Find_unchecked(_Get_unwrapped(::std:: move(_First)), _Uend(_Range), _Val, _Pass_fn(_Proj));

            _Seek_wrapped(_First, ::std:: move(_UResult));
            return _First;
        }
        
    };

    inline constexpr _Find_fn find{_Not_quite_object::_Construct_tag{}};
} 
#line 5307 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class _InIt, class _Ty>
[[nodiscard]] constexpr _Iter_diff_t<_InIt> count(const _InIt _First, const _InIt _Last, const _Ty& _Val) {
    
    _Adl_verify_range(_First, _Last);
    if constexpr (_Is_vb_iterator<_InIt> && is_same_v<_Ty, bool>) {
        return _Count_vbool(_First, _Last, _Val);
    } else {
        auto _UFirst               = _Get_unwrapped(_First);
        const auto _ULast          = _Get_unwrapped(_Last);
        _Iter_diff_t<_InIt> _Count = 0;

        for (; _UFirst != _ULast; ++_UFirst) {
            if (*_UFirst == _Val) {
                ++_Count;
            }
        }

        return _Count;
    }
}


template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _Iter_diff_t<_FwdIt> count(
    _ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last, const _Ty& _Val) noexcept; 
#line 5334 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class _InIt, class _Ty, class _Pr>
[[nodiscard]] constexpr _InIt _Find_pr(_InIt _First, const _InIt _Last, const _Ty& _Val, _Pr _Pred) {
    for (; _First != _Last; ++_First) {
        if (_Pred(*_First, _Val)) {
            break;
        }
    }

    return _First;
}

template <class _InIt, class _Ty, class _Pr>
[[nodiscard]] constexpr _Iter_diff_t<_InIt> _Count_pr(_InIt _First, const _InIt _Last, const _Ty& _Val, _Pr _Pred) {
    _Iter_diff_t<_InIt> _Count = 0;

    for (; _First != _Last; ++_First) {
        if (_Pred(*_First, _Val)) {
            ++_Count;
        }
    }

    return _Count;
}

enum class _TrimResult : unsigned char { _KeepTrimming, _HaveWorkAfterTrimming, _ReturnFalse, _ReturnTrue };

template <class _BidIt1, class _BidIt2, class _Pr>
[[nodiscard]] constexpr _TrimResult _Trim_equal(
    _BidIt1& _First1, _BidIt1& _Back1, _BidIt2& _First2, _BidIt2& _Back2, _Pr _Pred) {
    
    
    ;
    ;
    if (_Pred(*_First1, *_First2)) {
        do {
            ++_First1;
            ++_First2;
            if (_First1 == _Back1) {
                
                return _Pred(*_First1, *_First2) ? _TrimResult::_ReturnTrue : _TrimResult::_ReturnFalse;
            }
        } while (_Pred(*_First1, *_First2));
    } else {
        if (!_Pred(*_Back1, *_Back2)) {
            
            return _TrimResult::_HaveWorkAfterTrimming;
        }
        --_Back1;
        --_Back2;
    }

    for (;;) {
        if (_First1 == _Back1) {
            
            return _TrimResult::_ReturnFalse;
        }

        if (!_Pred(*_Back1, *_Back2)) {
            return _TrimResult::_KeepTrimming;
        }
        --_Back1;
        --_Back2;
    }
}

template <class _BidIt1, class _BidIt2, class _Pr>
[[nodiscard]] constexpr _TrimResult _Trim_reversed(
    _BidIt1& _First1, _BidIt1& _Back1, _BidIt2& _First2, _BidIt2& _Back2, _Pr _Pred) {
    
    
    ;
    ;
    if (_Pred(*_First1, *_Back2)) {
        do {
            ++_First1;
            --_Back2;
            if (_First1 == _Back1) {
                
                return _Pred(*_First1, *_First2) ? _TrimResult::_ReturnTrue : _TrimResult::_ReturnFalse;
            }
        } while (_Pred(*_First1, *_Back2));
    } else {
        if (!_Pred(*_Back1, *_First2)) {
            
            return _TrimResult::_HaveWorkAfterTrimming;
        }
        --_Back1;
        ++_First2;
    }

    for (;;) {
        if (_First1 == _Back1) {
            
            return _TrimResult::_ReturnFalse;
        }

        if (!_Pred(*_Back1, *_First2)) {
            return _TrimResult::_KeepTrimming;
        }
        --_Back1;
        ++_First2;
    }
}

template <class _BidIt1, class _BidIt2, class _Pr>
[[nodiscard]] constexpr _TrimResult _Trim_completely(
    _BidIt1& _First1, _BidIt1& _Back1, _BidIt2& _First2, _BidIt2& _Back2, _Pr _Pred) {
    
    _TrimResult _Res = _TrimResult::_KeepTrimming;

    for (bool _Check_reversed = true; _Res == _TrimResult::_KeepTrimming; _Check_reversed = !_Check_reversed) {
        if (_Check_reversed) {
            _Res = _Trim_reversed(_First1, _Back1, _First2, _Back2, _Pred);
        } else {
            _Res = _Trim_equal(_First1, _Back1, _First2, _Back2, _Pred);
        }
    }

    return _Res;
}

template <class _FwdIt1, class _FwdIt2, class _Pr>
[[nodiscard]] constexpr bool _Check_match_counts(
    _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred) {
    
    ;
    ;
    if constexpr (_Is_bidi_iter_v<_FwdIt1> && _Is_bidi_iter_v<_FwdIt2>) {
        do { 
            --_Last1;
            --_Last2;
        } while (_Pred(*_Last1, *_Last2));

        if (_First1 == _Last1) {
            return false;
        }

        const _TrimResult _Res = _Trim_completely(_First1, _Last1, _First2, _Last2, _Pred);

        if (_Res != _TrimResult::_HaveWorkAfterTrimming) {
            return _Res == _TrimResult::_ReturnTrue;
        }

        ++_Last1;
        ++_Last2;
    }

    for (_FwdIt1 _Next1 = _First1; _Next1 != _Last1; ++_Next1) {
        if (_Next1 == _Find_pr(_First1, _Next1, *_Next1, _Pred)) { 
            _Iter_diff_t<_FwdIt2> _Count2 = _Count_pr(_First2, _Last2, *_Next1, _Pred);
            if (_Count2 == 0) {
                return false; 
            }

            _FwdIt1 _Skip1                = _Next_iter(_Next1);
            _Iter_diff_t<_FwdIt1> _Count1 = _Count_pr(_Skip1, _Last1, *_Next1, _Pred) + 1;
            if (_Count2 != _Count1) {
                return false; 
            }
        }
    }

    return true;
}

template <class _BidIt>
constexpr void reverse(const _BidIt _First, const _BidIt _Last) { 
    _Adl_verify_range(_First, _Last);
    auto _UFirst = _Get_unwrapped(_First);
    auto _ULast  = _Get_unwrapped(_Last);

    using _Elem                         = remove_reference_t<_Iter_ref_t<decltype(_UFirst)>>;
    constexpr bool _Allow_vectorization = conjunction_v<bool_constant<_Iterator_is_contiguous<decltype(_UFirst)>>,
        _Is_trivially_swappable<_Elem>, negation<is_volatile<_Elem>>>;
    constexpr size_t _Nx                = sizeof(_Elem);

#pragma warning(suppress : 6326) 
    if constexpr (_Allow_vectorization && _Nx <= 8 && (_Nx & (_Nx - 1)) == 0) {

        if (!::std:: is_constant_evaluated())
#line 5516 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
        {
            if constexpr (_Nx == 1) {
                __std_reverse_trivially_swappable_1(_To_address(_UFirst), _To_address(_ULast));
            } else if constexpr (_Nx == 2) {
                __std_reverse_trivially_swappable_2(_To_address(_UFirst), _To_address(_ULast));
            } else if constexpr (_Nx == 4) {
                __std_reverse_trivially_swappable_4(_To_address(_UFirst), _To_address(_ULast));
            } else {
                __std_reverse_trivially_swappable_8(_To_address(_UFirst), _To_address(_ULast));
            }

            return;
        }
    }
#line 5531 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

    for (; _UFirst != _ULast && _UFirst != --_ULast; ++_UFirst) {
        ::std:: iter_swap(_UFirst, _ULast);
    }
}


template <class _ExPo, class _BidIt, _Enable_if_execution_policy_t<_ExPo> = 0>
void reverse(_ExPo&&, _BidIt _First, _BidIt _Last) noexcept  {
    
    
    return ::std:: reverse(_First, _Last);
}
#line 5545 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class _BidIt>
constexpr pair<_BidIt, _BidIt> _Reverse_until_sentinel_unchecked(_BidIt _First, _BidIt _Sentinel, _BidIt _Last) {
    
    while (_First != _Sentinel && _Last != _Sentinel) {
        ::std:: iter_swap(_First, --_Last);
        ++_First;
    }

    return pair<_BidIt, _BidIt>(_First, _Last);
}

template <class _FwdIt>
constexpr _FwdIt rotate(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last) {
    
    
    _Adl_verify_range(_First, _Mid);
    _Adl_verify_range(_Mid, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    auto _UMid        = _Get_unwrapped(_Mid);
    const auto _ULast = _Get_unwrapped(_Last);
    if (_UFirst == _UMid) {
        return _Last;
    }

    if (_UMid == _ULast) {
        return _First;
    }

    if constexpr (_Is_random_iter_v<_FwdIt>) {
        ::std:: reverse(_UFirst, _UMid);
        ::std:: reverse(_UMid, _ULast);
        ::std:: reverse(_UFirst, _ULast);
        _Seek_wrapped(_First, _UFirst + (_ULast - _UMid));
    } else if constexpr (_Is_bidi_iter_v<_FwdIt>) {
        ::std:: reverse(_UFirst, _UMid);
        ::std:: reverse(_UMid, _ULast);
        auto _Tmp = _Reverse_until_sentinel_unchecked(_UFirst, _UMid, _ULast);
        ::std:: reverse(_Tmp.first, _Tmp.second);
        _Seek_wrapped(_First, _UMid != _Tmp.first ? _Tmp.first : _Tmp.second);
    } else {
        auto _UNext = _UMid;
        do { 
            ::std:: iter_swap(_UFirst, _UNext);
            ++_UFirst;
            ++_UNext;
            if (_UFirst == _UMid) {
                _UMid = _UNext;
            }
        } while (_UNext != _ULast);
        _Seek_wrapped(_First, _UFirst);
        while (_UMid != _ULast) { 
            _UNext = _UMid;
            do {
                ::std:: iter_swap(_UFirst, _UNext);
                ++_UFirst;
                ++_UNext;
                if (_UFirst == _UMid) {
                    _UMid = _UNext;
                }
            } while (_UNext != _ULast);
        }
    }

    return _First;
}


template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt rotate(_ExPo&&, _FwdIt _First, _FwdIt _Mid, _FwdIt _Last) noexcept  {
    
    
    return ::std:: rotate(_First, _Mid, _Last);
}
#line 5621 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class _InIt, class _Pr>
[[nodiscard]] constexpr _InIt find_if(_InIt _First, const _InIt _Last, _Pr _Pred) { 
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    for (; _UFirst != _ULast; ++_UFirst) {
        if (_Pred(*_UFirst)) {
            break;
        }
    }

    _Seek_wrapped(_First, _UFirst);
    return _First;
}


namespace ranges {
    template <class _Result, class _Wrapped, class _Unwrapped>
    [[nodiscard]] constexpr _Result _Rewrap_subrange(_Wrapped& _Val, subrange<_Unwrapped>&& _UResult) {
        
        if constexpr (is_same_v<_Result, dangling>) {
            return dangling{};
        } else if constexpr (is_same_v<_Result, subrange<_Unwrapped>>) {
            return ::std:: move(_UResult);
        } else if constexpr (range<_Wrapped>) {
            ;
            ;
            ;

            auto _First = ::std::ranges:: begin(_Val);
            auto _Last  = _First;
            _First._Seek_to(_UResult.begin());
            _Last._Seek_to(_UResult.end());
            return _Result{::std:: move(_First), ::std:: move(_Last)};
        } else {
            ;
            ;

            auto _Last = _Val;
            _Val._Seek_to(_UResult.begin());
            _Last._Seek_to(_UResult.end());
            return _Result{::std:: move(_Val), ::std:: move(_Last)};
        }
    }

    
    template <input_iterator _It, sentinel_for<_It> _Se, class _Pj, indirect_unary_predicate<projected<_It, _Pj>> _Pr>
    [[nodiscard]] constexpr _It _Find_if_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
        for (; _First != _Last; ++_First) {
            if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_First))) {
                break;
            }
        }

        return _First;
    }

    class _Find_if_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <input_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
        [[nodiscard]] constexpr _It operator()(_It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            auto _UResult = ::std::ranges:: _Find_if_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)), _Pass_fn(_Pred), _Pass_fn(_Proj));

            _Seek_wrapped(_First, ::std:: move(_UResult));
            return _First;
        }

        template <input_range _Rng, class _Pj = identity,
            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
        [[nodiscard]] constexpr borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) const {
            auto _First   = ::std::ranges:: begin(_Range);
            auto _UResult = ::std::ranges:: _Find_if_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Uend(_Range), _Pass_fn(_Pred), _Pass_fn(_Proj));

            _Seek_wrapped(_First, ::std:: move(_UResult));
            return _First;
        }
    };

    inline constexpr _Find_if_fn find_if{_Not_quite_object::_Construct_tag{}};

    class _Find_if_not_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <input_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
        [[nodiscard]] constexpr _It operator()(_It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);

            auto _UResult = _Find_if_not_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)), _Pass_fn(_Pred), _Pass_fn(_Proj));

            _Seek_wrapped(_First, ::std:: move(_UResult));
            return _First;
        }

        template <input_range _Rng, class _Pj = identity,
            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
        [[nodiscard]] constexpr borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) const {
            auto _First = ::std::ranges:: begin(_Range);

            auto _UResult = _Find_if_not_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Uend(_Range), _Pass_fn(_Pred), _Pass_fn(_Proj));

            _Seek_wrapped(_First, ::std:: move(_UResult));
            return _First;
        }

    private:
        template <class _It, class _Se, class _Pj, class _Pr>
        [[nodiscard]] static constexpr _It _Find_if_not_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
            ;
            ;
            ;

            for (; _First != _Last; ++_First) {
                if (!::std:: invoke(_Pred, ::std:: invoke(_Proj, *_First))) {
                    break;
                }
            }

            return _First;
        }
    };

    inline constexpr _Find_if_not_fn find_if_not{_Not_quite_object::_Construct_tag{}};

    
    template <class _It1, class _It2, class _Se2, class _Pr, class _Pj1, class _Pj2>
    concept _Equal_rev_pred_can_memcmp = is_same_v<_Pj1, identity> && is_same_v<_Pj2, identity>
        && sized_sentinel_for<_Se2, _It2> && _Equal_memcmp_is_safe<_It1, _It2, _Pr>;

    template <input_iterator _It1, input_iterator _It2, sentinel_for<_It2> _Se2, class _Pr, class _Pj1, class _Pj2>
        requires indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
    [[nodiscard]] constexpr pair<bool, _It1> _Equal_rev_pred(
        _It1 _First1, _It2 _First2, const _Se2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
        
        
        constexpr bool _Optimize = _Equal_rev_pred_can_memcmp<_It1, _It2, _Se2, _Pr, _Pj1, _Pj2>;
        if constexpr (_Optimize) {
            if (!::std:: is_constant_evaluated()) {
                bool _Ans;
                if constexpr (same_as<_It2, _Se2>) {
                    _Ans = _Memcmp_ranges(_First2, _Last2, _First1) == 0;
                } else {
                    _Ans = _Memcmp_count(_First1, _First2, static_cast<size_t>(_Last2 - _First2)) == 0;
                }

                if (_Ans) {
                    _First1 += (_Last2 - _First2);
                    return {true, ::std:: move(_First1)};
                } else {
                    return {false, _It1{}};
                }
            }
        }

        for (; _First2 != _Last2; ++_First1, (void) ++_First2) {
            if (!::std:: invoke(_Pred, ::std:: invoke(_Proj1, *_First1), ::std:: invoke(_Proj2, *_First2))) {
                return {false, _It1{}};
            }
        }

        return {true, ::std:: move(_First1)};
    }

    class _Search_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <forward_iterator _It1, sentinel_for<_It1> _Se1, forward_iterator _It2, sentinel_for<_It2> _Se2,
            class _Pr = ranges::equal_to, class _Pj1 = identity, class _Pj2 = identity>
            requires indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
        [[nodiscard]] constexpr subrange<_It1> operator()(_It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2,
            _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            
            _Adl_verify_range(_First1, _Last1);
            _Adl_verify_range(_First2, _Last2);
            auto _UFirst1 = _Get_unwrapped(::std:: move(_First1));
            auto _ULast1  = _Get_unwrapped(::std:: move(_Last1));
            auto _UFirst2 = _Get_unwrapped(::std:: move(_First2));
            auto _ULast2  = _Get_unwrapped(::std:: move(_Last2));

            if constexpr (sized_sentinel_for<_Se1, _It1> && sized_sentinel_for<_Se2, _It2>) {
                const auto _Count1 = _ULast1 - _UFirst1;
                const auto _Count2 = _ULast2 - _UFirst2;
                auto _UResult = _Search_sized(::std:: move(_UFirst1), ::std:: move(_ULast1), _Count1, ::std:: move(_UFirst2),
                    ::std:: move(_ULast2), _Count2, _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
                return _Rewrap_subrange<subrange<_It1>>(_First1, ::std:: move(_UResult));
            } else {
                auto _UResult = _Search_unsized(::std:: move(_UFirst1), ::std:: move(_ULast1), ::std:: move(_UFirst2),
                    ::std:: move(_ULast2), _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
                return _Rewrap_subrange<subrange<_It1>>(_First1, ::std:: move(_UResult));
            }
        }

        
        template <forward_range _Rng1, forward_range _Rng2, class _Pr = ranges::equal_to, class _Pj1 = identity,
            class _Pj2 = identity>
            requires indirectly_comparable<iterator_t<_Rng1>, iterator_t<_Rng2>, _Pr, _Pj1, _Pj2>
        [[nodiscard]] constexpr borrowed_subrange_t<_Rng1> operator()(
            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            
            if constexpr (sized_range<_Rng1> && sized_range<_Rng2>) {
                const auto _Count1 = ::std::ranges:: distance(_Range1);
                const auto _Count2 = ::std::ranges:: distance(_Range2);
                auto _UResult      = _Search_sized(_Ubegin(_Range1), _Uend(_Range1), _Count1, _Ubegin(_Range2),
                         _Uend(_Range2), _Count2, _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
                return _Rewrap_subrange<borrowed_subrange_t<_Rng1>>(_Range1, ::std:: move(_UResult));
            } else {
                auto _UResult = _Search_unsized(_Ubegin(_Range1), _Uend(_Range1), _Ubegin(_Range2), _Uend(_Range2),
                    _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
                return _Rewrap_subrange<borrowed_subrange_t<_Rng1>>(_Range1, ::std:: move(_UResult));
            }
        }

    private:
        template <class _It1, class _Se1, class _It2, class _Se2, class _Pr, class _Pj1, class _Pj2>
        [[nodiscard]] static constexpr subrange<_It1> _Search_sized(_It1 _First1, const _Se1 _Last1,
            iter_difference_t<_It1> _Count1, _It2 _First2, const _Se2 _Last2, const iter_difference_t<_It2> _Count2,
            _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
            ;
            ;
            ;
            ;
            ;
            ;
            ;

            for (; _Count1 >= _Count2; ++_First1, (void) --_Count1) {
                auto [_Match, _Mid1] = ::std::ranges:: _Equal_rev_pred(_First1, _First2, _Last2, _Pred, _Proj1, _Proj2);
                if (_Match) {
                    return {::std:: move(_First1), ::std:: move(_Mid1)};
                }
            }

            _First1 = _Find_last_iterator(_First1, _Last1, _Count1);
            return {_First1, _First1};
        }

        template <class _It1, class _Se1, class _It2, class _Se2, class _Pr, class _Pj1, class _Pj2>
        [[nodiscard]] static constexpr subrange<_It1> _Search_unsized(
            _It1 _First1, const _Se1 _Last1, _It2 _First2, const _Se2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
            ;
            ;
            ;
            ;
            ;

            for (;; ++_First1) {
                auto _Mid1 = _First1;
                for (auto _Mid2 = _First2;; ++_Mid1, (void) ++_Mid2) {
                    if (_Mid2 == _Last2) { 
                        return {::std:: move(_First1), ::std:: move(_Mid1)};
                    }

                    if (_Mid1 == _Last1) { 
                        return {_Mid1, _Mid1};
                    }

                    if (!::std:: invoke(_Pred, ::std:: invoke(_Proj1, *_Mid1), ::std:: invoke(_Proj2, *_Mid2))) { 
                        break;
                    }
                }
            }
        }
    };

    inline constexpr _Search_fn search{_Not_quite_object::_Construct_tag{}};
} 
#line 5901 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

template <class _FwdIt, class _Ty, class _Pr>
[[nodiscard]] constexpr _FwdIt lower_bound(_FwdIt _First, const _FwdIt _Last, const _Ty& _Val, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst                = _Get_unwrapped(_First);
    _Iter_diff_t<_FwdIt> _Count = ::std:: distance(_UFirst, _Get_unwrapped(_Last));

    while (0 < _Count) { 
        const _Iter_diff_t<_FwdIt> _Count2 = _Count / 2;
        const auto _UMid                   = ::std:: next(_UFirst, _Count2);
        if (_Pred(*_UMid, _Val)) { 
            _UFirst = _Next_iter(_UMid);
            _Count -= _Count2 + 1;
        } else {
            _Count = _Count2;
        }
    }

    _Seek_wrapped(_First, _UFirst);
    return _First;
}

template <class _FwdIt, class _Ty>
[[nodiscard]] constexpr _FwdIt lower_bound(_FwdIt _First, _FwdIt _Last, const _Ty& _Val) {
    
    return ::std:: lower_bound(_First, _Last, _Val, less<>{});
}

template <class _FwdIt1, class _FwdIt2>
constexpr _FwdIt2 _Swap_ranges_unchecked(_FwdIt1 _First1, const _FwdIt1 _Last1, _FwdIt2 _First2) {
    

    using _Elem1 = remove_reference_t<_Iter_ref_t<_FwdIt1>>;
    using _Elem2 = remove_reference_t<_Iter_ref_t<_FwdIt2>>;
    if constexpr (is_same_v<_Elem1, _Elem2> && _Is_trivially_swappable_v<_Elem1> 
                  && _Iterators_are_contiguous<_FwdIt1, _FwdIt2>) {

        if (!::std:: is_constant_evaluated())
#line 5942 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
        {
            __std_swap_ranges_trivially_swappable_noalias(
                _To_address(_First1), _To_address(_Last1), _To_address(_First2));
            return _First2 + (_Last1 - _First1);
        }
    }
#line 5949 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

    for (; _First1 != _Last1; ++_First1, (void) ++_First2) {
        ::std:: iter_swap(_First1, _First2);
    }

    return _First2;
}

template <class _Diff, class _Urng>
class _Rng_from_urng { 
public:
    using _Ty0 = make_unsigned_t<_Diff>;
    using _Ty1 = typename _Urng::result_type;

    using _Udiff = conditional_t<sizeof(_Ty1) < sizeof(_Ty0), _Ty0, _Ty1>;

    explicit _Rng_from_urng(_Urng& _Func) : _Ref(_Func), _Bits(8 * sizeof(_Udiff)), _Bmask(_Udiff(-1)) {
        for (; (_Urng::max)() - (_Urng::min)() < _Bmask; _Bmask >>= 1) {
            --_Bits;
        }
    }

    _Diff operator()(_Diff _Index) { 
        for (;;) { 
            _Udiff _Ret  = 0; 
            _Udiff _Mask = 0; 

            while (_Mask < _Udiff(_Index - 1)) { 
                _Ret <<= _Bits - 1; 
                _Ret <<= 1;
                _Ret |= _Get_bits();
                _Mask <<= _Bits - 1; 
                _Mask <<= 1;
                _Mask |= _Bmask;
            }

            
            if (_Ret / _Index < _Mask / _Index || _Mask % _Index == _Udiff(_Index - 1)) {
                return static_cast<_Diff>(_Ret % _Index);
            }
        }
    }

    _Udiff _Get_all_bits() {
        _Udiff _Ret = 0;

        for (size_t _Num = 0; _Num < 8 * sizeof(_Udiff); _Num += _Bits) { 
            _Ret <<= _Bits - 1; 
            _Ret <<= 1;
            _Ret |= _Get_bits();
        }

        return _Ret;
    }

    _Rng_from_urng(const _Rng_from_urng&) = delete;
    _Rng_from_urng& operator=(const _Rng_from_urng&) = delete;

private:
    _Udiff _Get_bits() { 
        for (;;) { 
            _Udiff _Val = _Ref() - (_Urng::min)();

            if (_Val <= _Bmask) {
                return _Val;
            }
        }
    }

    _Urng& _Ref; 
    size_t _Bits; 
    _Udiff _Bmask; 
};

template <class _Ty, class _Alloc, class = void>
struct _Has_allocator_type : false_type {}; 

template <class _Ty, class _Alloc>
struct _Has_allocator_type<_Ty, _Alloc, void_t<typename _Ty::allocator_type>>
    : is_convertible<_Alloc, typename _Ty::allocator_type>::type {}; 

struct allocator_arg_t { 
    explicit allocator_arg_t() = default;
};

inline constexpr allocator_arg_t allocator_arg{};

[[noreturn]]  void __cdecl _Xbad_alloc();
[[noreturn]]  void __cdecl _Xinvalid_argument(  const char*);
[[noreturn]]  void __cdecl _Xlength_error(  const char*);
[[noreturn]]  void __cdecl _Xout_of_range(  const char*);
[[noreturn]]  void __cdecl _Xoverflow_error(  const char*);
[[noreturn]]  void __cdecl _Xruntime_error(  const char*);
[[noreturn]]  void __cdecl _XGetLastError();

template <class _Ty, class _Alloc>
struct uses_allocator : _Has_allocator_type<_Ty, _Alloc>::type {
    
};

template <class _Ty, class _Alloc>
inline constexpr bool uses_allocator_v = uses_allocator<_Ty, _Alloc>::value;

template <class _Category, class _Ty, class _Diff = ptrdiff_t, class _Pointer = _Ty*, class _Reference = _Ty&>
struct [[deprecated( "warning STL4015: " "The std::iterator class template (used as a base class to provide typedefs) is deprecated in C++17. " "(The <iterator> header is NOT deprecated.) The C++ Standard has never required user-defined iterators to " "derive from std::iterator. To fix this warning, stop deriving from std::iterator and start providing " "publicly accessible typedefs named iterator_category, value_type, difference_type, pointer, and reference. " "Note that value_type is required to be non-const, even for constant iterators. " "You can define _SILENCE_CXX17_ITERATOR_BASE_CLASS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] iterator { 
    using iterator_category = _Category;
    using value_type        = _Ty;
    using difference_type   = _Diff;
    using pointer           = _Pointer;
    using reference         = _Reference;
};

template <class _Ty, enable_if_t<is_floating_point_v<_Ty>, int> = 0>
[[nodiscard]] constexpr auto _Float_abs_bits(const _Ty& _Xx) {
    using _Traits    = _Floating_type_traits<_Ty>;
    using _Uint_type = typename _Traits::_Uint_type;
    const auto _Bits = _Bit_cast<_Uint_type>(_Xx);
    return _Bits & ~_Traits::_Shifted_sign_mask;
}

template <class _Ty, enable_if_t<is_floating_point_v<_Ty>, int> = 0>
[[nodiscard]] constexpr _Ty _Float_abs(const _Ty _Xx) { 
    return _Bit_cast<_Ty>(_Float_abs_bits(_Xx));
}

template <class _Ty, enable_if_t<is_floating_point_v<_Ty>, int> = 0>
[[nodiscard]] constexpr _Ty _Float_copysign(const _Ty _Magnitude, const _Ty _Sign) { 
    using _Traits       = _Floating_type_traits<_Ty>;
    using _Uint_type    = typename _Traits::_Uint_type;
    const auto _Signbit = _Bit_cast<_Uint_type>(_Sign) & _Traits::_Shifted_sign_mask;
    return _Bit_cast<_Ty>(_Float_abs_bits(_Magnitude) | _Signbit);
}

template <class _Ty, enable_if_t<is_floating_point_v<_Ty>, int> = 0>
[[nodiscard]] constexpr bool _Is_nan(const _Ty _Xx) { 
    using _Traits = _Floating_type_traits<_Ty>;
    return _Float_abs_bits(_Xx) > _Traits::_Shifted_exponent_mask;
}


template <class _Ty, enable_if_t<is_floating_point_v<_Ty>, int> = 0>
[[nodiscard]] constexpr bool _Is_signaling_nan(const _Ty& _Xx) { 
    using _Traits        = _Floating_type_traits<_Ty>;
    const auto _Abs_bits = _Float_abs_bits(_Xx);
    return _Abs_bits > _Traits::_Shifted_exponent_mask && ((_Abs_bits & _Traits::_Special_nan_mantissa_mask) == 0);
}

template <class _Ty, enable_if_t<is_floating_point_v<_Ty>, int> = 0>
[[nodiscard]] constexpr bool _Is_inf(const _Ty _Xx) { 
    using _Traits = _Floating_type_traits<_Ty>;
    return _Float_abs_bits(_Xx) == _Traits::_Shifted_exponent_mask;
}

template <class _Ty, enable_if_t<is_floating_point_v<_Ty>, int> = 0>
[[nodiscard]] constexpr bool _Is_finite(const _Ty _Xx) { 
    using _Traits = _Floating_type_traits<_Ty>;
    return _Float_abs_bits(_Xx) < _Traits::_Shifted_exponent_mask;
}


struct monostate {};
#line 6114 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"

}


#pragma warning(pop)
#pragma pack(pop)
#line 6121 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
#line 6122 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xutility"
#line 17 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tuple"


#pragma once


#line 14 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tuple"


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {

template <bool _Same, class _Dest, class... _Srcs>
inline constexpr bool _Tuple_conditional_explicit_v0 = false;

template <class... _Dests, class... _Srcs>
inline constexpr bool _Tuple_conditional_explicit_v0<true, tuple<_Dests...>, _Srcs...> =
    !conjunction_v<is_convertible<_Srcs, _Dests>...>;

template <class _Dest, class... _Srcs>
inline constexpr bool _Tuple_conditional_explicit_v =
    _Tuple_conditional_explicit_v0<tuple_size_v<_Dest> == sizeof...(_Srcs), _Dest, _Srcs...>;


#line 61 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tuple"

template <bool _Same, class _Dest, class... _Srcs>
inline constexpr bool _Tuple_constructible_v0 = false;

template <class... _Dests, class... _Srcs>
inline constexpr bool _Tuple_constructible_v0<true, tuple<_Dests...>, _Srcs...> =
    conjunction_v<is_constructible<_Dests, _Srcs>...>;

template <class _Dest, class... _Srcs>
inline constexpr bool _Tuple_constructible_v =
    _Tuple_constructible_v0<tuple_size_v<_Dest> == sizeof...(_Srcs), _Dest, _Srcs...>;

template <class _Dest, class... _Srcs>
struct _Tuple_constructible_val : bool_constant<_Tuple_constructible_v<_Dest, _Srcs...>> {};

template <bool _Same, class _Dest, class... _Srcs>
inline constexpr bool _Tuple_nothrow_constructible_v0 = false;

template <class... _Dests, class... _Srcs>
inline constexpr bool _Tuple_nothrow_constructible_v0<true, tuple<_Dests...>, _Srcs...> =
    conjunction_v<is_nothrow_constructible<_Dests, _Srcs>...>;

template <class _Dest, class... _Srcs>
inline constexpr bool _Tuple_nothrow_constructible_v =
    _Tuple_nothrow_constructible_v0<tuple_size_v<_Dest> == sizeof...(_Srcs), _Dest, _Srcs...>;

template <bool _Same, class _Dest, class... _Srcs>
inline constexpr bool _Tuple_assignable_v0 = false;

template <class... _Dests, class... _Srcs>
inline constexpr bool _Tuple_assignable_v0<true, tuple<_Dests...>, _Srcs...> =
    conjunction_v<is_assignable<_Dests&, _Srcs>...>; 

template <class _Dest, class... _Srcs>
inline constexpr bool _Tuple_assignable_v =
    _Tuple_assignable_v0<tuple_size_v<_Dest> == sizeof...(_Srcs), _Dest, _Srcs...>;

template <class _Dest, class... _Srcs>
struct _Tuple_assignable_val : bool_constant<_Tuple_assignable_v<_Dest, _Srcs...>> {};

template <bool _Same, class _Dest, class... _Srcs>
inline constexpr bool _Tuple_nothrow_assignable_v0 = false;

template <class... _Dests, class... _Srcs>
inline constexpr bool _Tuple_nothrow_assignable_v0<true, tuple<_Dests...>, _Srcs...> =
    conjunction_v<is_nothrow_assignable<_Dests&, _Srcs>...>; 

template <class _Dest, class... _Srcs>
inline constexpr bool _Tuple_nothrow_assignable_v =
    _Tuple_nothrow_assignable_v0<tuple_size_v<_Dest> == sizeof...(_Srcs), _Dest, _Srcs...>;


template <class _Myself, class... _Other>
struct _Tuple_convert_copy_val : true_type {};

template <class _This, class _Uty>
struct _Tuple_convert_copy_val<tuple<_This>, _Uty>
    : bool_constant<!disjunction_v<is_same<_This, _Uty>, is_constructible<_This, const tuple<_Uty>&>,
          is_convertible<const tuple<_Uty>&, _This>>> {};


template <class _Myself, class... _Other>
struct _Tuple_convert_move_val : true_type {};

template <class _This, class _Uty>
struct _Tuple_convert_move_val<tuple<_This>, _Uty>
    : bool_constant<!disjunction_v<is_same<_This, _Uty>, is_constructible<_This, tuple<_Uty>>,
          is_convertible<tuple<_Uty>, _This>>> {};


template <class _Myself, class _This2, class... _Rest2>
struct _Tuple_perfect_val : true_type {};

template <class _Myself, class _This2>
struct _Tuple_perfect_val<_Myself, _This2>
    : bool_constant<!is_same_v<_Myself, remove_const_t<remove_reference_t<_This2>>>> {};

struct _Ignore { 
    template <class _Ty>
    constexpr const _Ignore& operator=(const _Ty&) const noexcept  {
        
        return *this;
    }
};

inline constexpr _Ignore ignore{};


template <class _Ty>
struct _Tuple_val { 
    constexpr _Tuple_val() : _Val() {}

    template <class _Other>
    constexpr _Tuple_val(_Other&& _Arg) : _Val(::std:: forward<_Other>(_Arg)) {}

    template <class _Alloc, class... _Other, enable_if_t<!uses_allocator_v<_Ty, _Alloc>, int> = 0>
    constexpr _Tuple_val(const _Alloc&, allocator_arg_t, _Other&&... _Arg) : _Val(::std:: forward<_Other>(_Arg)...) {}

    template <class _Alloc, class... _Other,
        enable_if_t<conjunction_v<::std:: uses_allocator<_Ty, _Alloc>,
                        ::std:: is_constructible<_Ty, ::std:: allocator_arg_t, const _Alloc&, _Other...>>,
            int> = 0>
    constexpr _Tuple_val(const _Alloc& _Al, allocator_arg_t, _Other&&... _Arg)
        : _Val(allocator_arg, _Al, ::std:: forward<_Other>(_Arg)...) {}

    template <class _Alloc, class... _Other,
        enable_if_t<conjunction_v<::std:: uses_allocator<_Ty, _Alloc>,
                        ::std:: negation<::std:: is_constructible<_Ty, ::std:: allocator_arg_t, const _Alloc&, _Other...>>>,
            int> = 0>
    constexpr _Tuple_val(const _Alloc& _Al, allocator_arg_t, _Other&&... _Arg)
        : _Val(::std:: forward<_Other>(_Arg)..., _Al) {}

    _Ty _Val;
};

struct _Exact_args_t {
    explicit _Exact_args_t() = default;
}; 

struct _Unpack_tuple_t {
    explicit _Unpack_tuple_t() = default;
}; 

struct _Alloc_exact_args_t {
    explicit _Alloc_exact_args_t() = default;
}; 

struct _Alloc_unpack_tuple_t {
    explicit _Alloc_unpack_tuple_t() = default;
}; 

template <class... _Types>
class tuple;

template <>
class tuple<> { 
public:
    constexpr tuple() noexcept = default; 

    constexpr tuple(const tuple&) noexcept  {} 

    template <class _Alloc>
    constexpr tuple(allocator_arg_t, const _Alloc&) noexcept  {}

    template <class _Alloc>
    constexpr tuple(allocator_arg_t, const _Alloc&, const tuple&) noexcept  {}

    template <class _Tag, enable_if_t<is_same_v<_Tag, ::std:: _Exact_args_t>, int> = 0>
    constexpr tuple(_Tag) noexcept  {}

    template <class _Tag, class _Alloc, enable_if_t<is_same_v<_Tag, ::std:: _Alloc_exact_args_t>, int> = 0>
    constexpr tuple(_Tag, const _Alloc&) noexcept  {}

    constexpr tuple& operator=(const tuple&) = default;

    constexpr void swap(tuple&) noexcept {}

    constexpr bool _Equals(const tuple&) const noexcept {
        return true;
    }


    [[nodiscard]] constexpr strong_ordering _Three_way_compare(const tuple&) const noexcept {
        return strong_ordering::equal;
    }


#line 235 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tuple"
};

template <class _This, class... _Rest>
class tuple<_This, _Rest...> : private tuple<_Rest...> { 
public:
    using _This_type = _This;
    using _Mybase    = tuple<_Rest...>;

    template <class _Tag, class _This2, class... _Rest2, enable_if_t<is_same_v<_Tag, ::std:: _Exact_args_t>, int> = 0>
    constexpr tuple(_Tag, _This2&& _This_arg, _Rest2&&... _Rest_arg)
        : _Mybase(_Exact_args_t{}, ::std:: forward<_Rest2>(_Rest_arg)...), _Myfirst(::std:: forward<_This2>(_This_arg)) {}

    template <class _Tag, class _Tpl, size_t... _Indices, enable_if_t<is_same_v<_Tag, ::std:: _Unpack_tuple_t>, int> = 0>
    constexpr tuple(_Tag, _Tpl&& _Right, index_sequence<_Indices...>);

    template <class _Tag, class _Tpl, enable_if_t<is_same_v<_Tag, ::std:: _Unpack_tuple_t>, int> = 0>
    constexpr tuple(_Tag, _Tpl&& _Right)
        : tuple(_Unpack_tuple_t{}, ::std:: forward<_Tpl>(_Right),
            make_index_sequence<tuple_size_v<remove_reference_t<_Tpl>>>{}) {}

    template <class _Tag, class _Alloc, class _This2, class... _Rest2,
        enable_if_t<is_same_v<_Tag, ::std:: _Alloc_exact_args_t>, int> = 0>
    constexpr tuple(_Tag, const _Alloc& _Al, _This2&& _This_arg, _Rest2&&... _Rest_arg)
        : _Mybase(_Alloc_exact_args_t{}, _Al, ::std:: forward<_Rest2>(_Rest_arg)...),
          _Myfirst(_Al, allocator_arg, ::std:: forward<_This2>(_This_arg)) {}

    template <class _Tag, class _Alloc, class _Tpl, size_t... _Indices,
        enable_if_t<is_same_v<_Tag, ::std:: _Alloc_unpack_tuple_t>, int> = 0>
    constexpr tuple(_Tag, const _Alloc& _Al, _Tpl&& _Right, index_sequence<_Indices...>);

    template <class _Tag, class _Alloc, class _Tpl, enable_if_t<is_same_v<_Tag, ::std:: _Alloc_unpack_tuple_t>, int> = 0>
    constexpr tuple(_Tag, const _Alloc& _Al, _Tpl&& _Right)
        : tuple(_Alloc_unpack_tuple_t{}, _Al, ::std:: forward<_Tpl>(_Right),
            make_index_sequence<tuple_size_v<remove_reference_t<_Tpl>>>{}) {}


    template <class _This2 = _This,
        enable_if_t<conjunction_v<::std:: is_default_constructible<_This2>, ::std:: is_default_constructible<_Rest>...>,
            int>           = 0>
    constexpr explicit(
        !conjunction_v<_Is_implicitly_default_constructible<_This2>, _Is_implicitly_default_constructible<_Rest>...>)
        tuple() noexcept(conjunction_v<is_nothrow_default_constructible<_This2>,
            is_nothrow_default_constructible<_Rest>...>) 
        : _Mybase(), _Myfirst() {}


#line 297 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tuple"


    template <class _This2 = _This, enable_if_t<_Tuple_constructible_v<tuple, const _This2&, const _Rest&...>, int> = 0>
    constexpr explicit(_Tuple_conditional_explicit_v<tuple, const _This2&, const _Rest&...>) tuple(
        const _This& _This_arg, const _Rest&... _Rest_arg) noexcept(conjunction_v<is_nothrow_copy_constructible<_This2>,
        is_nothrow_copy_constructible<_Rest>...>) 
        : tuple(_Exact_args_t{}, _This_arg, _Rest_arg...) {}


#line 319 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tuple"


    template <class _This2, class... _Rest2,
        enable_if_t<conjunction_v<::std:: _Tuple_perfect_val<tuple, _This2, _Rest2...>,
                        ::std:: _Tuple_constructible_val<tuple, _This2, _Rest2...>>,
            int> = 0>
    constexpr explicit(_Tuple_conditional_explicit_v<tuple, _This2, _Rest2...>) tuple(_This2&& _This_arg,
        _Rest2&&... _Rest_arg) noexcept(_Tuple_nothrow_constructible_v<tuple, _This2, _Rest2...>) 
        : tuple(_Exact_args_t{}, ::std:: forward<_This2>(_This_arg), ::std:: forward<_Rest2>(_Rest_arg)...) {}


#line 345 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tuple"

    tuple(const tuple&) = default;
    tuple(tuple&&)      = default;


    template <class... _Other, enable_if_t<conjunction_v<::std:: _Tuple_constructible_val<tuple, const _Other&...>,
                                               ::std:: _Tuple_convert_copy_val<tuple, _Other...>>,
                                   int> = 0>
    constexpr explicit(_Tuple_conditional_explicit_v<tuple, const _Other&...>)
        tuple(const tuple<_Other...>& _Right) noexcept(
            _Tuple_nothrow_constructible_v<tuple, const _Other&...>) 
        : tuple(_Unpack_tuple_t{}, _Right) {}


#line 372 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tuple"


    template <class... _Other, enable_if_t<conjunction_v<::std:: _Tuple_constructible_val<tuple, _Other...>,
                                               ::std:: _Tuple_convert_move_val<tuple, _Other...>>,
                                   int> = 0>
    constexpr explicit(_Tuple_conditional_explicit_v<tuple, _Other...>)
        tuple(tuple<_Other...>&& _Right) noexcept(_Tuple_nothrow_constructible_v<tuple, _Other...>) 
        : tuple(_Unpack_tuple_t{}, ::std:: move(_Right)) {}


#line 395 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tuple"


    template <class _First, class _Second,
        enable_if_t<_Tuple_constructible_v<tuple, const _First&, const _Second&>, int> = 0>
    constexpr explicit(_Tuple_conditional_explicit_v<tuple, const _First&, const _Second&>)
        tuple(const pair<_First, _Second>& _Right) noexcept(
            _Tuple_nothrow_constructible_v<tuple, const _First&, const _Second&>) 
        : tuple(_Unpack_tuple_t{}, _Right) {}


#line 416 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tuple"


    template <class _First, class _Second, enable_if_t<_Tuple_constructible_v<tuple, _First, _Second>, int> = 0>
    constexpr explicit(_Tuple_conditional_explicit_v<tuple, _First, _Second>) tuple(
        pair<_First, _Second>&& _Right) noexcept(_Tuple_nothrow_constructible_v<tuple, _First, _Second>) 
        : tuple(_Unpack_tuple_t{}, ::std:: move(_Right)) {}


#line 433 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tuple"


    template <class _Alloc, class _This2 = _This,
        enable_if_t<conjunction_v<::std:: is_default_constructible<_This2>, ::std:: is_default_constructible<_Rest>...>,
            int> = 0>
    constexpr explicit(
        !conjunction_v<_Is_implicitly_default_constructible<_This2>, _Is_implicitly_default_constructible<_Rest>...>)
        tuple(allocator_arg_t, const _Alloc& _Al)
        : _Mybase(allocator_arg, _Al), _Myfirst(_Al, allocator_arg) {}


#line 458 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tuple"


    template <class _Alloc, class _This2 = _This,
        enable_if_t<_Tuple_constructible_v<tuple, const _This2&, const _Rest&...>, int> = 0>
    constexpr explicit(_Tuple_conditional_explicit_v<tuple, const _This2&, const _Rest&...>)
        tuple(allocator_arg_t, const _Alloc& _Al, const _This& _This_arg, const _Rest&... _Rest_arg)
        : tuple(_Alloc_exact_args_t{}, _Al, _This_arg, _Rest_arg...) {}


#line 476 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tuple"


    template <class _Alloc, class _This2, class... _Rest2,
        enable_if_t<conjunction_v<::std:: _Tuple_perfect_val<tuple, _This2, _Rest2...>,
                        ::std:: _Tuple_constructible_val<tuple, _This2, _Rest2...>>,
            int> = 0>
    constexpr explicit(_Tuple_conditional_explicit_v<tuple, _This2, _Rest2...>)
        tuple(allocator_arg_t, const _Alloc& _Al, _This2&& _This_arg, _Rest2&&... _Rest_arg)
        : tuple(_Alloc_exact_args_t{}, _Al, ::std:: forward<_This2>(_This_arg), ::std:: forward<_Rest2>(_Rest_arg)...) {}


#line 500 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tuple"

    template <class _Alloc, class _This2 = _This,
        enable_if_t<_Tuple_constructible_v<tuple, const _This2&, const _Rest&...>, int> = 0>
    constexpr tuple(allocator_arg_t, const _Alloc& _Al, const tuple& _Right)
        : tuple(_Alloc_unpack_tuple_t{}, _Al, _Right) {}

    template <class _Alloc, class _This2 = _This, enable_if_t<_Tuple_constructible_v<tuple, _This2, _Rest...>, int> = 0>
    constexpr tuple(allocator_arg_t, const _Alloc& _Al, tuple&& _Right)
        : tuple(_Alloc_unpack_tuple_t{}, _Al, ::std:: move(_Right)) {}


    template <class _Alloc, class... _Other,
        enable_if_t<conjunction_v<::std:: _Tuple_constructible_val<tuple, const _Other&...>,
                        ::std:: _Tuple_convert_copy_val<tuple, _Other...>>,
            int> = 0>
    constexpr explicit(_Tuple_conditional_explicit_v<tuple, const _Other&...>)
        tuple(allocator_arg_t, const _Alloc& _Al, const tuple<_Other...>& _Right)
        : tuple(_Alloc_unpack_tuple_t{}, _Al, _Right) {}


#line 533 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tuple"


    template <class _Alloc, class... _Other,
        enable_if_t<conjunction_v<::std:: _Tuple_constructible_val<tuple, _Other...>,
                        ::std:: _Tuple_convert_move_val<tuple, _Other...>>,
            int> = 0>
    constexpr explicit(_Tuple_conditional_explicit_v<tuple, _Other...>)
        tuple(allocator_arg_t, const _Alloc& _Al, tuple<_Other...>&& _Right)
        : tuple(_Alloc_unpack_tuple_t{}, _Al, ::std:: move(_Right)) {}


#line 555 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tuple"


    template <class _Alloc, class _First, class _Second,
        enable_if_t<_Tuple_constructible_v<tuple, const _First&, const _Second&>, int> = 0>
    constexpr explicit(_Tuple_conditional_explicit_v<tuple, const _First&, const _Second&>)
        tuple(allocator_arg_t, const _Alloc& _Al, const pair<_First, _Second>& _Right)
        : tuple(_Alloc_unpack_tuple_t{}, _Al, _Right) {}


#line 573 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tuple"


    template <class _Alloc, class _First, class _Second,
        enable_if_t<_Tuple_constructible_v<tuple, _First, _Second>, int> = 0>
    constexpr explicit(_Tuple_conditional_explicit_v<tuple, _First, _Second>)
        tuple(allocator_arg_t, const _Alloc& _Al, pair<_First, _Second>&& _Right)
        : tuple(_Alloc_unpack_tuple_t{}, _Al, ::std:: move(_Right)) {}


#line 591 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tuple"

    tuple& operator=(const volatile tuple&) = delete;

    template <class _Myself = tuple, class _This2 = _This,
        enable_if_t<conjunction_v<::std:: _Is_copy_assignable_no_precondition_check<_This2>,
                        ::std:: _Is_copy_assignable_no_precondition_check<_Rest>...>,
            int> = 0>
    constexpr tuple& operator=(_Identity_t<const _Myself&> _Right) noexcept(
        conjunction_v<is_nothrow_copy_assignable<_This2>, is_nothrow_copy_assignable<_Rest>...>)  {
        _Myfirst._Val = _Right._Myfirst._Val;
        _Get_rest()   = _Right._Get_rest();
        return *this;
    }

    template <class _Myself = tuple, class _This2 = _This,
        enable_if_t<conjunction_v<::std:: _Is_move_assignable_no_precondition_check<_This2>,
                        ::std:: _Is_move_assignable_no_precondition_check<_Rest>...>,
            int> = 0>
    constexpr tuple& operator=(_Identity_t<_Myself&&> _Right) noexcept(
        conjunction_v<is_nothrow_move_assignable<_This2>, is_nothrow_move_assignable<_Rest>...>) {
        _Myfirst._Val = ::std:: forward<_This>(_Right._Myfirst._Val);
        _Get_rest()   = ::std:: forward<_Mybase>(_Right._Get_rest());
        return *this;
    }

    template <class... _Other, enable_if_t<conjunction_v<::std:: negation<::std:: is_same<tuple, ::std:: tuple<_Other...>>>,
                                               ::std:: _Tuple_assignable_val<tuple, const _Other&...>>,
                                   int> = 0>
    constexpr tuple& operator=(const tuple<_Other...>& _Right) noexcept(
        _Tuple_nothrow_assignable_v<tuple, const _Other&...>)  {
        _Myfirst._Val = _Right._Myfirst._Val;
        _Get_rest()   = _Right._Get_rest();
        return *this;
    }

    template <class... _Other, enable_if_t<conjunction_v<::std:: negation<::std:: is_same<tuple, ::std:: tuple<_Other...>>>,
                                               ::std:: _Tuple_assignable_val<tuple, _Other...>>,
                                   int> = 0>
    constexpr tuple& operator=(tuple<_Other...>&& _Right) noexcept(
        _Tuple_nothrow_assignable_v<tuple, _Other...>)  {
        _Myfirst._Val = ::std:: forward<typename tuple<_Other...>::_This_type>(_Right._Myfirst._Val);
        _Get_rest()   = ::std:: forward<typename tuple<_Other...>::_Mybase>(_Right._Get_rest());
        return *this;
    }

    template <class _First, class _Second,
        enable_if_t<_Tuple_assignable_v<tuple, const _First&, const _Second&>, int> = 0>
    constexpr tuple& operator=(const pair<_First, _Second>& _Right) noexcept(
        _Tuple_nothrow_assignable_v<tuple, const _First&, const _Second&>)  {
        _Myfirst._Val             = _Right.first;
        _Get_rest()._Myfirst._Val = _Right.second;
        return *this;
    }

    template <class _First, class _Second, enable_if_t<_Tuple_assignable_v<tuple, _First, _Second>, int> = 0>
    constexpr tuple& operator=(pair<_First, _Second>&& _Right) noexcept(
        _Tuple_nothrow_assignable_v<tuple, _First, _Second>)  {
        _Myfirst._Val             = ::std:: forward<_First>(_Right.first);
        _Get_rest()._Myfirst._Val = ::std:: forward<_Second>(_Right.second);
        return *this;
    }

    constexpr void swap(tuple& _Right) noexcept(
        conjunction_v<_Is_nothrow_swappable<_This>, _Is_nothrow_swappable<_Rest>...>) {
        _Swap_adl(_Myfirst._Val, _Right._Myfirst._Val);
        _Mybase::swap(_Right._Get_rest());
    }

    constexpr _Mybase& _Get_rest() noexcept { 
        return *this;
    }

    constexpr const _Mybase& _Get_rest() const noexcept { 
        return *this;
    }

    template <class... _Other>
    constexpr bool _Equals(const tuple<_Other...>& _Right) const {
        return _Myfirst._Val == _Right._Myfirst._Val && _Mybase::_Equals(_Right._Get_rest());
    }


    template <class _First, class... _Other>
    [[nodiscard]] constexpr common_comparison_category_t<_Synth_three_way_result<_This, _First>,
        _Synth_three_way_result<_Rest, _Other>...>
        _Three_way_compare(const tuple<_First, _Other...>& _Right) const {
        if (auto _Result = _Synth_three_way{}(_Myfirst._Val, _Right._Myfirst._Val); _Result != 0) {
            return _Result;
        }
        return _Mybase::_Three_way_compare(_Right._Get_rest());
    }


#line 689 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tuple"

    template <size_t _Index, class... _Types>
    friend constexpr tuple_element_t<_Index, tuple<_Types...>>& get(tuple<_Types...>& _Tuple) noexcept;

    template <size_t _Index, class... _Types>
    friend constexpr const tuple_element_t<_Index, tuple<_Types...>>& get(const tuple<_Types...>& _Tuple) noexcept;

    template <size_t _Index, class... _Types>
    friend constexpr tuple_element_t<_Index, tuple<_Types...>>&& get(tuple<_Types...>&& _Tuple) noexcept;

    template <size_t _Index, class... _Types>
    friend constexpr const tuple_element_t<_Index, tuple<_Types...>>&& get(const tuple<_Types...>&& _Tuple) noexcept;

    template <size_t _Index, class... _Types>
    friend constexpr auto&& _Tuple_get(tuple<_Types...>&& _Tuple) noexcept;

    template <class _Ty, class... _Types>
    friend constexpr _Ty& get(tuple<_Types...>& _Tuple) noexcept;

    template <class _Ty, class... _Types>
    friend constexpr const _Ty& get(const tuple<_Types...>& _Tuple) noexcept;

    template <class _Ty, class... _Types>
    friend constexpr _Ty&& get(tuple<_Types...>&& _Tuple) noexcept;

    template <class _Ty, class... _Types>
    friend constexpr const _Ty&& get(const tuple<_Types...>&& _Tuple) noexcept;

    _Tuple_val<_This> _Myfirst; 
};


template <class... _Types>
tuple(_Types...) -> tuple<_Types...>;

template <class _Ty1, class _Ty2>
tuple(pair<_Ty1, _Ty2>) -> tuple<_Ty1, _Ty2>;

template <class _Alloc, class... _Types>
tuple(allocator_arg_t, _Alloc, _Types...) -> tuple<_Types...>;

template <class _Alloc, class _Ty1, class _Ty2>
tuple(allocator_arg_t, _Alloc, pair<_Ty1, _Ty2>) -> tuple<_Ty1, _Ty2>;

template <class _Alloc, class... _Types>
tuple(allocator_arg_t, _Alloc, tuple<_Types...>) -> tuple<_Types...>;
#line 736 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tuple"

template <class... _Types1, class... _Types2>
[[nodiscard]] constexpr bool operator==(const tuple<_Types1...>& _Left, const tuple<_Types2...>& _Right) {
    static_assert(sizeof...(_Types1) == sizeof...(_Types2), "cannot compare tuples of different sizes");
    return _Left._Equals(_Right);
}


template <class... _Types1, class... _Types2>
[[nodiscard]] constexpr common_comparison_category_t<_Synth_three_way_result<_Types1, _Types2>...> operator<=>(
    const tuple<_Types1...>& _Left, const tuple<_Types2...>& _Right) {
    static_assert(sizeof...(_Types1) == sizeof...(_Types2), "cannot compare tuples of different sizes");
    return _Left._Three_way_compare(_Right);
}


#line 779 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tuple"

template <class... _Types, enable_if_t<conjunction_v<::std:: _Is_swappable<_Types>...>, int> = 0>
constexpr void swap(tuple<_Types...>& _Left, tuple<_Types...>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
    return _Left.swap(_Right);
}

template <class _Ty, class _Tuple>
struct _Tuple_element {}; 

template <class _This, class... _Rest>
struct _Tuple_element<_This, tuple<_This, _Rest...>> { 
    static_assert(!_Is_any_of_v<_This, _Rest...>, "duplicate type T in get<T>(tuple)");
    using _Ttype = tuple<_This, _Rest...>;
};

template <class _Ty, class _This, class... _Rest>
struct _Tuple_element<_Ty, tuple<_This, _Rest...>> { 
    using _Ttype = typename _Tuple_element<_Ty, tuple<_Rest...>>::_Ttype;
};

template <size_t _Index, class... _Types>
[[nodiscard]] constexpr tuple_element_t<_Index, tuple<_Types...>>& get(tuple<_Types...>& _Tuple) noexcept {
    using _Ttype = typename tuple_element<_Index, tuple<_Types...>>::_Ttype;
    return static_cast<_Ttype&>(_Tuple)._Myfirst._Val;
}

template <size_t _Index, class... _Types>
[[nodiscard]] constexpr const tuple_element_t<_Index, tuple<_Types...>>& get(const tuple<_Types...>& _Tuple) noexcept {
    using _Ttype = typename tuple_element<_Index, tuple<_Types...>>::_Ttype;
    return static_cast<const _Ttype&>(_Tuple)._Myfirst._Val;
}

template <size_t _Index, class... _Types>
[[nodiscard]] constexpr tuple_element_t<_Index, tuple<_Types...>>&& get(tuple<_Types...>&& _Tuple) noexcept {
    using _Ty    = tuple_element_t<_Index, tuple<_Types...>>;
    using _Ttype = typename tuple_element<_Index, tuple<_Types...>>::_Ttype;
    return static_cast<_Ty&&>(static_cast<_Ttype&>(_Tuple)._Myfirst._Val);
}

template <size_t _Index, class... _Types>
[[nodiscard]] constexpr const tuple_element_t<_Index, tuple<_Types...>>&& get(const tuple<_Types...>&& _Tuple) noexcept {
    using _Ty    = tuple_element_t<_Index, tuple<_Types...>>;
    using _Ttype = typename tuple_element<_Index, tuple<_Types...>>::_Ttype;
    return static_cast<const _Ty&&>(static_cast<const _Ttype&>(_Tuple)._Myfirst._Val);
}

template <size_t _Index, class... _Types>
[[nodiscard]] constexpr auto&& _Tuple_get(tuple<_Types...>&& _Tuple) noexcept {
    
    using _Ty    = tuple_element_t<_Index, tuple<_Types...>>;
    using _Ttype = typename tuple_element<_Index, tuple<_Types...>>::_Ttype;
    return static_cast<_Ty&&>(static_cast<_Ttype&>(_Tuple)._Myfirst._Val);
}

template <class _Ty, class... _Types>
[[nodiscard]] constexpr _Ty& get(tuple<_Types...>& _Tuple) noexcept {
    using _Ttype = typename _Tuple_element<_Ty, tuple<_Types...>>::_Ttype;
    return static_cast<_Ttype&>(_Tuple)._Myfirst._Val;
}

template <class _Ty, class... _Types>
[[nodiscard]] constexpr const _Ty& get(const tuple<_Types...>& _Tuple) noexcept {
    using _Ttype = typename _Tuple_element<_Ty, tuple<_Types...>>::_Ttype;
    return static_cast<const _Ttype&>(_Tuple)._Myfirst._Val;
}

template <class _Ty, class... _Types>
[[nodiscard]] constexpr _Ty&& get(tuple<_Types...>&& _Tuple) noexcept {
    using _Ttype = typename _Tuple_element<_Ty, tuple<_Types...>>::_Ttype;
    return static_cast<_Ty&&>(static_cast<_Ttype&>(_Tuple)._Myfirst._Val);
}

template <class _Ty, class... _Types>
[[nodiscard]] constexpr const _Ty&& get(const tuple<_Types...>&& _Tuple) noexcept {
    using _Ttype = typename _Tuple_element<_Ty, tuple<_Types...>>::_Ttype;
    return static_cast<const _Ty&&>(static_cast<const _Ttype&>(_Tuple)._Myfirst._Val);
}

template <class _This, class... _Rest>
template <class _Tag, class _Tpl, size_t... _Indices, enable_if_t<is_same_v<_Tag, ::std:: _Unpack_tuple_t>, int>>
constexpr tuple<_This, _Rest...>::tuple(_Tag, _Tpl&& _Right, index_sequence<_Indices...>)
    : tuple(_Exact_args_t{}, ::std:: get<_Indices>(::std:: forward<_Tpl>(_Right))...) {}

template <class _This, class... _Rest>
template <class _Tag, class _Alloc, class _Tpl, size_t... _Indices,
    enable_if_t<is_same_v<_Tag, ::std:: _Alloc_unpack_tuple_t>, int>>
constexpr tuple<_This, _Rest...>::tuple(_Tag, const _Alloc& _Al, _Tpl&& _Right, index_sequence<_Indices...>)
    : tuple(_Alloc_exact_args_t{}, _Al, ::std:: get<_Indices>(::std:: forward<_Tpl>(_Right))...) {}

template <class... _Types>
[[nodiscard]] constexpr tuple<_Unrefwrap_t<_Types>...> make_tuple(_Types&&... _Args) { 
    using _Ttype = tuple<_Unrefwrap_t<_Types>...>;
    return _Ttype(::std:: forward<_Types>(_Args)...);
}

template <class... _Types>
[[nodiscard]] constexpr tuple<_Types&...> tie(_Types&... _Args) noexcept { 
    using _Ttype = tuple<_Types&...>;
    return _Ttype(_Args...);
}

template <class... _Types>
[[nodiscard]] constexpr tuple<_Types&&...> forward_as_tuple(_Types&&... _Args) noexcept { 
    return tuple<_Types&&...>(::std:: forward<_Types>(_Args)...);
}

template <class _Seq_type1, class _Seq_type2>
struct _Cat_sequences;

template <size_t... _Indexes1, size_t... _Indexes2>
struct _Cat_sequences<index_sequence<_Indexes1...>,
    index_sequence<_Indexes2...>> { 
    using type = index_sequence<_Indexes1..., _Indexes2...>;
};

template <class _Ty, size_t _Size>
class array;

template <size_t _Idx, class _Ty, size_t _Size>
[[nodiscard]] constexpr _Ty& get(array<_Ty, _Size>& _Arr) noexcept;

template <size_t _Idx, class _Ty, size_t _Size>
[[nodiscard]] constexpr const _Ty& get(const array<_Ty, _Size>& _Arr) noexcept;

template <size_t _Idx, class _Ty, size_t _Size>
[[nodiscard]] constexpr _Ty&& get(array<_Ty, _Size>&& _Arr) noexcept;

template <size_t _Idx, class _Ty, size_t _Size>
[[nodiscard]] constexpr const _Ty&& get(const array<_Ty, _Size>&& _Arr) noexcept;

template <class _Ty, class... _For_array>
struct _View_as_tuple { 
    static_assert(_Always_false<_Ty>, "Unsupported tuple_cat arguments.");
};

template <class... _Types>
struct _View_as_tuple<tuple<_Types...>> { 
    using type = tuple<_Types...>;
};

template <class _Ty1, class _Ty2>
struct _View_as_tuple<pair<_Ty1, _Ty2>> { 
    using type = tuple<_Ty1, _Ty2>;
};

template <class _Ty, class... _Types>
struct _View_as_tuple<array<_Ty, 0>, _Types...> { 
    using type = tuple<_Types...>;
};

template <class _Ty, size_t _Size, class... _Types>
struct _View_as_tuple<array<_Ty, _Size>, _Types...>
    : _View_as_tuple<array<_Ty, _Size - 1>, _Ty, _Types...> { 
};

template <size_t _Nx, class _Ty>
struct _Repeat_for : integral_constant<size_t, _Nx> {}; 

template <class _Ret, class _Kx_arg, class _Ix_arg, size_t _Ix_next, class... _Tuples>
struct _Tuple_cat2 { 
    static_assert(sizeof...(_Tuples) == 0, "Unsupported tuple_cat arguments.");
    using type        = _Ret;
    using _Kx_arg_seq = _Kx_arg;
    using _Ix_arg_seq = _Ix_arg;
};

template <class... _Types1, class _Kx_arg, size_t... _Ix, size_t _Ix_next, class... _Types2, class... _Rest>
struct _Tuple_cat2<tuple<_Types1...>, _Kx_arg, index_sequence<_Ix...>, _Ix_next, tuple<_Types2...>, _Rest...>
    : _Tuple_cat2<tuple<_Types1..., _Types2...>, typename _Cat_sequences<_Kx_arg, index_sequence_for<_Types2...>>::type,
          index_sequence<_Ix..., _Repeat_for<_Ix_next, _Types2>::value...>, _Ix_next + 1,
          _Rest...> { 
};

template <class... _Tuples>
struct _Tuple_cat1 : _Tuple_cat2<tuple<>, index_sequence<>, index_sequence<>, 0,
                         typename _View_as_tuple<decay_t<_Tuples>>::type...> { 
                                                                               
};

template <class _Ret, size_t... _Kx, size_t... _Ix, class _Ty>
constexpr _Ret _Tuple_cat(index_sequence<_Kx...>, index_sequence<_Ix...>, _Ty&& _Arg) { 
    return _Ret(::std:: get<_Kx>(::std:: get<_Ix>(::std:: forward<_Ty>(_Arg)))...);
}

template <class... _Tuples>
[[nodiscard]] constexpr typename _Tuple_cat1<_Tuples...>::type tuple_cat(_Tuples&&... _Tpls) { 
    using _Cat1 = _Tuple_cat1<_Tuples...>;
    return _Tuple_cat<typename _Cat1::type>(typename _Cat1::_Kx_arg_seq{}, typename _Cat1::_Ix_arg_seq{},
        ::std:: forward_as_tuple(::std:: forward<_Tuples>(_Tpls)...));
}


template <class _Callable, class _Tuple, size_t... _Indices>
constexpr decltype(auto) _Apply_impl(
    _Callable&& _Obj, _Tuple&& _Tpl, index_sequence<_Indices...>) { 
    return ::std:: invoke(::std:: forward<_Callable>(_Obj), ::std:: get<_Indices>(::std:: forward<_Tuple>(_Tpl))...);
}

template <class _Callable, class _Tuple>
constexpr decltype(auto) apply(_Callable&& _Obj, _Tuple&& _Tpl) { 
    return _Apply_impl(::std:: forward<_Callable>(_Obj), ::std:: forward<_Tuple>(_Tpl),
        make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{});
}

template <class _Ty, class _Tuple, size_t... _Indices>
constexpr _Ty _Make_from_tuple_impl(_Tuple&& _Tpl, index_sequence<_Indices...>) {
    
    static_assert(is_constructible_v<_Ty, decltype(::std:: get<_Indices>(::std:: forward<_Tuple>(_Tpl)))...>,
        "the target type must be constructible from the fields of the argument tuple (N4892 [tuple.apply]/2).");
    return _Ty(::std:: get<_Indices>(::std:: forward<_Tuple>(_Tpl))...);
}

template <class _Ty, class _Tuple>
[[nodiscard]] constexpr _Ty make_from_tuple(_Tuple&& _Tpl) { 
    return _Make_from_tuple_impl<_Ty>(
        ::std:: forward<_Tuple>(_Tpl), make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{});
}
#line 997 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tuple"

template <class... _Types, class _Alloc>
struct uses_allocator<tuple<_Types...>, _Alloc> : true_type {}; 


#line 1011 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tuple"

}


#pragma warning(pop)
#pragma pack(pop)
#line 1019 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tuple"
#line 1020 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tuple"
#line 20 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
#line 21 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
template <class _Ty>
struct [[nodiscard]] _Tidy_guard { 
    _Ty* _Target;
    constexpr ~_Tidy_guard() {
        if (_Target) {
            _Target->_Tidy();
        }
    }
};

template <class _Ty>
struct [[nodiscard]] _Tidy_deallocate_guard { 
    _Ty* _Target;
    constexpr ~_Tidy_deallocate_guard() {
        if (_Target) {
            _Target->_Tidy_deallocate();
        }
    }
};

template <class _Keycmp, class _Lhs, class _Rhs>
inline constexpr bool _Nothrow_compare = noexcept(
    static_cast<bool>(::std:: declval<const _Keycmp&>()(::std:: declval<const _Lhs&>(), ::std:: declval<const _Rhs&>())));

template <size_t _Ty_size>
[[nodiscard]] constexpr size_t _Get_size_of_n(const size_t _Count) {
    constexpr bool _Overflow_is_possible = _Ty_size > 1;

    if constexpr (_Overflow_is_possible) {
        constexpr size_t _Max_possible = static_cast<size_t>(-1) / _Ty_size;
        if (_Count > _Max_possible) {
            _Throw_bad_array_new_length(); 
        }
    }

    return _Count * _Ty_size;
}

template <class _Ty>
inline constexpr size_t _New_alignof = (::std:: max)(alignof(_Ty),
    static_cast<size_t>(8u) 
);

struct _Default_allocate_traits {
    __declspec(allocator) static


        void* _Allocate(const size_t _Bytes) {
        return ::operator new(_Bytes);
    }


    __declspec(allocator) static


        void* _Allocate_aligned(const size_t _Bytes, const size_t _Align) {


        {
            return ::operator new (_Bytes, align_val_t{_Align});
        }
    }
#line 100 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
};

constexpr bool _Is_pow_2(const size_t _Value) noexcept {
    return _Value != 0 && (_Value & (_Value - 1)) == 0;
}


constexpr size_t _Big_allocation_threshold = 4096;
constexpr size_t _Big_allocation_alignment = 32;

static_assert(2 * sizeof(void*) <= _Big_allocation_alignment,
    "Big allocation alignment should at least match vector register alignment");
static_assert(_Is_pow_2(_Big_allocation_alignment), "Big allocation alignment must be a power of two");


constexpr size_t _Non_user_size           = sizeof(void*) + _Big_allocation_alignment - 1;
#line 119 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"


constexpr size_t _Big_allocation_sentinel = 0xFAFAFAFAUL;
#line 125 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"

template <class _Traits>
__declspec(allocator) void* _Allocate_manually_vector_aligned(const size_t _Bytes) {
    
    const size_t _Block_size = _Non_user_size + _Bytes;
    if (_Block_size <= _Bytes) {
        _Throw_bad_array_new_length(); 
    }

    const uintptr_t _Ptr_container = reinterpret_cast<uintptr_t>(_Traits::_Allocate(_Block_size));
    do { if (_Ptr_container != 0) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false); 
    void* const _Ptr = reinterpret_cast<void*>((_Ptr_container + _Non_user_size) & ~(_Big_allocation_alignment - 1));
    static_cast<uintptr_t*>(_Ptr)[-1] = _Ptr_container;


    return _Ptr;
}

inline void _Adjust_manually_vector_aligned(void*& _Ptr, size_t& _Bytes) {
    
    _Bytes += _Non_user_size;

    const uintptr_t* const _Ptr_user = static_cast<uintptr_t*>(_Ptr);
    const uintptr_t _Ptr_container   = _Ptr_user[-1];

    
    ;

    
    constexpr uintptr_t _Min_back_shift = sizeof(void*);
#line 163 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
    const uintptr_t _Back_shift = reinterpret_cast<uintptr_t>(_Ptr) - _Ptr_container;
    do { if (_Back_shift >= _Min_back_shift && _Back_shift <= _Non_user_size) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
    _Ptr = reinterpret_cast<void*>(_Ptr_container);
}
#line 168 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"


template <size_t _Align, class _Traits = _Default_allocate_traits,
    enable_if_t<(_Align > 8u), int> = 0>
__declspec(allocator) constexpr void* _Allocate(const size_t _Bytes) {
    
    if (_Bytes == 0) {
        return nullptr;
    }


    if (::std:: is_constant_evaluated()) {
        return _Traits::_Allocate(_Bytes);
    } else
#line 183 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
    {
        size_t _Passed_align = _Align;

        if (_Bytes >= _Big_allocation_threshold) {
            
            _Passed_align = (::std:: max)(_Align, _Big_allocation_alignment);
        }
#line 191 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
        return _Traits::_Allocate_aligned(_Bytes, _Passed_align);
    }
}

template <size_t _Align, enable_if_t<(_Align > 8u), int> = 0>
constexpr void _Deallocate(void* _Ptr, const size_t _Bytes) noexcept {
    

    if (::std:: is_constant_evaluated()) {
        ::operator delete(_Ptr);
    } else
#line 203 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
    {
        size_t _Passed_align = _Align;

        if (_Bytes >= _Big_allocation_threshold) { 
            _Passed_align = (::std:: max)(_Align, _Big_allocation_alignment);
        }
#line 210 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
        ::operator delete (_Ptr, _Bytes, align_val_t{_Passed_align});
    }
}


#line 218 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"

template <size_t _Align, class _Traits = _Default_allocate_traits,
    enable_if_t<(!1 || _Align <= 8u), int> = 0>
__declspec(allocator) constexpr void* _Allocate(const size_t _Bytes) {
    

    if (!::std:: is_constant_evaluated())
#line 227 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
    {
        if (_Bytes >= _Big_allocation_threshold) { 
            return _Allocate_manually_vector_aligned<_Traits>(_Bytes);
        }
    }
#line 233 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"

    if (_Bytes != 0) {
        return _Traits::_Allocate(_Bytes);
    }

    return nullptr;
}

template <size_t _Align, enable_if_t<(!1 || _Align <= 8u), int> = 0>
constexpr void _Deallocate(void* _Ptr, size_t _Bytes) noexcept {
    

    if (::std:: is_constant_evaluated()) {
        ::operator delete(_Ptr);
    } else
#line 249 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
    {

        if (_Bytes >= _Big_allocation_threshold) { 
            _Adjust_manually_vector_aligned(_Ptr, _Bytes);
        }
#line 255 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
        ::operator delete(_Ptr, _Bytes);
    }
}


template <class _Ty, class... _Types>
_Ty* _Global_new(_Types&&... _Args) { 
    struct [[nodiscard]] _Guard_type {
        void* _Result;
        ~_Guard_type() {
            if (_Result) {
                _Deallocate<_New_alignof<_Ty>>(_Result, sizeof(_Ty));
            }
        }
    };

    _Guard_type _Guard{_Allocate<_New_alignof<_Ty>>(sizeof(_Ty))};
    ::new (_Guard._Result) _Ty(::std:: forward<_Types>(_Args)...);
    return static_cast<_Ty*>(::std:: exchange(_Guard._Result, nullptr));
}

template <class _Ptr, class _Ty>
using _Rebind_pointer_t = typename pointer_traits<_Ptr>::template rebind<_Ty>;

template <class _Pointer, enable_if_t<!is_pointer_v<_Pointer>, int> = 0>
constexpr _Pointer _Refancy(typename pointer_traits<_Pointer>::element_type* _Ptr) noexcept {
    return pointer_traits<_Pointer>::pointer_to(*_Ptr);
}

template <class _Pointer, enable_if_t<is_pointer_v<_Pointer>, int> = 0>
constexpr _Pointer _Refancy(_Pointer _Ptr) noexcept {
    return _Ptr;
}

template <class _NoThrowFwdIt, class _NoThrowSentinel>
constexpr void _Destroy_range(_NoThrowFwdIt _First, _NoThrowSentinel _Last) noexcept;

template <class _Ty>
constexpr void _Destroy_in_place(_Ty& _Obj) noexcept {
    if constexpr (is_array_v<_Ty>) {
        _Destroy_range(_Obj, _Obj + extent_v<_Ty>);
    } else {
        _Obj.~_Ty();
    }
}


template <class _Ty>
constexpr void destroy_at(_Ty* const _Location) noexcept  {

    if constexpr (is_array_v<_Ty>) {
        _Destroy_range(::std:: begin(*_Location), ::std:: end(*_Location));
    } else
#line 310 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
    {
        _Location->~_Ty();
    }
}
#line 315 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"

template <class _Ptrty>
auto _Const_cast(_Ptrty _Ptr) noexcept { 
    using _Elem       = typename pointer_traits<_Ptrty>::element_type;
    using _Modifiable = remove_const_t<_Elem>;
    using _Dest       = typename pointer_traits<_Ptrty>::template rebind<_Modifiable>;

    return pointer_traits<_Dest>::pointer_to(const_cast<_Modifiable&>(*_Ptr));
}

template <class _Ty>
auto _Const_cast(_Ty* _Ptr) noexcept {
    return const_cast<remove_const_t<_Ty>*>(_Ptr);
}

template <class _Ty, class = void>
struct _Get_pointer_type {
    using type = typename _Ty::value_type*;
};

__pragma(warning(push)) __pragma(warning(disable : 4996))
template <class _Ty>
struct _Get_pointer_type<_Ty, void_t<typename _Ty::pointer>> {
    using type = typename _Ty::pointer;
};
__pragma(warning(pop))

template <class _Ty, class = void>
struct _Get_const_pointer_type {
    using _Ptrty = typename _Get_pointer_type<_Ty>::type;
    using _Valty = typename _Ty::value_type;
    using type   = typename pointer_traits<_Ptrty>::template rebind<const _Valty>;
};

__pragma(warning(push)) __pragma(warning(disable : 4996))
template <class _Ty>
struct _Get_const_pointer_type<_Ty, void_t<typename _Ty::const_pointer>> {
    using type = typename _Ty::const_pointer;
};
__pragma(warning(pop))

template <class _Ty, class = void>
struct _Get_void_pointer_type {
    using _Ptrty = typename _Get_pointer_type<_Ty>::type;
    using type   = typename pointer_traits<_Ptrty>::template rebind<void>;
};

template <class _Ty>
struct _Get_void_pointer_type<_Ty, void_t<typename _Ty::void_pointer>> {
    using type = typename _Ty::void_pointer;
};

template <class _Ty, class = void>
struct _Get_const_void_pointer_type {
    using _Ptrty = typename _Get_pointer_type<_Ty>::type;
    using type   = typename pointer_traits<_Ptrty>::template rebind<const void>;
};

template <class _Ty>
struct _Get_const_void_pointer_type<_Ty, void_t<typename _Ty::const_void_pointer>> {
    using type = typename _Ty::const_void_pointer;
};

template <class _Ty, class = void>
struct _Get_difference_type {
    using _Ptrty = typename _Get_pointer_type<_Ty>::type;
    using type   = typename pointer_traits<_Ptrty>::difference_type;
};

template <class _Ty>
struct _Get_difference_type<_Ty, void_t<typename _Ty::difference_type>> {
    using type = typename _Ty::difference_type;
};

template <class _Ty, class = void>
struct _Get_size_type {
    using type = make_unsigned_t<typename _Get_difference_type<_Ty>::type>;
};

template <class _Ty>
struct _Get_size_type<_Ty, void_t<typename _Ty::size_type>> {
    using type = typename _Ty::size_type;
};

template <class _Ty, class = void>
struct _Get_propagate_on_container_copy {
    using type = false_type;
};

template <class _Ty>
struct _Get_propagate_on_container_copy<_Ty, void_t<typename _Ty::propagate_on_container_copy_assignment>> {
    using type = typename _Ty::propagate_on_container_copy_assignment;
};

template <class _Ty, class = void>
struct _Get_propagate_on_container_move {
    using type = false_type;
};

template <class _Ty>
struct _Get_propagate_on_container_move<_Ty, void_t<typename _Ty::propagate_on_container_move_assignment>> {
    using type = typename _Ty::propagate_on_container_move_assignment;
};

template <class _Ty, class = void>
struct _Get_propagate_on_container_swap {
    using type = false_type;
};

template <class _Ty>
struct _Get_propagate_on_container_swap<_Ty, void_t<typename _Ty::propagate_on_container_swap>> {
    using type = typename _Ty::propagate_on_container_swap;
};

template <class _Ty, class = void>
struct _Get_is_always_equal {
    using type = bool_constant<is_empty_v<_Ty>>;
};

__pragma(warning(push)) __pragma(warning(disable : 4996))
template <class _Ty>
struct _Get_is_always_equal<_Ty, void_t<typename _Ty::is_always_equal>> {
    using type = typename _Ty::is_always_equal;
};
__pragma(warning(pop))

template <class _Ty, class _Other, class = void>
struct _Get_rebind_type {
    using type = typename _Replace_first_parameter<_Other, _Ty>::type;
};

__pragma(warning(push)) __pragma(warning(disable : 4996))
template <class _Ty, class _Other>
struct _Get_rebind_type<_Ty, _Other, void_t<typename _Ty::template rebind<_Other>::other>> {
    using type = typename _Ty::template rebind<_Other>::other;
};
__pragma(warning(pop))

template <class _Ty>
class allocator;

template <class _Alloc, class = void>
struct _Is_default_allocator : false_type {};

template <class _Ty>
struct _Is_default_allocator<allocator<_Ty>, void_t<typename allocator<_Ty>::_From_primary>>
    : is_same<typename allocator<_Ty>::_From_primary, allocator<_Ty>>::type {};

template <class _Void, class... _Types>
struct _Has_no_allocator_construct : true_type {};

__pragma(warning(push)) __pragma(warning(disable : 4996))
template <class _Alloc, class _Ptr, class... _Args>
struct _Has_no_allocator_construct<
    void_t<decltype(::std:: declval<_Alloc&>().construct(::std:: declval<_Ptr>(), ::std:: declval<_Args>()...))>, _Alloc, _Ptr,
    _Args...> : false_type {};
__pragma(warning(pop))

template <class _Alloc, class _Ptr, class... _Args>
using _Uses_default_construct =
    disjunction<_Is_default_allocator<_Alloc>, _Has_no_allocator_construct<void, _Alloc, _Ptr, _Args...>>;

template <class _Alloc, class _Ptr, class = void>
struct _Has_no_alloc_destroy : true_type {};

__pragma(warning(push)) __pragma(warning(disable : 4996))
template <class _Alloc, class _Ptr>
struct _Has_no_alloc_destroy<_Alloc, _Ptr, void_t<decltype(::std:: declval<_Alloc&>().destroy(::std:: declval<_Ptr>()))>>
    : false_type {};
__pragma(warning(pop))

template <class _Alloc, class _Ptr>
using _Uses_default_destroy = disjunction<_Is_default_allocator<_Alloc>, _Has_no_alloc_destroy<_Alloc, _Ptr>>;

template <class _Alloc, class _Ptr>
using _Uses_default_destroy_t = typename _Uses_default_destroy<_Alloc, _Ptr>::type;

template <class _Alloc, class _Size_type, class _Const_void_pointer, class = void>
struct _Has_allocate_hint : false_type {};

__pragma(warning(push)) __pragma(warning(disable : 4996))
template <class _Alloc, class _Size_type, class _Const_void_pointer>
struct _Has_allocate_hint<_Alloc, _Size_type, _Const_void_pointer,
    void_t<decltype(::std:: declval<_Alloc&>().allocate(
        ::std:: declval<const _Size_type&>(), ::std:: declval<const _Const_void_pointer&>()))>> : true_type {};
__pragma(warning(pop))

template <class _Alloc, class = void>
struct _Has_max_size : false_type {};

__pragma(warning(push)) __pragma(warning(disable : 4996))
template <class _Alloc>
struct _Has_max_size<_Alloc, void_t<decltype(::std:: declval<const _Alloc&>().max_size())>> : true_type {};
__pragma(warning(pop))

template <class _Alloc, class = void>
struct _Has_select_on_container_copy_construction : false_type {};

template <class _Alloc>
struct _Has_select_on_container_copy_construction<_Alloc,
    void_t<decltype(::std:: declval<const _Alloc&>().select_on_container_copy_construction())>> : true_type {};

template <class _Alloc>
struct allocator_traits;

__pragma(warning(push)) __pragma(warning(disable : 4996))
template <class _Alloc>
struct _Normal_allocator_traits { 
    using allocator_type = _Alloc;
    using value_type     = typename _Alloc::value_type;

    using pointer            = typename _Get_pointer_type<_Alloc>::type;
    using const_pointer      = typename _Get_const_pointer_type<_Alloc>::type;
    using void_pointer       = typename _Get_void_pointer_type<_Alloc>::type;
    using const_void_pointer = typename _Get_const_void_pointer_type<_Alloc>::type;

    using size_type       = typename _Get_size_type<_Alloc>::type;
    using difference_type = typename _Get_difference_type<_Alloc>::type;

    using propagate_on_container_copy_assignment = typename _Get_propagate_on_container_copy<_Alloc>::type;
    using propagate_on_container_move_assignment = typename _Get_propagate_on_container_move<_Alloc>::type;
    using propagate_on_container_swap            = typename _Get_propagate_on_container_swap<_Alloc>::type;
    using is_always_equal                        = typename _Get_is_always_equal<_Alloc>::type;

    template <class _Other>
    using rebind_alloc = typename _Get_rebind_type<_Alloc, _Other>::type;

    template <class _Other>
    using rebind_traits = allocator_traits<rebind_alloc<_Other>>;

    [[nodiscard]] static constexpr __declspec(allocator) pointer
        allocate(_Alloc& _Al,  const size_type _Count) {
        return _Al.allocate(_Count);
    }

    [[nodiscard]] static constexpr __declspec(allocator) pointer
        allocate(_Alloc& _Al,  const size_type _Count, const const_void_pointer _Hint) {
        if constexpr (_Has_allocate_hint<_Alloc, size_type, const_void_pointer>::value) {
            return _Al.allocate(_Count, _Hint);
        } else {
            return _Al.allocate(_Count);
        }
    }

    static constexpr void deallocate(_Alloc& _Al, pointer _Ptr, size_type _Count) {
        _Al.deallocate(_Ptr, _Count);
    }

    template <class _Ty, class... _Types>
    static constexpr void construct(_Alloc& _Al, _Ty* _Ptr, _Types&&... _Args) {
        if constexpr (_Uses_default_construct<_Alloc, _Ty*, _Types...>::value) {

            ::std:: construct_at(_Ptr, ::std:: forward<_Types>(_Args)...);


#line 571 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
        } else {
            _Al.construct(_Ptr, ::std:: forward<_Types>(_Args)...);
        }
    }

    template <class _Ty>
    static constexpr void destroy(_Alloc& _Al, _Ty* _Ptr) {
        if constexpr (_Uses_default_destroy<_Alloc, _Ty*>::value) {

            ::std:: destroy_at(_Ptr);


#line 584 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
        } else {
            _Al.destroy(_Ptr);
        }
    }

    [[nodiscard]] static constexpr size_type max_size(const _Alloc& _Al) noexcept {
        if constexpr (_Has_max_size<_Alloc>::value) {
            return _Al.max_size();
        } else {
            return (numeric_limits<size_type>::max)() / sizeof(value_type);
        }
    }

    [[nodiscard]] static constexpr _Alloc select_on_container_copy_construction(const _Alloc& _Al) {
        if constexpr (_Has_select_on_container_copy_construction<_Alloc>::value) {
            return _Al.select_on_container_copy_construction();
        } else {
            return _Al;
        }
    }
};
__pragma(warning(pop))

template <class _Alloc>
struct _Default_allocator_traits { 
    using allocator_type = _Alloc;
    using value_type     = typename _Alloc::value_type;

    using pointer            = value_type*;
    using const_pointer      = const value_type*;
    using void_pointer       = void*;
    using const_void_pointer = const void*;

    using size_type       = size_t;
    using difference_type = ptrdiff_t;

    using propagate_on_container_copy_assignment = false_type;
    using propagate_on_container_move_assignment = true_type;
    using propagate_on_container_swap            = false_type;
    using is_always_equal                        = true_type;

    template <class _Other>
    using rebind_alloc = allocator<_Other>;

    template <class _Other>
    using rebind_traits = allocator_traits<allocator<_Other>>;

    [[nodiscard]] static constexpr __declspec(allocator) pointer
        allocate(_Alloc& _Al,  const size_type _Count) {

        if (::std:: is_constant_evaluated()) {
            return _Al.allocate(_Count);
        } else
#line 638 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
        {
            (void) _Al;
            return static_cast<pointer>(
                _Allocate<_New_alignof<value_type>>(_Get_size_of_n<sizeof(value_type)>(_Count)));
        }
    }

    [[nodiscard]] static constexpr __declspec(allocator) pointer
        allocate(_Alloc& _Al,  const size_type _Count, const_void_pointer) {

        if (::std:: is_constant_evaluated()) {
            return _Al.allocate(_Count);
        } else
#line 652 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
        {
            (void) _Al;
            return static_cast<pointer>(
                _Allocate<_New_alignof<value_type>>(_Get_size_of_n<sizeof(value_type)>(_Count)));
        }
    }

    static constexpr void deallocate(_Alloc& _Al, const pointer _Ptr, const size_type _Count) {
        

        if (::std:: is_constant_evaluated()) {
            _Al.deallocate(_Ptr, _Count);
        } else
#line 666 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
        {
            (void) _Al;
            _Deallocate<_New_alignof<value_type>>(_Ptr, sizeof(value_type) * _Count);
        }
    }

    template <class _Objty, class... _Types>
    static constexpr void construct(_Alloc&, _Objty* const _Ptr, _Types&&... _Args) {

        if (::std:: is_constant_evaluated()) {
            ::std:: construct_at(_Ptr, ::std:: forward<_Types>(_Args)...);
        } else
#line 679 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
        {
            ::new (_Voidify_iter(_Ptr)) _Objty(::std:: forward<_Types>(_Args)...);
        }
    }

    template <class _Uty>
    static constexpr void destroy(_Alloc&, _Uty* const _Ptr) {

        ::std:: destroy_at(_Ptr);


#line 691 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
    }

    [[nodiscard]] static constexpr size_type max_size(const _Alloc&) noexcept {
        return static_cast<size_t>(-1) / sizeof(value_type);
    }

    [[nodiscard]] static constexpr _Alloc select_on_container_copy_construction(const _Alloc& _Al) {
        return _Al;
    }
};

template <class _Alloc>
struct allocator_traits : conditional_t<_Is_default_allocator<_Alloc>::value, _Default_allocator_traits<_Alloc>,
                              _Normal_allocator_traits<_Alloc>> {};


template <class _Alloc>
inline constexpr bool _Choose_pocca_v = allocator_traits<_Alloc>::propagate_on_container_copy_assignment::value
                                          && !allocator_traits<_Alloc>::is_always_equal::value;

enum class _Pocma_values {
    _Equal_allocators, 
    _Propagate_allocators, 
    _No_propagate_allocators, 
};

template <class _Alloc>
inline constexpr _Pocma_values
    _Choose_pocma_v = allocator_traits<_Alloc>::is_always_equal::value
                        ? _Pocma_values::_Equal_allocators
                        : (allocator_traits<_Alloc>::propagate_on_container_move_assignment::value
                                ? _Pocma_values::_Propagate_allocators
                                : _Pocma_values::_No_propagate_allocators);

template <class _Alloc, class _Value_type>
using _Rebind_alloc_t = typename allocator_traits<_Alloc>::template rebind_alloc<_Value_type>;


template <class _Alloc, class _Value_type>
using _Maybe_rebind_alloc_t =
    typename _Select<is_same_v<typename _Alloc::value_type, _Value_type>>::template _Apply<_Alloc&,
        _Rebind_alloc_t<_Alloc, _Value_type>>;

template <class _Alloc> 
inline constexpr bool _Is_simple_alloc_v = is_same_v<typename allocator_traits<_Alloc>::size_type, size_t>&&
    is_same_v<typename allocator_traits<_Alloc>::difference_type, ptrdiff_t>&&
        is_same_v<typename allocator_traits<_Alloc>::pointer, typename _Alloc::value_type*>&&
            is_same_v<typename allocator_traits<_Alloc>::const_pointer, const typename _Alloc::value_type*>;

template <class _Value_type>
struct _Simple_types { 
                       
    using value_type      = _Value_type;
    using size_type       = size_t;
    using difference_type = ptrdiff_t;
    using pointer         = value_type*;
    using const_pointer   = const value_type*;
};


template <class _Ptr>
struct allocation_result {
    _Ptr ptr;
    size_t count;
};


template <class _Alloc>
concept _Has_member_allocate_at_least = requires(_Alloc _Al, size_t _Count) {
    _Al.allocate_at_least(_Count);
};

template <class _Alloc>
[[nodiscard]] constexpr allocation_result<typename allocator_traits<_Alloc>::pointer> allocate_at_least(
    _Alloc& _Al, const size_t _Count) {
    if constexpr (_Has_member_allocate_at_least<_Alloc>) {
        return _Al.allocate_at_least(_Count);
    } else {
        return {_Al.allocate(_Count), _Count};
    }
}
#line 775 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
#line 776 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"


inline constexpr size_t _Asan_granularity = 8;

template <class _Ty>
class allocator {
public:
    static_assert(!is_const_v<_Ty>, "The C++ Standard forbids containers of const elements "
                                    "because allocator<const T> is ill-formed.");

    using _From_primary = allocator;

    using value_type = _Ty;


#line 797 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"

    using size_type       = size_t;
    using difference_type = ptrdiff_t;

    using propagate_on_container_move_assignment           = true_type;
    using is_always_equal [[deprecated("warning STL4033: " "std::allocator::is_always_equal is deprecated in C++20 by LWG-3170. " "Prefer std::allocator_traits<allocator<T>>::is_always_equal. " "You can define _SILENCE_CXX20_IS_ALWAYS_EQUAL_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] = true_type;


#line 818 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"

    constexpr allocator() noexcept {}

    constexpr allocator(const allocator&) noexcept = default;
    template <class _Other>
    constexpr allocator(const allocator<_Other>&) noexcept {}
    constexpr ~allocator()       = default;
    constexpr allocator& operator=(const allocator&) = default;

    constexpr void deallocate(_Ty* const _Ptr, const size_t _Count) {
        ;
        
        _Deallocate<_New_alignof<_Ty>>(_Ptr, sizeof(_Ty) * _Count);
    }

    [[nodiscard]] constexpr __declspec(allocator) _Ty* allocate( const size_t _Count) {
        return static_cast<_Ty*>(_Allocate<_New_alignof<_Ty>>(_Get_size_of_n<sizeof(_Ty)>(_Count)));
    }


    [[nodiscard]] constexpr allocation_result<_Ty*> allocate_at_least( const size_t _Count) {
        return {allocate(_Count), _Count};
    }
#line 842 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"


#line 863 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"

    static constexpr size_t _Minimum_allocation_alignment = _Asan_granularity;
};

template <>
class allocator<void> {
public:
    using value_type = void;


#line 875 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"

    using size_type       = size_t;
    using difference_type = ptrdiff_t;

    using propagate_on_container_move_assignment           = true_type;
    using is_always_equal [[deprecated("warning STL4033: " "std::allocator::is_always_equal is deprecated in C++20 by LWG-3170. " "Prefer std::allocator_traits<allocator<T>>::is_always_equal. " "You can define _SILENCE_CXX20_IS_ALWAYS_EQUAL_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] = true_type;


#line 888 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
};

template <class _Ty, class _Other>
[[nodiscard]] constexpr bool operator==(const allocator<_Ty>&, const allocator<_Other>&) noexcept {
    return true;
}


#line 901 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"


template <class _Alloc>
using _Guide_size_type_t =
    typename allocator_traits<conditional_t<_Is_allocator<_Alloc>::value, _Alloc, allocator<int>>>::size_type;
#line 908 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"

template <class _Alloc>
using _Alloc_ptr_t = typename allocator_traits<_Alloc>::pointer;

template <class _Alloc>
using _Alloc_size_t = typename allocator_traits<_Alloc>::size_type;

template <class _Alloc>
constexpr void _Pocca(_Alloc& _Left, const _Alloc& _Right) noexcept {
    if constexpr (allocator_traits<_Alloc>::propagate_on_container_copy_assignment::value) {
        _Left = _Right;
    }
}

template <class _Alloc>
constexpr void _Pocma(_Alloc& _Left, _Alloc& _Right) noexcept { 
    if constexpr (allocator_traits<_Alloc>::propagate_on_container_move_assignment::value) {
        _Left = ::std:: move(_Right);
    }
}

template <class _Alloc>
constexpr void _Pocs(_Alloc& _Left, _Alloc& _Right) noexcept {
    if constexpr (allocator_traits<_Alloc>::propagate_on_container_swap::value) {
        _Swap_adl(_Left, _Right);
    } else {
        ;
    }
}

template <class _Alloc>
constexpr void _Destroy_range(_Alloc_ptr_t<_Alloc> _First, const _Alloc_ptr_t<_Alloc> _Last, _Alloc& _Al) noexcept {
    
    using _Ty = typename _Alloc::value_type;
    if constexpr (!conjunction_v<is_trivially_destructible<_Ty>, _Uses_default_destroy<_Alloc, _Ty*>>) {
        for (; _First != _Last; ++_First) {
            allocator_traits<_Alloc>::destroy(_Al, _Unfancy(_First));
        }
    }
}

template <class _NoThrowFwdIt, class _NoThrowSentinel>
constexpr void _Destroy_range(_NoThrowFwdIt _First, const _NoThrowSentinel _Last) noexcept {
    
    if constexpr (!is_trivially_destructible_v<_Iter_value_t<_NoThrowFwdIt>>) {
        for (; _First != _Last; ++_First) {
            _Destroy_in_place(*_First);
        }
    }
}

template <class _Size_type>
[[nodiscard]] constexpr _Size_type _Convert_size(const size_t _Len) noexcept(is_same_v<_Size_type, size_t>) {
    
    if constexpr (!is_same_v<_Size_type, size_t>) {
        if (_Len > (numeric_limits<_Size_type>::max)()) {
            _Xlength_error("size_t too long for _Size_type");
        }
    }

    return static_cast<_Size_type>(_Len);
}

template <class _Alloc>
constexpr void _Deallocate_plain(_Alloc& _Al, typename _Alloc::value_type* const _Ptr) noexcept {
    
    using _Alloc_traits = allocator_traits<_Alloc>;
    if constexpr (is_same_v<_Alloc_ptr_t<_Alloc>, typename _Alloc::value_type*>) {
        _Alloc_traits::deallocate(_Al, _Ptr, 1);
    } else {
        using _Ptr_traits = pointer_traits<_Alloc_ptr_t<_Alloc>>;
        _Alloc_traits::deallocate(_Al, _Ptr_traits::pointer_to(*_Ptr), 1);
    }
}

template <class _Alloc>
constexpr void _Delete_plain_internal(_Alloc& _Al, typename _Alloc::value_type* const _Ptr) noexcept {
    
    using _Ty = typename _Alloc::value_type;
    _Ptr->~_Ty();
    _Deallocate_plain(_Al, _Ptr);
}

template <class _Alloc>
struct _Alloc_construct_ptr { 
    using pointer = _Alloc_ptr_t<_Alloc>;
    _Alloc& _Al;
    pointer _Ptr;

    constexpr explicit _Alloc_construct_ptr(_Alloc& _Al_) : _Al(_Al_), _Ptr(nullptr) {}

    [[nodiscard]] constexpr pointer _Release() noexcept { 
        return ::std:: exchange(_Ptr, nullptr);
    }

    constexpr void _Allocate() { 
        _Ptr = nullptr; 
        _Ptr = _Al.allocate(1);
    }

    constexpr ~_Alloc_construct_ptr() { 
        if (_Ptr) {
            _Al.deallocate(_Ptr, 1);
        }
    }

    _Alloc_construct_ptr(const _Alloc_construct_ptr&) = delete;
    _Alloc_construct_ptr& operator=(const _Alloc_construct_ptr&) = delete;
};

struct _Fake_allocator {};

struct _Container_base0 {
    constexpr void _Orphan_all() noexcept {}
    constexpr void _Swap_proxy_and_iterators(_Container_base0&) noexcept {}
    constexpr void _Alloc_proxy(const _Fake_allocator&) noexcept {}
    constexpr void _Reload_proxy(const _Fake_allocator&, const _Fake_allocator&) noexcept {}
};

struct _Iterator_base0 {
    constexpr void _Adopt(const void*) noexcept {}
    constexpr const _Container_base0* _Getcont() const noexcept {
        return nullptr;
    }

    static constexpr bool _Unwrap_when_unverified = true;
};

struct _Container_base12;
struct _Container_proxy { 
    constexpr _Container_proxy() noexcept = default;
    constexpr _Container_proxy(_Container_base12* _Mycont_) noexcept : _Mycont(_Mycont_) {}

    const _Container_base12* _Mycont       = nullptr;
    mutable _Iterator_base12* _Myfirstiter = nullptr;
};

struct _Container_base12 {
public:
    constexpr _Container_base12() noexcept = default;

    _Container_base12(const _Container_base12&) = delete;
    _Container_base12& operator=(const _Container_base12&) = delete;

    constexpr void _Orphan_all() noexcept;
    constexpr void _Swap_proxy_and_iterators(_Container_base12&) noexcept;

    template <class _Alloc>
    constexpr void _Alloc_proxy(_Alloc&& _Al) {
        _Container_proxy* const _New_proxy = _Unfancy(_Al.allocate(1));
        _Construct_in_place(*_New_proxy, this);
        _Myproxy            = _New_proxy;
        _New_proxy->_Mycont = this;
    }

    template <class _Alloc>
    constexpr void _Reload_proxy(_Alloc&& _Old_alloc, _Alloc&& _New_alloc) {
        
        _Container_proxy* const _New_proxy = _Unfancy(_New_alloc.allocate(1));
        _Construct_in_place(*_New_proxy, this);
        _New_proxy->_Mycont = this;
        _Delete_plain_internal(_Old_alloc, ::std:: exchange(_Myproxy, _New_proxy));
    }

    _Container_proxy* _Myproxy = nullptr;

private:
    constexpr void _Orphan_all_unlocked_v3() noexcept;
    constexpr void _Swap_proxy_and_iterators_unlocked(_Container_base12&) noexcept;

    void _Orphan_all_locked_v3() noexcept {
        _Lockit _Lock(3);
        _Orphan_all_unlocked_v3();
    }

    void _Swap_proxy_and_iterators_locked(_Container_base12& _Right) noexcept {
        _Lockit _Lock(3);
        _Swap_proxy_and_iterators_unlocked(_Right);
    }
};

struct _Iterator_base12 { 
public:
    constexpr _Iterator_base12() noexcept = default; 

    constexpr _Iterator_base12(const _Iterator_base12& _Right) noexcept {
        *this = _Right;
    }

    constexpr _Iterator_base12& operator=(const _Iterator_base12& _Right) noexcept {


#line 1108 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
        _Myproxy = _Right._Myproxy;
#line 1110 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
        return *this;
    }


#line 1136 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
    constexpr void _Adopt(const _Container_base12* _Parent) noexcept {
        if (_Parent) { 
            _Myproxy = _Parent->_Myproxy;
        } else { 
            _Myproxy = nullptr;
        }
    }
#line 1144 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"

    constexpr const _Container_base12* _Getcont() const noexcept {
        return _Myproxy ? _Myproxy->_Mycont : nullptr;
    }

    static constexpr bool _Unwrap_when_unverified = 0 == 0;

    mutable _Container_proxy* _Myproxy    = nullptr;
    mutable _Iterator_base12* _Mynextiter = nullptr;


#line 1217 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
};

constexpr void _Container_base12::_Orphan_all_unlocked_v3() noexcept {
    if (!_Myproxy) { 
        return;
    }

    
    for (auto& _Pnext = _Myproxy->_Myfirstiter; _Pnext; _Pnext = _Pnext->_Mynextiter) { 
        _Pnext->_Myproxy = nullptr;
    }
    _Myproxy->_Myfirstiter = nullptr;
}

constexpr void _Container_base12::_Orphan_all() noexcept {


#line 1242 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
}

constexpr void _Container_base12::_Swap_proxy_and_iterators_unlocked(_Container_base12& _Right) noexcept {
    _Container_proxy* _Temp = _Myproxy;
    _Myproxy                = _Right._Myproxy;
    _Right._Myproxy         = _Temp;

    if (_Myproxy) {
        _Myproxy->_Mycont = this;
    }

    if (_Right._Myproxy) {
        _Right._Myproxy->_Mycont = &_Right;
    }
}

constexpr void _Container_base12::_Swap_proxy_and_iterators(_Container_base12& _Right) noexcept {


#line 1269 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
    _Swap_proxy_and_iterators_unlocked(_Right);
#line 1271 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
}


using _Container_base = _Container_base0;
using _Iterator_base  = _Iterator_base0;


#line 1280 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"

struct _Leave_proxy_unbound {
    explicit _Leave_proxy_unbound() = default;
}; 

struct _Fake_proxy_ptr_impl { 
    _Fake_proxy_ptr_impl(const _Fake_proxy_ptr_impl&) = delete;
    _Fake_proxy_ptr_impl& operator=(const _Fake_proxy_ptr_impl&) = delete;
    constexpr _Fake_proxy_ptr_impl(const _Fake_allocator&, _Leave_proxy_unbound) noexcept {}
    constexpr _Fake_proxy_ptr_impl(const _Fake_allocator&, const _Container_base0&) noexcept {}

    constexpr void _Bind(const _Fake_allocator&, _Container_base0*) noexcept {}
    constexpr void _Release() noexcept {}
};

struct _Basic_container_proxy_ptr12 {
    
    _Container_proxy* _Ptr = nullptr;

    constexpr void _Release() noexcept { 
        _Ptr = nullptr;
    }

protected:
    constexpr _Basic_container_proxy_ptr12()                       = default;
    _Basic_container_proxy_ptr12(const _Basic_container_proxy_ptr12&) = delete;
    _Basic_container_proxy_ptr12(_Basic_container_proxy_ptr12&&)      = delete;
};

template <class _Alloc>
struct _Container_proxy_ptr12 : _Basic_container_proxy_ptr12 {
    
    _Alloc& _Al;

    constexpr _Container_proxy_ptr12(_Alloc& _Al_, _Leave_proxy_unbound) : _Al(_Al_) {
        
        _Ptr = _Unfancy(_Al_.allocate(1));
        _Construct_in_place(*_Ptr);
    }

    constexpr _Container_proxy_ptr12(_Alloc& _Al_, _Container_base12& _Mycont) : _Al(_Al_) {
        
        _Ptr = _Unfancy(_Al_.allocate(1));
        _Construct_in_place(*_Ptr, ::std:: addressof(_Mycont));
        _Mycont._Myproxy = _Ptr;
    }

    constexpr void _Bind(_Alloc& _Old_alloc, _Container_base12* _Mycont) noexcept {
        
        
        _Ptr->_Mycont = _Mycont;
        _Delete_plain_internal(_Old_alloc, ::std:: exchange(_Mycont->_Myproxy, ::std:: exchange(_Ptr, nullptr)));
    }

    constexpr ~_Container_proxy_ptr12() {
        if (_Ptr) {
            _Delete_plain_internal(_Al, _Ptr);
        }
    }
};


inline constexpr _Fake_allocator _Fake_alloc{};

template <class _Alloc>
using _Container_proxy_ptr = _Fake_proxy_ptr_impl;


#line 1351 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"

struct _Zero_then_variadic_args_t {
    explicit _Zero_then_variadic_args_t() = default;
}; 

struct _One_then_variadic_args_t {
    explicit _One_then_variadic_args_t() = default;
}; 

template <class _Ty1, class _Ty2, bool = is_empty_v<_Ty1> && !is_final_v<_Ty1>>
class _Compressed_pair final : private _Ty1 { 
public:
    _Ty2 _Myval2;

    using _Mybase = _Ty1; 

    template <class... _Other2>
    constexpr explicit _Compressed_pair(_Zero_then_variadic_args_t, _Other2&&... _Val2) noexcept(
        conjunction_v<is_nothrow_default_constructible<_Ty1>, is_nothrow_constructible<_Ty2, _Other2...>>)
        : _Ty1(), _Myval2(::std:: forward<_Other2>(_Val2)...) {}

    template <class _Other1, class... _Other2>
    constexpr _Compressed_pair(_One_then_variadic_args_t, _Other1&& _Val1, _Other2&&... _Val2) noexcept(
        conjunction_v<is_nothrow_constructible<_Ty1, _Other1>, is_nothrow_constructible<_Ty2, _Other2...>>)
        : _Ty1(::std:: forward<_Other1>(_Val1)), _Myval2(::std:: forward<_Other2>(_Val2)...) {}

    constexpr _Ty1& _Get_first() noexcept {
        return *this;
    }

    constexpr const _Ty1& _Get_first() const noexcept {
        return *this;
    }
};

template <class _Ty1, class _Ty2>
class _Compressed_pair<_Ty1, _Ty2, false> final { 
public:
    _Ty1 _Myval1;
    _Ty2 _Myval2;

    template <class... _Other2>
    constexpr explicit _Compressed_pair(_Zero_then_variadic_args_t, _Other2&&... _Val2) noexcept(
        conjunction_v<is_nothrow_default_constructible<_Ty1>, is_nothrow_constructible<_Ty2, _Other2...>>)
        : _Myval1(), _Myval2(::std:: forward<_Other2>(_Val2)...) {}

    template <class _Other1, class... _Other2>
    constexpr _Compressed_pair(_One_then_variadic_args_t, _Other1&& _Val1, _Other2&&... _Val2) noexcept(
        conjunction_v<is_nothrow_constructible<_Ty1, _Other1>, is_nothrow_constructible<_Ty2, _Other2...>>)
        : _Myval1(::std:: forward<_Other1>(_Val1)), _Myval2(::std:: forward<_Other2>(_Val2)...) {}

    constexpr _Ty1& _Get_first() noexcept {
        return _Myval1;
    }

    constexpr const _Ty1& _Get_first() const noexcept {
        return _Myval1;
    }
};

struct _Move_allocator_tag {
    explicit _Move_allocator_tag() = default;
};

template <class _Ty>
pair<_Ty*, ptrdiff_t> _Get_temporary_buffer(ptrdiff_t _Count) noexcept {
    if (static_cast<size_t>(_Count) <= static_cast<size_t>(-1) / sizeof(_Ty)) {
        for (; 0 < _Count; _Count /= 2) {
            const auto _Size = static_cast<size_t>(_Count) * sizeof(_Ty);
            void* _Pbuf;

            if constexpr (alignof(_Ty) > 8u) {
                _Pbuf = ::operator new (_Size, align_val_t{alignof(_Ty)}, nothrow);
            } else
#line 1426 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
            {
                _Pbuf = ::operator new(_Size, nothrow);
            }

            if (_Pbuf) {
                return {static_cast<_Ty*>(_Pbuf), _Count};
            }
        }
    }

    return {nullptr, 0};
}

template <class _Ty>
void _Return_temporary_buffer(_Ty* const _Pbuf) noexcept {

    if constexpr (alignof(_Ty) > 8u) {
        ::operator delete (_Pbuf, align_val_t{alignof(_Ty)});
    } else
#line 1446 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
    {
        ::operator delete(_Pbuf);
    }
}

template <class _NoThrowFwdIt>
struct [[nodiscard]] _Uninitialized_backout {
    
    _NoThrowFwdIt _First;
    _NoThrowFwdIt _Last;

    constexpr explicit _Uninitialized_backout(_NoThrowFwdIt _Dest) : _First(_Dest), _Last(_Dest) {}

    constexpr _Uninitialized_backout(_NoThrowFwdIt _First_, _NoThrowFwdIt _Last_) : _First(_First_), _Last(_Last_) {}

    _Uninitialized_backout(const _Uninitialized_backout&) = delete;
    _Uninitialized_backout& operator=(const _Uninitialized_backout&) = delete;

    constexpr ~_Uninitialized_backout() {
        _Destroy_range(_First, _Last);
    }

    template <class... _Types>
    constexpr void _Emplace_back(_Types&&... _Vals) {
        
        _Construct_in_place(*_Last, ::std:: forward<_Types>(_Vals)...);
        ++_Last;
    }

    constexpr _NoThrowFwdIt _Release() { 
        _First = _Last;
        return _Last;
    }
};

template <class _InIt, class _NoThrowFwdIt>
constexpr _NoThrowFwdIt _Uninitialized_move_unchecked(_InIt _First, const _InIt _Last, _NoThrowFwdIt _Dest) {
    
    if constexpr (_Iter_move_cat<_InIt, _NoThrowFwdIt>::_Bitcopy_constructible) {

        if (!::std:: is_constant_evaluated())
#line 1488 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
        {
            return _Copy_memmove(_First, _Last, _Dest);
        }
    }
    _Uninitialized_backout<_NoThrowFwdIt> _Backout{_Dest};
    for (; _First != _Last; ++_First) {
        _Backout._Emplace_back(::std:: move(*_First));
    }

    return _Backout._Release();
}


namespace ranges {
    template <class _It>
    concept _No_throw_input_iterator = input_iterator<_It> 
        && is_lvalue_reference_v<iter_reference_t<_It>> 
        && same_as<remove_cvref_t<iter_reference_t<_It>>, iter_value_t<_It>>;

    template <class _Se, class _It>
    concept _No_throw_sentinel_for = sentinel_for<_Se, _It>;

    template <class _It>
    concept _No_throw_forward_iterator = _No_throw_input_iterator<_It> 
        && forward_iterator<_It> 
        && _No_throw_sentinel_for<_It, _It>;

    template <class _Rng>
    concept _No_throw_input_range = range<_Rng> 
        && _No_throw_input_iterator<iterator_t<_Rng>> 
        && _No_throw_sentinel_for<sentinel_t<_Rng>, iterator_t<_Rng>>;

    template <class _Rng>
    concept _No_throw_forward_range = _No_throw_input_range<_Rng> 
        && _No_throw_forward_iterator<iterator_t<_Rng>>;

    template <class _InIt, class _OutIt>
    in_out_result<_InIt, _OutIt> _Copy_memcpy_count(_InIt _IFirst, _OutIt _OFirst, const size_t _Count) noexcept {
        const auto _IFirstPtr     = _To_address(_IFirst);
        const auto _OFirstPtr     = _To_address(_OFirst);
        const auto _IFirst_ch     = const_cast<char*>(reinterpret_cast<const volatile char*>(_IFirstPtr));
        const auto _OFirst_ch     = const_cast<char*>(reinterpret_cast<const volatile char*>(_OFirstPtr));
        const size_t _Count_bytes = _Count * sizeof(iter_value_t<_InIt>);
        :: memcpy(_OFirst_ch, _IFirst_ch, _Count_bytes);
        if constexpr (is_pointer_v<_InIt>) {
            _IFirst = reinterpret_cast<_InIt>(_IFirst_ch + _Count_bytes);
        } else {
            _IFirst += _Count;
        }

        if constexpr (is_pointer_v<_OutIt>) {
            _OFirst = reinterpret_cast<_OutIt>(_OFirst_ch + _Count_bytes);
        } else {
            _OFirst += _Count;
        }
        return {::std:: move(_IFirst), ::std:: move(_OFirst)};
    }

    template <class _InIt, class _OutIt, class _DistIt>
    in_out_result<_InIt, _OutIt> _Copy_memcpy_distance(
        _InIt _IFirst, _OutIt _OFirst, const _DistIt _DFirst, const _DistIt _DLast) noexcept {
        
        const auto _IFirstPtr   = _To_address(_IFirst);
        const auto _OFirstPtr   = _To_address(_OFirst);
        const auto _DFirstPtr   = _To_address(_DFirst);
        const auto _DLastPtr    = _To_address(_DLast);
        const auto _IFirst_ch   = const_cast<char*>(reinterpret_cast<const volatile char*>(_IFirstPtr));
        const auto _OFirst_ch   = const_cast<char*>(reinterpret_cast<const volatile char*>(_OFirstPtr));
        const auto _DFirst_ch   = const_cast<char*>(reinterpret_cast<const volatile char*>(_DFirstPtr));
        const auto _DLast_ch    = const_cast<char*>(reinterpret_cast<const volatile char*>(_DLastPtr));
        const auto _Count_bytes = static_cast<size_t>(_DLast_ch - _DFirst_ch);
        :: memcpy(_OFirst_ch, _IFirst_ch, _Count_bytes);
        if constexpr (is_pointer_v<_InIt>) {
            _IFirst = reinterpret_cast<_InIt>(_IFirst_ch + _Count_bytes);
        } else {
            _IFirst += _Count_bytes / sizeof(iter_value_t<_InIt>);
        }

        if constexpr (is_pointer_v<_OutIt>) {
            _OFirst = reinterpret_cast<_OutIt>(_OFirst_ch + _Count_bytes);
        } else {
            _OFirst += _Count_bytes / sizeof(iter_value_t<_OutIt>);
        }
        return {::std:: move(_IFirst), ::std:: move(_OFirst)};
    }

    template <class _InIt, class _OutIt>
    in_out_result<_InIt, _OutIt> _Copy_memcpy_common(
        _InIt _IFirst, _InIt _ILast, _OutIt _OFirst, _OutIt _OLast) noexcept {
        const auto _IFirstPtr   = _To_address(_IFirst);
        const auto _ILastPtr    = _To_address(_ILast);
        const auto _OFirstPtr   = _To_address(_OFirst);
        const auto _OLastPtr    = _To_address(_OLast);
        const auto _IFirst_ch   = const_cast<char*>(reinterpret_cast<const volatile char*>(_IFirstPtr));
        const auto _ILast_ch    = const_cast<const char*>(reinterpret_cast<const volatile char*>(_ILastPtr));
        const auto _OFirst_ch   = const_cast<char*>(reinterpret_cast<const volatile char*>(_OFirstPtr));
        const auto _OLast_ch    = const_cast<const char*>(reinterpret_cast<const volatile char*>(_OLastPtr));
        const auto _Count_bytes = static_cast<size_t>((::std:: min)(_ILast_ch - _IFirst_ch, _OLast_ch - _OFirst_ch));
        :: memcpy(_OFirst_ch, _IFirst_ch, _Count_bytes);
        if constexpr (is_pointer_v<_InIt>) {
            _IFirst = reinterpret_cast<_InIt>(_IFirst_ch + _Count_bytes);
        } else {
            _IFirst += _Count_bytes / sizeof(iter_value_t<_InIt>);
        }

        if constexpr (is_pointer_v<_OutIt>) {
            _OFirst = reinterpret_cast<_OutIt>(_OFirst_ch + _Count_bytes);
        } else {
            _OFirst += _Count_bytes / sizeof(iter_value_t<_OutIt>);
        }
        return {::std:: move(_IFirst), ::std:: move(_OFirst)};
    }

    template <class _In, class _Out>
    using uninitialized_move_result = in_out_result<_In, _Out>;

    
    template <input_iterator _It, sentinel_for<_It> _Se, _No_throw_forward_iterator _Out,
        _No_throw_sentinel_for<_Out> _OSe>
        requires (constructible_from<iter_value_t<_Out>, iter_rvalue_reference_t<_It>>)
    uninitialized_move_result<_It, _Out> _Uninitialized_move_unchecked(
        _It _IFirst, _Se _ILast, _Out _OFirst, _OSe _OLast) {
        
        constexpr bool _Is_sized1 = sized_sentinel_for<_Se, _It>;
        constexpr bool _Is_sized2 = sized_sentinel_for<_OSe, _Out>;
        if constexpr (_Iter_move_cat<_It, _Out>::_Bitcopy_constructible
                      && _Sized_or_unreachable_sentinel_for<_Se, _It> 
                      && _Sized_or_unreachable_sentinel_for<_OSe, _Out>) {
            if constexpr (_Is_sized1 && _Is_sized2) {
                return _Copy_memcpy_common(_IFirst, ::std::ranges:: next(_IFirst, ::std:: move(_ILast)), _OFirst,
                    ::std::ranges:: next(_OFirst, ::std:: move(_OLast)));
            } else if constexpr (_Is_sized1) {
                return _Copy_memcpy_distance(_IFirst, _OFirst, _IFirst, ::std::ranges:: next(_IFirst, ::std:: move(_ILast)));
            } else if constexpr (_Is_sized2) {
                return _Copy_memcpy_distance(_IFirst, _OFirst, _OFirst, ::std::ranges:: next(_OFirst, ::std:: move(_OLast)));
            } else {
                ;
            }
        } else {
            _Uninitialized_backout _Backout{::std:: move(_OFirst)};

            for (; _IFirst != _ILast && _Backout._Last != _OLast; ++_IFirst) {
                _Backout._Emplace_back(::std::ranges:: iter_move(_IFirst));
            }

            return {::std:: move(_IFirst), _Backout._Release()};
        }
    }
} 
#line 1638 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"

template <class _Alloc>
class [[nodiscard]] _Uninitialized_backout_al {
    
    using pointer = _Alloc_ptr_t<_Alloc>;

public:
    constexpr _Uninitialized_backout_al(pointer _Dest, _Alloc& _Al_) : _First(_Dest), _Last(_Dest), _Al(_Al_) {}

    _Uninitialized_backout_al(const _Uninitialized_backout_al&) = delete;
    _Uninitialized_backout_al& operator=(const _Uninitialized_backout_al&) = delete;

    constexpr ~_Uninitialized_backout_al() {
        _Destroy_range(_First, _Last, _Al);
    }

    template <class... _Types>
    constexpr void _Emplace_back(_Types&&... _Vals) { 
        allocator_traits<_Alloc>::construct(_Al, _Unfancy(_Last), ::std:: forward<_Types>(_Vals)...);
        ++_Last;
    }

    constexpr pointer _Release() { 
        _First = _Last;
        return _Last;
    }

private:
    pointer _First;
    pointer _Last;
    _Alloc& _Al;
};

template <class _InIt, class _Alloc>
constexpr _Alloc_ptr_t<_Alloc> _Uninitialized_copy(
    const _InIt _First, const _InIt _Last, _Alloc_ptr_t<_Alloc> _Dest, _Alloc& _Al) {
    
    
    using _Ptrval = typename _Alloc::value_type*;

    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);

    if constexpr (conjunction_v<bool_constant<_Iter_copy_cat<decltype(_UFirst), _Ptrval>::_Bitcopy_constructible>,
                      _Uses_default_construct<_Alloc, _Ptrval, decltype(*_UFirst)>>) {

        if (!::std:: is_constant_evaluated())
#line 1686 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
        {
            _Copy_memmove(_UFirst, _ULast, _Unfancy(_Dest));
            _Dest += _ULast - _UFirst;
            return _Dest;
        }
    }

    _Uninitialized_backout_al<_Alloc> _Backout{_Dest, _Al};
    for (; _UFirst != _ULast; ++_UFirst) {
        _Backout._Emplace_back(*_UFirst);
    }

    return _Backout._Release();
}

template <class _InIt, class _NoThrowFwdIt>
constexpr _NoThrowFwdIt _Uninitialized_copy_unchecked(_InIt _First, const _InIt _Last, _NoThrowFwdIt _Dest) {
    
    if constexpr (_Iter_copy_cat<_InIt, _NoThrowFwdIt>::_Bitcopy_constructible) {

        if (!::std:: is_constant_evaluated())
#line 1708 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
        {
            return _Copy_memmove(_First, _Last, _Dest);
        }
    }

    _Uninitialized_backout<_NoThrowFwdIt> _Backout{_Dest};
    for (; _First != _Last; ++_First) {
        _Backout._Emplace_back(*_First);
    }

    return _Backout._Release();
}

template <class _InIt, class _NoThrowFwdIt>
_NoThrowFwdIt uninitialized_copy(const _InIt _First, const _InIt _Last, _NoThrowFwdIt _Dest) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    auto _UDest       = _Get_unwrapped_n(_Dest, _Idl_distance<_InIt>(_UFirst, _ULast));
    _Seek_wrapped(_Dest, _Uninitialized_copy_unchecked(_UFirst, _ULast, _UDest));
    return _Dest;
}

template <class _InIt, class _Alloc>
constexpr _Alloc_ptr_t<_Alloc> _Uninitialized_move(
    const _InIt _First, const _InIt _Last, _Alloc_ptr_t<_Alloc> _Dest, _Alloc& _Al) {
    
    
    using _Ptrval     = typename _Alloc::value_type*;
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    if constexpr (conjunction_v<bool_constant<_Iter_move_cat<decltype(_UFirst), _Ptrval>::_Bitcopy_constructible>,
                      _Uses_default_construct<_Alloc, _Ptrval, decltype(::std:: move(*_UFirst))>>) {

        if (!::std:: is_constant_evaluated())
#line 1745 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
        {
            _Copy_memmove(_UFirst, _ULast, _Unfancy(_Dest));
            return _Dest + (_ULast - _UFirst);
        }
    }

    _Uninitialized_backout_al<_Alloc> _Backout{_Dest, _Al};
    for (; _UFirst != _ULast; ++_UFirst) {
        _Backout._Emplace_back(::std:: move(*_UFirst));
    }

    return _Backout._Release();
}

template <class _Alloc>
constexpr _Alloc_ptr_t<_Alloc> _Uninitialized_fill_n(
    _Alloc_ptr_t<_Alloc> _First, _Alloc_size_t<_Alloc> _Count, const typename _Alloc::value_type& _Val, _Alloc& _Al) {
    
    using _Ty = typename _Alloc::value_type;
    if constexpr (_Fill_memset_is_safe<_Ty*, _Ty> && _Uses_default_construct<_Alloc, _Ty*, _Ty>::value) {

        if (!::std:: is_constant_evaluated())
#line 1768 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
        {
            _Fill_memset(_Unfancy(_First), _Val, static_cast<size_t>(_Count));
            return _First + _Count;
        }
    } else if constexpr (_Fill_zero_memset_is_safe<_Ty*, _Ty> && _Uses_default_construct<_Alloc, _Ty*, _Ty>::value) {

        if (!::std:: is_constant_evaluated())
#line 1776 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
        {
            if (_Is_all_bits_zero(_Val)) {
                _Fill_zero_memset(_Unfancy(_First), static_cast<size_t>(_Count));
                return _First + _Count;
            }
        }
    }

    _Uninitialized_backout_al<_Alloc> _Backout{_First, _Al};
    for (; 0 < _Count; --_Count) {
        _Backout._Emplace_back(_Val);
    }

    return _Backout._Release();
}

template <class _NoThrowFwdIt, class _Tval>
void uninitialized_fill(const _NoThrowFwdIt _First, const _NoThrowFwdIt _Last, const _Tval& _Val) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    if constexpr (_Fill_memset_is_safe<_Unwrapped_t<const _NoThrowFwdIt&>, _Tval>) {
        _Fill_memset(_UFirst, _Val, static_cast<size_t>(_ULast - _UFirst));
    } else {
        if constexpr (_Fill_zero_memset_is_safe<_Unwrapped_t<const _NoThrowFwdIt&>, _Tval>) {
            if (_Is_all_bits_zero(_Val)) {
                _Fill_zero_memset(_UFirst, static_cast<size_t>(_ULast - _UFirst));
                return;
            }
        }

        _Uninitialized_backout<_Unwrapped_t<const _NoThrowFwdIt&>> _Backout{_UFirst};
        while (_Backout._Last != _ULast) {
            _Backout._Emplace_back(_Val);
        }

        _Backout._Release();
    }
}

template <class _NoThrowFwdIt>
inline constexpr bool _Use_memset_value_construct_v =
    conjunction_v<bool_constant<_Iterator_is_contiguous<_NoThrowFwdIt>>, is_scalar<_Iter_value_t<_NoThrowFwdIt>>,
        negation<is_volatile<remove_reference_t<_Iter_ref_t<_NoThrowFwdIt>>>>,
        negation<is_member_pointer<_Iter_value_t<_NoThrowFwdIt>>>>;

template <class _Ptr>
_Ptr _Zero_range(const _Ptr _First, const _Ptr _Last) { 
    char* const _First_ch = reinterpret_cast<char*>(_To_address(_First));
    char* const _Last_ch  = reinterpret_cast<char*>(_To_address(_Last));
    :: memset(_First_ch, 0, static_cast<size_t>(_Last_ch - _First_ch));
    return _Last;
}

template <class _Alloc>
constexpr _Alloc_ptr_t<_Alloc> _Uninitialized_value_construct_n(
    _Alloc_ptr_t<_Alloc> _First, _Alloc_size_t<_Alloc> _Count, _Alloc& _Al) {
    
    using _Ptrty = typename _Alloc::value_type*;
    if constexpr (_Use_memset_value_construct_v<_Ptrty> && _Uses_default_construct<_Alloc, _Ptrty>::value) {

        if (!::std:: is_constant_evaluated())
#line 1840 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
        {
            auto _PFirst = _Unfancy(_First);
            _Zero_range(_PFirst, _PFirst + _Count);
            return _First + _Count;
        }
    }

    _Uninitialized_backout_al<_Alloc> _Backout{_First, _Al};
    for (; 0 < _Count; --_Count) {
        _Backout._Emplace_back();
    }

    return _Backout._Release();
}

template <class _NoThrowFwdIt, class _Diff>
_NoThrowFwdIt _Uninitialized_value_construct_n_unchecked1(_NoThrowFwdIt _UFirst, _Diff _Count) {
    
    ;
    if constexpr (_Use_memset_value_construct_v<_NoThrowFwdIt>) {
        return _Zero_range(_UFirst, _UFirst + _Count);
    } else {
        _Uninitialized_backout<_NoThrowFwdIt> _Backout{_UFirst};
        for (; 0 < _Count; --_Count) {
            _Backout._Emplace_back();
        }

        return _Backout._Release();
    }
}


#line 1882 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"


template <class _Key, class... _Args>
struct _In_place_key_extract_set {
    
    static constexpr bool _Extractable = false;
};

template <class _Key>
struct _In_place_key_extract_set<_Key, _Key> {
    
    static constexpr bool _Extractable = true;
    static const _Key& _Extract(const _Key& _Val) noexcept {
        return _Val;
    }
};


template <class _Key, class... _Args>
struct _In_place_key_extract_map {
    
    static constexpr bool _Extractable = false;
};

template <class _Key, class _Second>
struct _In_place_key_extract_map<_Key, _Key, _Second> {
    
    static constexpr bool _Extractable = true;
    static const _Key& _Extract(const _Key& _Val, const _Second&) noexcept {
        return _Val;
    }
};

template <class _Key, class _First, class _Second>
struct _In_place_key_extract_map<_Key, pair<_First, _Second>> {
    
    static constexpr bool _Extractable = is_same_v<_Key, _Remove_cvref_t<_First>>;
    static const _Key& _Extract(const pair<_First, _Second>& _Val) {
        return _Val.first;
    }
};

#pragma warning(push)
#pragma warning(disable : 4624) 
template <class _Ty>
struct _Wrap {
    _Ty _Value; 
};
#pragma warning(pop)

template <class _Alloc>
struct _Alloc_temporary2 {
    using value_type = typename _Alloc::value_type;
    using _Traits    = allocator_traits<_Alloc>;

    _Alloc& _Al;


    union {
        value_type _Value;
    };

    [[nodiscard]] constexpr value_type& _Get_value() noexcept {
        return _Value;
    }

    [[nodiscard]] constexpr const value_type& _Get_value() const noexcept {
        return _Value;
    }
#line 1964 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"

    template <class... _Args>
    constexpr explicit _Alloc_temporary2(_Alloc& _Al_, _Args&&... _Vals) noexcept(
        noexcept(_Traits::construct(_Al_, ::std:: addressof(_Get_value()), ::std:: forward<_Args>(_Vals)...)))
        : _Al(_Al_) {
        _Traits::construct(_Al, ::std:: addressof(_Get_value()), ::std:: forward<_Args>(_Vals)...);
    }

    _Alloc_temporary2(const _Alloc_temporary2&) = delete;
    _Alloc_temporary2& operator=(const _Alloc_temporary2&) = delete;

    constexpr ~_Alloc_temporary2() {
        _Traits::destroy(_Al, ::std:: addressof(_Get_value()));
    }
};

template <class _Alloc>
[[nodiscard]] constexpr bool _Allocators_equal(const _Alloc& _Lhs, const _Alloc& _Rhs) noexcept {
    if constexpr (allocator_traits<_Alloc>::is_always_equal::value) {
        return true;
    } else {
        return _Lhs == _Rhs;
    }
}

template <class _FwdIt, class _Ty>
[[nodiscard]] constexpr _FwdIt remove(_FwdIt _First, const _FwdIt _Last, const _Ty& _Val) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    _UFirst           = _Find_unchecked(_UFirst, _ULast, _Val);
    auto _UNext       = _UFirst;
    if (_UFirst != _ULast) {
        while (++_UFirst != _ULast) {
            if (!(*_UFirst == _Val)) {
                *_UNext = ::std:: move(*_UFirst);
                ++_UNext;
            }
        }
    }

    _Seek_wrapped(_First, _UNext);
    return _First;
}

template <class _FwdIt, class _Pr>
[[nodiscard]] constexpr _FwdIt remove_if(_FwdIt _First, const _FwdIt _Last, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    _UFirst           = ::std:: find_if(_UFirst, _ULast, _Pass_fn(_Pred));
    auto _UNext       = _UFirst;
    if (_UFirst != _ULast) {
        while (++_UFirst != _ULast) {
            if (!_Pred(*_UFirst)) {
                *_UNext = ::std:: move(*_UFirst);
                ++_UNext;
            }
        }
    }

    _Seek_wrapped(_First, _UNext);
    return _First;
}

template <class _Container, class _Uty>
constexpr typename _Container::size_type _Erase_remove(_Container& _Cont, const _Uty& _Val) {
    
    auto _First          = _Cont.begin();
    const auto _Last     = _Cont.end();
    const auto _Old_size = _Cont.size();
    _Seek_wrapped(_First, ::std:: remove(_Get_unwrapped(_First), _Get_unwrapped(_Last), _Val));
    _Cont.erase(_First, _Last);
    return _Old_size - _Cont.size();
}

template <class _Container, class _Pr>
constexpr typename _Container::size_type _Erase_remove_if(_Container& _Cont, _Pr _Pred) {
    
    auto _First          = _Cont.begin();
    const auto _Last     = _Cont.end();
    const auto _Old_size = _Cont.size();
    _Seek_wrapped(_First, ::std:: remove_if(_Get_unwrapped(_First), _Get_unwrapped(_Last), _Pred));
    _Cont.erase(_First, _Last);
    return _Old_size - _Cont.size();
}

template <class _Container, class _Pr>
typename _Container::size_type _Erase_nodes_if(_Container& _Cont, _Pr _Pred) {
    
    auto _First          = _Cont.begin();
    const auto _Last     = _Cont.end();
    const auto _Old_size = _Cont.size();
    while (_First != _Last) {
        if (_Pred(*_First)) {
            _First = _Cont.erase(_First);
        } else {
            ++_First;
        }
    }
    return _Old_size - _Cont.size();
}


template <class _Ty, class _Alloc, class... _Types, enable_if_t<!_Is_specialization_v<_Ty, pair>, int> = 0>
[[nodiscard]] constexpr auto uses_allocator_construction_args(const _Alloc& _Al, _Types&&... _Args) noexcept {
    if constexpr (!uses_allocator_v<_Ty, _Alloc>) {
        static_assert(is_constructible_v<_Ty, _Types...>,
            "If uses_allocator_v<T, Alloc> does not hold, T must be constructible from Types...");
        (void) _Al;
        return ::std:: forward_as_tuple(::std:: forward<_Types>(_Args)...);
    } else if constexpr (is_constructible_v<_Ty, allocator_arg_t, const _Alloc&, _Types...>) {
        using _ReturnType = tuple<allocator_arg_t, const _Alloc&, _Types&&...>;
        return _ReturnType{allocator_arg, _Al, ::std:: forward<_Types>(_Args)...};
    } else if constexpr (is_constructible_v<_Ty, _Types..., const _Alloc&>) {
        return ::std:: forward_as_tuple(::std:: forward<_Types>(_Args)..., _Al);
    } else {
        static_assert(_Always_false<_Ty>,
            "T must be constructible from either (allocator_arg_t, const Alloc&, Types...) "
            "or (Types..., const Alloc&) if uses_allocator_v<T, Alloc> is true");
    }
}

template <class _Ty, class _Alloc, enable_if_t<_Is_specialization_v<_Ty, pair>, int> = 0>
[[nodiscard]] constexpr auto uses_allocator_construction_args(const _Alloc& _Al) noexcept;

template <class _Ty, class _Alloc, class _Uty1, class _Uty2, enable_if_t<_Is_specialization_v<_Ty, pair>, int> = 0>
[[nodiscard]] constexpr auto uses_allocator_construction_args(const _Alloc& _Al, _Uty1&& _Val1, _Uty2&& _Val2) noexcept;

template <class _Ty, class _Alloc, class _Uty1, class _Uty2, enable_if_t<_Is_specialization_v<_Ty, pair>, int> = 0>
[[nodiscard]] constexpr auto uses_allocator_construction_args(const _Alloc& _Al, const pair<_Uty1, _Uty2>& _Pair) noexcept;

template <class _Ty, class _Alloc, class _Uty1, class _Uty2, enable_if_t<_Is_specialization_v<_Ty, pair>, int> = 0>
[[nodiscard]] constexpr auto uses_allocator_construction_args(const _Alloc& _Al, pair<_Uty1, _Uty2>&& _Pair) noexcept;

template <class _Ty, class _Alloc, class _Tuple1, class _Tuple2, enable_if_t<_Is_specialization_v<_Ty, pair>, int> = 0>
[[nodiscard]] constexpr auto uses_allocator_construction_args(
    const _Alloc& _Al, piecewise_construct_t, _Tuple1&& _Tup1, _Tuple2&& _Tup2) noexcept {
    return ::std:: make_tuple(piecewise_construct,
        ::std:: apply(
            [&_Al](auto&&... _Tuple_args) {
                return ::std:: uses_allocator_construction_args<typename _Ty::first_type>(
                    _Al, ::std:: forward<decltype(_Tuple_args)>(_Tuple_args)...);
            },
            ::std:: forward<_Tuple1>(_Tup1)),
        ::std:: apply(
            [&_Al](auto&&... _Tuple_args) {
                return ::std:: uses_allocator_construction_args<typename _Ty::second_type>(
                    _Al, ::std:: forward<decltype(_Tuple_args)>(_Tuple_args)...);
            },
            ::std:: forward<_Tuple2>(_Tup2)));
}

template <class _Ty, class _Alloc, enable_if_t<_Is_specialization_v<_Ty, pair>, int>>
[[nodiscard]] constexpr auto uses_allocator_construction_args(const _Alloc& _Al) noexcept {
    
    
    return ::std:: make_tuple(piecewise_construct, ::std:: uses_allocator_construction_args<typename _Ty::first_type>(_Al),
        ::std:: uses_allocator_construction_args<typename _Ty::second_type>(_Al));
}

template <class _Ty, class _Alloc, class _Uty1, class _Uty2, enable_if_t<_Is_specialization_v<_Ty, pair>, int>>
[[nodiscard]] constexpr auto uses_allocator_construction_args(const _Alloc& _Al, _Uty1&& _Val1, _Uty2&& _Val2) noexcept {
    
    
    return ::std:: make_tuple(piecewise_construct,
        ::std:: uses_allocator_construction_args<typename _Ty::first_type>(_Al, ::std:: forward<_Uty1>(_Val1)),
        ::std:: uses_allocator_construction_args<typename _Ty::second_type>(_Al, ::std:: forward<_Uty2>(_Val2)));
}

template <class _Ty, class _Alloc, class _Uty1, class _Uty2, enable_if_t<_Is_specialization_v<_Ty, pair>, int>>
[[nodiscard]] constexpr auto uses_allocator_construction_args(
    const _Alloc& _Al, const pair<_Uty1, _Uty2>& _Pair) noexcept {
    
    
    return ::std:: make_tuple(piecewise_construct,
        ::std:: uses_allocator_construction_args<typename _Ty::first_type>(_Al, _Pair.first),
        ::std:: uses_allocator_construction_args<typename _Ty::second_type>(_Al, _Pair.second));
}

template <class _Ty, class _Alloc, class _Uty1, class _Uty2, enable_if_t<_Is_specialization_v<_Ty, pair>, int>>
[[nodiscard]] constexpr auto uses_allocator_construction_args(const _Alloc& _Al, pair<_Uty1, _Uty2>&& _Pair) noexcept {
    
    
    return ::std:: make_tuple(piecewise_construct,
        ::std:: uses_allocator_construction_args<typename _Ty::first_type>(_Al, ::std:: get<0>(::std:: move(_Pair))),
        ::std:: uses_allocator_construction_args<typename _Ty::second_type>(_Al, ::std:: get<1>(::std:: move(_Pair))));
}

template <class _Ty, class _Alloc, class... _Types>
[[nodiscard]] constexpr _Ty make_obj_using_allocator(const _Alloc& _Al, _Types&&... _Args) {
    return ::std:: make_from_tuple<_Ty>(::std:: uses_allocator_construction_args<_Ty>(_Al, ::std:: forward<_Types>(_Args)...));
}

template <class _Ty, class _Alloc, class... _Types>
constexpr _Ty* uninitialized_construct_using_allocator(_Ty* _Ptr, const _Alloc& _Al, _Types&&... _Args) {
    return ::std:: apply(
        [&](auto&&... _Construct_args) {
            return ::std:: construct_at(_Ptr, ::std:: forward<decltype(_Construct_args)>(_Construct_args)...);
        },
        ::std:: uses_allocator_construction_args<_Ty>(_Al, ::std:: forward<_Types>(_Args)...));
}
#line 2172 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
}


#pragma warning(pop)
#pragma pack(pop)
#line 2179 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
#line 2180 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmemory"
#line 20 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\any"


#line 24 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\any"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {

class bad_any_cast : public bad_cast { 
public:
    [[nodiscard]] const char*  what() const noexcept override {
        return "Bad any_cast";
    }
};

[[noreturn]] inline void _Throw_bad_any_cast() {
    throw bad_any_cast{};
}

inline constexpr size_t _Any_trivial_space_size = (_Small_object_num_ptrs - 1) * sizeof(void*);

template <class _Ty>
inline constexpr bool _Any_is_trivial = alignof(_Ty) <= alignof(max_align_t)
                                     && is_trivially_copyable_v<_Ty> && sizeof(_Ty) <= _Any_trivial_space_size;

inline constexpr size_t _Any_small_space_size = (_Small_object_num_ptrs - 2) * sizeof(void*);

template <class _Ty>
inline constexpr bool _Any_is_small = alignof(_Ty) <= alignof(max_align_t)
                                   && is_nothrow_move_constructible_v<_Ty> && sizeof(_Ty) <= _Any_small_space_size;

enum class _Any_representation : uintptr_t { _Trivial, _Big, _Small };

struct _Any_big_RTTI { 
    using _Destroy_fn = void __cdecl(void*) noexcept;
    using _Copy_fn    = void* __cdecl(const void*);

    template <class _Ty>
    static void __cdecl _Destroy_impl(void* const _Target) noexcept {
        ::delete static_cast<_Ty*>(_Target);
    }

    template <class _Ty>
    [[nodiscard]] static void* __cdecl _Copy_impl(const void* const _Source) {
        return ::new _Ty(*static_cast<const _Ty*>(_Source));
    }

    _Destroy_fn* _Destroy;
    _Copy_fn* _Copy;
};

struct _Any_small_RTTI { 
    using _Destroy_fn = void __cdecl(void*) noexcept;
    using _Copy_fn    = void __cdecl(void*, const void*);
    using _Move_fn    = void __cdecl(void*, void*) noexcept;

    template <class _Ty>
    static void __cdecl _Destroy_impl(void* const _Target) noexcept {
        _Destroy_in_place(*static_cast<_Ty*>(_Target));
    }

    template <class _Ty>
    static void __cdecl _Copy_impl(void* const _Target, const void* const _Source) {
        _Construct_in_place(*static_cast<_Ty*>(_Target), *static_cast<const _Ty*>(_Source));
    }

    template <class _Ty>
    static void __cdecl _Move_impl(void* const _Target, void* const _Source) noexcept {
        _Construct_in_place(*static_cast<_Ty*>(_Target), ::std:: move(*static_cast<_Ty*>(_Source)));
    }

    _Destroy_fn* _Destroy;
    _Copy_fn* _Copy;
    _Move_fn* _Move;
};

template <class _Ty>
inline constexpr _Any_big_RTTI _Any_big_RTTI_obj = {
    &_Any_big_RTTI::_Destroy_impl<_Ty>, &_Any_big_RTTI::_Copy_impl<_Ty>};

template <class _Ty>
inline constexpr _Any_small_RTTI _Any_small_RTTI_obj = {
    &_Any_small_RTTI::_Destroy_impl<_Ty>, &_Any_small_RTTI::_Copy_impl<_Ty>, &_Any_small_RTTI::_Move_impl<_Ty>};

class any { 
public:
    
    constexpr any() noexcept {}

    any(const any& _That) {
        _Storage._TypeData = _That._Storage._TypeData;
        switch (_Rep()) {
        case _Any_representation::_Small:
            _Storage._SmallStorage._RTTI = _That._Storage._SmallStorage._RTTI;
            _Storage._SmallStorage._RTTI->_Copy(&_Storage._SmallStorage._Data, &_That._Storage._SmallStorage._Data);
            break;
        case _Any_representation::_Big:
            _Storage._BigStorage._RTTI = _That._Storage._BigStorage._RTTI;
            _Storage._BigStorage._Ptr  = _Storage._BigStorage._RTTI->_Copy(_That._Storage._BigStorage._Ptr);
            break;
        case _Any_representation::_Trivial:
        default:
            :: memcpy(_Storage._TrivialData, _That._Storage._TrivialData, sizeof(_Storage._TrivialData));
            break;
        }
    }

    any(any&& _That) noexcept {
        _Move_from(_That);
    }

    template <class _ValueType, enable_if_t<conjunction_v<negation<is_same<decay_t<_ValueType>, any>>,
                                                negation<_Is_specialization<decay_t<_ValueType>, in_place_type_t>>,
                                                is_copy_constructible<decay_t<_ValueType>>>,
                                    int> = 0>
    any(_ValueType&& _Value) { 
        _Emplace<decay_t<_ValueType>>(::std:: forward<_ValueType>(_Value));
    }

    template <class _ValueType, class... _Types,
        enable_if_t<
            conjunction_v<is_constructible<decay_t<_ValueType>, _Types...>, is_copy_constructible<decay_t<_ValueType>>>,
            int> = 0>
    explicit any(in_place_type_t<_ValueType>, _Types&&... _Args) {
        
        _Emplace<decay_t<_ValueType>>(::std:: forward<_Types>(_Args)...);
    }

    template <class _ValueType, class _Elem, class... _Types,
        enable_if_t<conjunction_v<is_constructible<decay_t<_ValueType>, initializer_list<_Elem>&, _Types...>,
                        is_copy_constructible<decay_t<_ValueType>>>,
            int> = 0>
    explicit any(in_place_type_t<_ValueType>, initializer_list<_Elem> _Ilist, _Types&&... _Args) {
        
        _Emplace<decay_t<_ValueType>>(_Ilist, ::std:: forward<_Types>(_Args)...);
    }

    ~any() noexcept {
        reset();
    }

    
    any& operator=(const any& _That) {
        *this = any{_That};
        return *this;
    }

    any& operator=(any&& _That) noexcept {
        reset();
        _Move_from(_That);
        return *this;
    }

    template <class _ValueType, enable_if_t<conjunction_v<negation<is_same<decay_t<_ValueType>, any>>,
                                                is_copy_constructible<decay_t<_ValueType>>>,
                                    int> = 0>
    any& operator=(_ValueType&& _Value) {
        
        *this = any{::std:: forward<_ValueType>(_Value)};
        return *this;
    }

    
    template <class _ValueType, class... _Types,
        enable_if_t<
            conjunction_v<is_constructible<decay_t<_ValueType>, _Types...>, is_copy_constructible<decay_t<_ValueType>>>,
            int> = 0>
    decay_t<_ValueType>& emplace(_Types&&... _Args) {
        
        reset();
        return _Emplace<decay_t<_ValueType>>(::std:: forward<_Types>(_Args)...);
    }
    template <class _ValueType, class _Elem, class... _Types,
        enable_if_t<conjunction_v<is_constructible<decay_t<_ValueType>, initializer_list<_Elem>&, _Types...>,
                        is_copy_constructible<decay_t<_ValueType>>>,
            int> = 0>
    decay_t<_ValueType>& emplace(initializer_list<_Elem> _Ilist, _Types&&... _Args) {
        
        reset();
        return _Emplace<decay_t<_ValueType>>(_Ilist, ::std:: forward<_Types>(_Args)...);
    }

    void reset() noexcept { 
        switch (_Rep()) {
        case _Any_representation::_Small:
            _Storage._SmallStorage._RTTI->_Destroy(&_Storage._SmallStorage._Data);
            break;
        case _Any_representation::_Big:
            _Storage._BigStorage._RTTI->_Destroy(_Storage._BigStorage._Ptr);
            break;
        case _Any_representation::_Trivial:
        default:
            break;
        }
        _Storage._TypeData = 0;
    }

    void swap(any& _That) noexcept {
        _That = ::std:: exchange(*this, ::std:: move(_That));
    }

    
    [[nodiscard]] bool has_value() const noexcept {
        return _Storage._TypeData != 0;
    }

    [[nodiscard]] const type_info& type() const noexcept {
        
        const type_info* const _Info = _TypeInfo();
        if (_Info) {
            return *_Info;
        }

        return typeid(void);
    }

    template <class _Decayed>
    [[nodiscard]] const _Decayed* _Cast() const noexcept {
        
        const type_info* const _Info = _TypeInfo();
        if (!_Info || *_Info != typeid(_Decayed)) {
            return nullptr;
        }

        if constexpr (_Any_is_trivial<_Decayed>) {
            
            return reinterpret_cast<const _Decayed*>(&_Storage._TrivialData);
        } else if constexpr (_Any_is_small<_Decayed>) {
            
            return reinterpret_cast<const _Decayed*>(&_Storage._SmallStorage._Data);
        } else {
            
            return static_cast<const _Decayed*>(_Storage._BigStorage._Ptr);
        }
    }

    template <class _Decayed>
    [[nodiscard]] _Decayed* _Cast() noexcept { 
        return const_cast<_Decayed*>(static_cast<const any*>(this)->_Cast<_Decayed>());
    }

private:
    static constexpr uintptr_t _Rep_mask = 3;

    [[nodiscard]] _Any_representation _Rep() const noexcept { 
        return static_cast<_Any_representation>(_Storage._TypeData & _Rep_mask);
    }
    [[nodiscard]] const type_info* _TypeInfo() const noexcept { 
        return reinterpret_cast<const type_info*>(_Storage._TypeData & ~_Rep_mask);
    }

    void _Move_from(any& _That) noexcept {
        _Storage._TypeData = _That._Storage._TypeData;
        switch (_Rep()) {
        case _Any_representation::_Small:
            _Storage._SmallStorage._RTTI = _That._Storage._SmallStorage._RTTI;
            _Storage._SmallStorage._RTTI->_Move(&_Storage._SmallStorage._Data, &_That._Storage._SmallStorage._Data);
            break;
        case _Any_representation::_Big:
            _Storage._BigStorage._RTTI = _That._Storage._BigStorage._RTTI;
            _Storage._BigStorage._Ptr  = _That._Storage._BigStorage._Ptr;
            _That._Storage._TypeData   = 0;
            break;
        case _Any_representation::_Trivial:
        default:
            :: memcpy(_Storage._TrivialData, _That._Storage._TrivialData, sizeof(_Storage._TrivialData));
            break;
        }
    }

    template <class _Decayed, class... _Types>
    _Decayed& _Emplace(_Types&&... _Args) { 
        if constexpr (_Any_is_trivial<_Decayed>) {
            
            auto& _Obj = reinterpret_cast<_Decayed&>(_Storage._TrivialData);
            _Construct_in_place(_Obj, ::std:: forward<_Types>(_Args)...);
            _Storage._TypeData =
                reinterpret_cast<uintptr_t>(&typeid(_Decayed)) | static_cast<uintptr_t>(_Any_representation::_Trivial);
            return _Obj;
        } else if constexpr (_Any_is_small<_Decayed>) {
            
            auto& _Obj = reinterpret_cast<_Decayed&>(_Storage._SmallStorage._Data);
            _Construct_in_place(_Obj, ::std:: forward<_Types>(_Args)...);
            _Storage._SmallStorage._RTTI = &_Any_small_RTTI_obj<_Decayed>;
            _Storage._TypeData =
                reinterpret_cast<uintptr_t>(&typeid(_Decayed)) | static_cast<uintptr_t>(_Any_representation::_Small);
            return _Obj;
        } else {
            
            _Decayed* const _Ptr       = ::new _Decayed(::std:: forward<_Types>(_Args)...);
            _Storage._BigStorage._Ptr  = _Ptr;
            _Storage._BigStorage._RTTI = &_Any_big_RTTI_obj<_Decayed>;
            _Storage._TypeData =
                reinterpret_cast<uintptr_t>(&typeid(_Decayed)) | static_cast<uintptr_t>(_Any_representation::_Big);
            return *_Ptr;
        }
    }

    struct _Small_storage_t {
        unsigned char _Data[_Any_small_space_size];
        const _Any_small_RTTI* _RTTI;
    };
    static_assert(sizeof(_Small_storage_t) == _Any_trivial_space_size);

    struct _Big_storage_t {
        
        unsigned char _Padding[_Any_small_space_size - sizeof(void*)];
        void* _Ptr;
        const _Any_big_RTTI* _RTTI;
    };
    static_assert(sizeof(_Big_storage_t) == _Any_trivial_space_size);

    struct _Storage_t {
        union {
            unsigned char _TrivialData[_Any_trivial_space_size];
            _Small_storage_t _SmallStorage;
            _Big_storage_t _BigStorage;
        };
        uintptr_t _TypeData;
    };
    static_assert(sizeof(_Storage_t) == _Any_trivial_space_size + sizeof(void*));
    static_assert(is_standard_layout_v<_Storage_t>);

    union {
        _Storage_t _Storage{};
        max_align_t _Dummy;
    };
};


inline void swap(any& _Left, any& _Right) noexcept {
    _Left.swap(_Right);
}

template <class _ValueType, class... _Types>
[[nodiscard]] any make_any(_Types&&... _Args) { 
    return any{in_place_type<_ValueType>, ::std:: forward<_Types>(_Args)...};
}
template <class _ValueType, class _Elem, class... _Types>
[[nodiscard]] any make_any(initializer_list<_Elem> _Ilist, _Types&&... _Args) {
    
    return any{in_place_type<_ValueType>, _Ilist, ::std:: forward<_Types>(_Args)...};
}

template <class _ValueType>
[[nodiscard]] const _ValueType* any_cast(const any* const _Any) noexcept {
    
    static_assert(!is_void_v<_ValueType>, "std::any cannot contain void.");

    if constexpr (is_function_v<_ValueType> || is_array_v<_ValueType>) {
        return nullptr;
    } else {
        if (!_Any) {
            return nullptr;
        }

        return _Any->_Cast<_Remove_cvref_t<_ValueType>>();
    }
}
template <class _ValueType>
[[nodiscard]] _ValueType* any_cast(any* const _Any) noexcept {
    
    static_assert(!is_void_v<_ValueType>, "std::any cannot contain void.");

    if constexpr (is_function_v<_ValueType> || is_array_v<_ValueType>) {
        return nullptr;
    } else {
        if (!_Any) {
            return nullptr;
        }

        return _Any->_Cast<_Remove_cvref_t<_ValueType>>();
    }
}

template <class _Ty>
[[nodiscard]] remove_cv_t<_Ty> any_cast(const any& _Any) {
    static_assert(is_constructible_v<remove_cv_t<_Ty>, const _Remove_cvref_t<_Ty>&>,
        "any_cast<T>(const any&) requires remove_cv_t<T> to be constructible from "
        "const remove_cv_t<remove_reference_t<T>>&");

    const auto _Ptr = ::std:: any_cast<_Remove_cvref_t<_Ty>>(&_Any);
    if (!_Ptr) {
        _Throw_bad_any_cast();
    }

    return static_cast<remove_cv_t<_Ty>>(*_Ptr);
}
template <class _Ty>
[[nodiscard]] remove_cv_t<_Ty> any_cast(any& _Any) {
    static_assert(is_constructible_v<remove_cv_t<_Ty>, _Remove_cvref_t<_Ty>&>,
        "any_cast<T>(any&) requires remove_cv_t<T> to be constructible from remove_cv_t<remove_reference_t<T>>&");

    const auto _Ptr = ::std:: any_cast<_Remove_cvref_t<_Ty>>(&_Any);
    if (!_Ptr) {
        _Throw_bad_any_cast();
    }

    return static_cast<remove_cv_t<_Ty>>(*_Ptr);
}
template <class _Ty>
[[nodiscard]] remove_cv_t<_Ty> any_cast(any&& _Any) {
    static_assert(is_constructible_v<remove_cv_t<_Ty>, _Remove_cvref_t<_Ty>>,
        "any_cast<T>(any&&) requires remove_cv_t<T> to be constructible from remove_cv_t<remove_reference_t<T>>");

    const auto _Ptr = ::std:: any_cast<_Remove_cvref_t<_Ty>>(&_Any);
    if (!_Ptr) {
        _Throw_bad_any_cast();
    }

    return static_cast<remove_cv_t<_Ty>>(::std:: move(*_Ptr));
}

}


#pragma warning(pop)
#pragma pack(pop)
#line 446 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\any"

#line 448 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\any"
#line 449 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\any"
#line 13 "all-std.cxx"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\bitset"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iosfwd"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {


#line 45 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iosfwd"


using streamoff  = long long;
using streamsize = long long;

template <class _Statetype>
class fpos { 
public:
     fpos(streamoff _Off = 0) : _Myoff(_Off), _Fpos(0), _Mystate() {}

    fpos(_Statetype _State, fpos_t _Fileposition) : _Myoff(_Fileposition), _Fpos(0), _Mystate(_State) {}

    [[nodiscard]] _Statetype state() const {
        return _Mystate;
    }

    void state(_Statetype _State) {
        _Mystate = _State;
    }

    operator streamoff() const {
        
        
        return _Myoff + _Fpos;
    }


    [[deprecated("warning STL4019: " "The member std::fpos::seekpos() is non-Standard, and is preserved only for compatibility with " "workarounds for old versions of Visual C++. It will be removed in a future release, and in this " "release always returns 0. Please use standards-conforming mechanisms to manipulate fpos, such as " "conversions to and from streamoff, or an integral type, instead. If you are receiving this message " "while compiling Boost.IOStreams, a fix has been submitted upstream to make Boost use " "standards-conforming mechanisms, as it does for other compilers. You can define " "_SILENCE_FPOS_SEEKPOS_DEPRECATION_WARNING to acknowledge that you have received this warning, " "or define _REMOVE_FPOS_SEEKPOS to remove std::fpos::seekpos entirely.")]] fpos_t seekpos() const noexcept {
        return {};
    }
#line 76 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iosfwd"

    [[nodiscard]] streamoff operator-(const fpos& _Right) const {
        return static_cast<streamoff>(*this) - static_cast<streamoff>(_Right);
    }

    fpos& operator+=(streamoff _Off) { 
        _Myoff += _Off;
        return *this;
    }

    fpos& operator-=(streamoff _Off) { 
        _Myoff -= _Off;
        return *this;
    }

    [[nodiscard]] fpos operator+(streamoff _Off) const {
        fpos _Tmp = *this;
        _Tmp += _Off;
        return _Tmp;
    }

    [[nodiscard]] fpos operator-(streamoff _Off) const {
        fpos _Tmp = *this;
        _Tmp -= _Off;
        return _Tmp;
    }

    [[nodiscard]] bool operator==(const fpos& _Right) const {
        return static_cast<streamoff>(*this) == static_cast<streamoff>(_Right);
    }

    template <class _Int, enable_if_t<is_integral_v<_Int>, int> = 0>
    [[nodiscard]] friend bool operator==(const fpos& _Left, const _Int _Right) {
        return static_cast<streamoff>(_Left) == _Right;
    }

    template <class _Int, enable_if_t<is_integral_v<_Int>, int> = 0>
    [[nodiscard]] friend bool operator==(const _Int _Left, const fpos& _Right) {
        return _Left == static_cast<streamoff>(_Right);
    }

    [[nodiscard]] bool operator!=(const fpos& _Right) const {
        return static_cast<streamoff>(*this) != static_cast<streamoff>(_Right);
    }

    template <class _Int, enable_if_t<is_integral_v<_Int>, int> = 0>
    [[nodiscard]] friend bool operator!=(const fpos& _Left, const _Int _Right) {
        return static_cast<streamoff>(_Left) != _Right;
    }

    template <class _Int, enable_if_t<is_integral_v<_Int>, int> = 0>
    [[nodiscard]] friend bool operator!=(const _Int _Left, const fpos& _Right) {
        return _Left != static_cast<streamoff>(_Right);
    }

private:
    streamoff _Myoff; 
    fpos_t _Fpos; 
    _Statetype _Mystate; 
};

using streampos  = fpos<_Mbstatet>;
using wstreampos = streampos;

using u8streampos = streampos;
#line 142 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iosfwd"
using u16streampos = streampos;
using u32streampos = streampos;

class locale;
template <class _Facet>
const _Facet& __cdecl use_facet(const locale&);

template <class _Elem>
struct char_traits;
template <>
struct char_traits<char>;

template <>
struct char_traits<char8_t>;
#line 157 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iosfwd"
template <>
struct char_traits<char16_t>;
template <>
struct char_traits<char32_t>;
template <>
struct char_traits<wchar_t>;

template <>
struct char_traits<unsigned short>;
#line 167 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iosfwd"

template <class _Ty>
class allocator;
class ios_base;
template <class _Elem, class _Traits = char_traits<_Elem>>
class basic_ios;
template <class _Elem, class _Traits = char_traits<_Elem>>
class istreambuf_iterator;
template <class _Elem, class _Traits = char_traits<_Elem>>
class ostreambuf_iterator;
template <class _Elem, class _Traits = char_traits<_Elem>>
class basic_streambuf;

#pragma vtordisp(push, 2) 
template <class _Elem, class _Traits = char_traits<_Elem>>
class basic_istream;
template <class _Elem, class _Traits = char_traits<_Elem>>
class basic_ostream;
#pragma vtordisp(pop) 

template <class _Elem, class _Traits = char_traits<_Elem>>
class basic_iostream;
template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
class basic_stringbuf;
template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
class basic_istringstream;
template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
class basic_ostringstream;
template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
class basic_stringstream;

template <class _Elem, class _Traits = char_traits<_Elem>>
class basic_spanbuf;
template <class _Elem, class _Traits = char_traits<_Elem>>
class basic_ispanstream;
template <class _Elem, class _Traits = char_traits<_Elem>>
class basic_ospanstream;
template <class _Elem, class _Traits = char_traits<_Elem>>
class basic_spanstream;
#line 207 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iosfwd"
template <class _Elem, class _Traits = char_traits<_Elem>>
class basic_filebuf;
template <class _Elem, class _Traits = char_traits<_Elem>>
class basic_ifstream;
template <class _Elem, class _Traits = char_traits<_Elem>>
class basic_ofstream;
template <class _Elem, class _Traits = char_traits<_Elem>>
class basic_fstream;

template <class _Elem, class _Traits = char_traits<_Elem>>
class _Basic_syncbuf_impl;
template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
class basic_syncbuf;
template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
class basic_osyncstream;
#line 223 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iosfwd"


#line 232 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iosfwd"

using ios           = basic_ios<char, char_traits<char>>;
using streambuf     = basic_streambuf<char, char_traits<char>>;
using istream       = basic_istream<char, char_traits<char>>;
using ostream       = basic_ostream<char, char_traits<char>>;
using iostream      = basic_iostream<char, char_traits<char>>;
using stringbuf     = basic_stringbuf<char, char_traits<char>, allocator<char>>;
using istringstream = basic_istringstream<char, char_traits<char>, allocator<char>>;
using ostringstream = basic_ostringstream<char, char_traits<char>, allocator<char>>;
using stringstream  = basic_stringstream<char, char_traits<char>, allocator<char>>;
using filebuf       = basic_filebuf<char, char_traits<char>>;
using ifstream      = basic_ifstream<char, char_traits<char>>;
using ofstream      = basic_ofstream<char, char_traits<char>>;
using fstream       = basic_fstream<char, char_traits<char>>;

using syncbuf     = basic_syncbuf<char>;
using osyncstream = basic_osyncstream<char>;
#line 250 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iosfwd"

using spanbuf     = basic_spanbuf<char>;
using ispanstream = basic_ispanstream<char>;
using ospanstream = basic_ospanstream<char>;
using spanstream  = basic_spanstream<char>;
#line 256 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iosfwd"

using wios           = basic_ios<wchar_t, char_traits<wchar_t>>;
using wstreambuf     = basic_streambuf<wchar_t, char_traits<wchar_t>>;
using wistream       = basic_istream<wchar_t, char_traits<wchar_t>>;
using wostream       = basic_ostream<wchar_t, char_traits<wchar_t>>;
using wiostream      = basic_iostream<wchar_t, char_traits<wchar_t>>;
using wstringbuf     = basic_stringbuf<wchar_t, char_traits<wchar_t>, allocator<wchar_t>>;
using wistringstream = basic_istringstream<wchar_t, char_traits<wchar_t>, allocator<wchar_t>>;
using wostringstream = basic_ostringstream<wchar_t, char_traits<wchar_t>, allocator<wchar_t>>;
using wstringstream  = basic_stringstream<wchar_t, char_traits<wchar_t>, allocator<wchar_t>>;
using wfilebuf       = basic_filebuf<wchar_t, char_traits<wchar_t>>;
using wifstream      = basic_ifstream<wchar_t, char_traits<wchar_t>>;
using wofstream      = basic_ofstream<wchar_t, char_traits<wchar_t>>;
using wfstream       = basic_fstream<wchar_t, char_traits<wchar_t>>;

using wsyncbuf     = basic_syncbuf<wchar_t>;
using wosyncstream = basic_osyncstream<wchar_t>;
#line 274 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iosfwd"

using wspanbuf     = basic_spanbuf<wchar_t>;
using wispanstream = basic_ispanstream<wchar_t>;
using wospanstream = basic_ospanstream<wchar_t>;
using wspanstream  = basic_spanstream<wchar_t>;
#line 280 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iosfwd"


#line 286 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iosfwd"
}


#pragma warning(pop)
#pragma pack(pop)
#line 293 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iosfwd"
#line 294 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iosfwd"
#line 12 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\bitset"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xpolymorphic_allocator.h"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {


#line 137 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xpolymorphic_allocator.h"


namespace pmr {
    class __declspec(novtable) memory_resource {
    public:
        virtual ~memory_resource() noexcept = default;

        [[nodiscard]] __declspec(allocator) void* allocate( const size_t _Bytes,
            const size_t _Align = alignof(max_align_t)) { 
            ;
            void* _Ptr = do_allocate(_Bytes, _Align);
            return ::operator new(_Bytes, _Ptr);
        }

        void deallocate(void* const _Ptr, const size_t _Bytes, const size_t _Align = alignof(max_align_t)) {
            
            ;
            return do_deallocate(_Ptr, _Bytes, _Align);
        }

        [[nodiscard]] bool is_equal(const memory_resource& _That) const noexcept {
            
            return do_is_equal(_That);
        }

    private:
        virtual void* do_allocate(size_t _Bytes, size_t _Align)               = 0;
        virtual void do_deallocate(void* _Ptr, size_t _Bytes, size_t _Align)  = 0;
        virtual bool do_is_equal(const memory_resource& _That) const noexcept = 0;
    };

    [[nodiscard]] inline bool operator==(const memory_resource& _Left, const memory_resource& _Right) noexcept {
        return &_Left == &_Right || _Left.is_equal(_Right);
    }


#line 177 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xpolymorphic_allocator.h"

    extern "C"  memory_resource* __cdecl _Aligned_get_default_resource() noexcept;
    extern "C"  memory_resource* __cdecl _Unaligned_get_default_resource() noexcept;

    [[nodiscard]] inline memory_resource* get_default_resource() noexcept {

        return _Aligned_get_default_resource();


#line 187 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xpolymorphic_allocator.h"
    }


    template <class _Ty = byte>


#line 194 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xpolymorphic_allocator.h"
    class polymorphic_allocator {
    public:
        template <class>
        friend class polymorphic_allocator;

        using value_type = _Ty;

        polymorphic_allocator() noexcept = default;

         polymorphic_allocator(memory_resource* const _Resource_) noexcept 
            : _Resource{_Resource_} { 
            ;
#line 207 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xpolymorphic_allocator.h"
        }

        polymorphic_allocator(const polymorphic_allocator&) = default;

        template <class _Uty>
        polymorphic_allocator(const polymorphic_allocator<_Uty>& _That) noexcept
            : _Resource{_That._Resource} {} 

        polymorphic_allocator& operator=(const polymorphic_allocator&) = delete;

        [[nodiscard]] __declspec(allocator) _Ty* allocate( const size_t _Count) {
            
            void* const _Vp = _Resource->allocate(_Get_size_of_n<sizeof(_Ty)>(_Count), alignof(_Ty));
            return static_cast<_Ty*>(_Vp);
        }

        void deallocate(_Ty* const _Ptr, const size_t _Count) noexcept  {
            
            
            _Resource->deallocate(_Ptr, _Count * sizeof(_Ty), alignof(_Ty));
        }


        [[nodiscard]] __declspec(allocator) void* allocate_bytes(
            const size_t _Bytes, const size_t _Align = alignof(max_align_t)) {
            return _Resource->allocate(_Bytes, _Align);
        }

        void deallocate_bytes(void* const _Ptr, const size_t _Bytes,
            const size_t _Align = alignof(max_align_t)) noexcept  {
            _Resource->deallocate(_Ptr, _Bytes, _Align);
        }

        template <class _Uty>
        [[nodiscard]] __declspec(allocator) _Uty* allocate_object( const size_t _Count = 1) {
            void* const _Vp = allocate_bytes(_Get_size_of_n<sizeof(_Uty)>(_Count), alignof(_Uty));
            return static_cast<_Uty*>(_Vp);
        }

        template <class _Uty>
        void deallocate_object(_Uty* const _Ptr, const size_t _Count = 1) noexcept  {
            deallocate_bytes(_Ptr, _Count * sizeof(_Uty), alignof(_Uty));
        }

        template <class _Uty, class... _Types>
        [[nodiscard]] __declspec(allocator) _Uty* new_object(_Types&&... _Args) {
            _Uty* const _Ptr = allocate_object<_Uty>();
            try {
            construct(_Ptr, ::std:: forward<_Types>(_Args)...);
            } catch (...) {
            deallocate_object(_Ptr);
            throw;
            }
            return _Ptr;
        }

        template <class _Uty>
        void delete_object(_Uty* const _Ptr) noexcept  {
            _Destroy_in_place(*_Ptr);
            deallocate_object(_Ptr);
        }
#line 269 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xpolymorphic_allocator.h"

        template <class _Uty, class... _Types>
        void construct(_Uty* const _Ptr, _Types&&... _Args) {
            

            ::std:: uninitialized_construct_using_allocator(_Ptr, *this, ::std:: forward<_Types>(_Args)...);


#line 279 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xpolymorphic_allocator.h"
        }

        template <class _Uty>
        [[deprecated("warning STL4032: " "std::pmr::polymorphic_allocator::destroy() is deprecated in C++17 by LWG-3036. " "Prefer std::destroy_at() or std::allocator_traits<polymorphic_allocator>::destroy(). " "You can define _SILENCE_CXX17_POLYMORPHIC_ALLOCATOR_DESTROY_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] void destroy(_Uty* const _Ptr) noexcept  {
            _Destroy_in_place(*_Ptr);
        }

        [[nodiscard]] polymorphic_allocator select_on_container_copy_construction() const noexcept  {
            
            return {};
        }

        [[nodiscard]] memory_resource* resource() const noexcept  {
            
            return _Resource;
        }

    private:
        memory_resource* _Resource = ::std:: pmr::get_default_resource();
    };

    template <class _Ty1, class _Ty2>
    [[nodiscard]] bool operator==(
        const polymorphic_allocator<_Ty1>& _Left, const polymorphic_allocator<_Ty2>& _Right) noexcept {
        
        return *_Left.resource() == *_Right.resource();
    }


#line 314 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xpolymorphic_allocator.h"

} 

template <class _Ty, class _Ptr>
struct _Has_no_alloc_destroy<pmr::polymorphic_allocator<_Ty>, _Ptr, void> : true_type {
    
    
};

#line 324 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xpolymorphic_allocator.h"

}


#pragma warning(pop)
#pragma pack(pop)
#line 332 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xpolymorphic_allocator.h"
#line 333 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xpolymorphic_allocator.h"
#line 18 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
#line 19 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


#line 32 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

namespace std {
template <class _Elem, class _Int_type>
struct _Char_traits { 
    using char_type  = _Elem;
    using int_type   = _Int_type;
    using pos_type   = streampos;
    using off_type   = streamoff;
    using state_type = _Mbstatet;

    using comparison_category = strong_ordering;
#line 44 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    
    static constexpr _Elem* copy(  _Elem* const _First1,
          const _Elem* const _First2, const size_t _Count) noexcept  {
        

#line 53 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

        if (::std:: is_constant_evaluated()) {
            
            for (size_t _Idx = 0; _Idx != _Count; ++_Idx) {
                _First1[_Idx] = _First2[_Idx];
            }

            return _First1;
        }
#line 63 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

        :: memcpy(_First1, _First2, _Count * sizeof(_Elem));
#line 66 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

        return _First1;
    }

      static constexpr _Elem* _Copy_s( 
                                                                                 _Elem* const _First1,
        const size_t _Dest_size,   const _Elem* const _First2, const size_t _Count) noexcept {
        
        do { if (_Count <= _Dest_size) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
        return copy(_First1, _First2, _Count);
    }

    static constexpr _Elem* move(  _Elem* const _First1,
          const _Elem* const _First2, const size_t _Count) noexcept  {
        

#line 84 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

        if (::std:: is_constant_evaluated()) {
            
            
            bool _Loop_forward = true;

            for (const _Elem* _Src = _First2; _Src != _First2 + _Count; ++_Src) {
                if (_First1 == _Src) {
                    _Loop_forward = false;
                    break;
                }
            }

            if (_Loop_forward) {
                for (size_t _Idx = 0; _Idx != _Count; ++_Idx) {
                    _First1[_Idx] = _First2[_Idx];
                }
            } else {
                for (size_t _Idx = _Count; _Idx != 0; --_Idx) {
                    _First1[_Idx - 1] = _First2[_Idx - 1];
                }
            }

            return _First1;
        }
#line 116 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

        :: memmove(_First1, _First2, _Count * sizeof(_Elem));
#line 119 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

        return _First1;
    }

    
    [[nodiscard]] static constexpr int compare(  const _Elem* _First1,
          const _Elem* _First2, size_t _Count) noexcept  {
        
        for (; 0 < _Count; --_Count, ++_First1, ++_First2) {
            if (*_First1 != *_First2) {
                return *_First1 < *_First2 ? -1 : +1;
            }
        }

        return 0;
    }

    [[nodiscard]] static constexpr size_t length(  const _Elem* _First) noexcept  {
        
        size_t _Count = 0;
        while (*_First != _Elem()) {
            ++_Count;
            ++_First;
        }

        return _Count;
    }

    [[nodiscard]] static constexpr const _Elem* find(
          const _Elem* _First, size_t _Count, const _Elem& _Ch) noexcept  {
        
        for (; 0 < _Count; --_Count, ++_First) {
            if (*_First == _Ch) {
                return _First;
            }
        }

        return nullptr;
    }

    static constexpr _Elem* assign(
          _Elem* const _First, size_t _Count, const _Elem _Ch) noexcept  {
        

        if (::std:: is_constant_evaluated()) {
            for (_Elem* _Next = _First; _Count > 0; --_Count, ++_Next) {
                ::std:: construct_at(_Next, _Ch);
            }
        } else
#line 171 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        {
            for (_Elem* _Next = _First; _Count > 0; --_Count, ++_Next) {
                *_Next = _Ch;
            }
        }

        return _First;
    }

    static constexpr void assign(_Elem& _Left, const _Elem& _Right) noexcept {

        if (::std:: is_constant_evaluated()) {
            ::std:: construct_at(::std:: addressof(_Left), _Right);
        } else
#line 186 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        {
            _Left = _Right;
        }
    }

    [[nodiscard]] static constexpr bool eq(const _Elem& _Left, const _Elem& _Right) noexcept {
        return _Left == _Right;
    }

    [[nodiscard]] static constexpr bool lt(const _Elem& _Left, const _Elem& _Right) noexcept {
        return _Left < _Right;
    }

    [[nodiscard]] static constexpr _Elem to_char_type(const int_type& _Meta) noexcept {
        return static_cast<_Elem>(_Meta);
    }

    [[nodiscard]] static constexpr int_type to_int_type(const _Elem& _Ch) noexcept {
        return static_cast<int_type>(_Ch);
    }

    [[nodiscard]] static constexpr bool eq_int_type(const int_type& _Left, const int_type& _Right) noexcept {
        return _Left == _Right;
    }

    [[nodiscard]] static constexpr int_type not_eof(const int_type& _Meta) noexcept {
        return _Meta != eof() ? _Meta : !eof();
    }

    [[nodiscard]] static constexpr int_type eof() noexcept {
        return static_cast<int_type>((-1));
    }
};

template <class _Elem>
struct _WChar_traits : private _Char_traits<_Elem, unsigned short> {
    
private:
    using _Primary_char_traits = _Char_traits<_Elem, unsigned short>;

public:
    using char_type  = _Elem;
    using int_type   = unsigned short;
    using pos_type   = streampos;
    using off_type   = streamoff;
    using state_type = mbstate_t;

    using comparison_category = strong_ordering;
#line 235 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    using _Primary_char_traits::_Copy_s;
    using _Primary_char_traits::copy;
    using _Primary_char_traits::move;

    [[nodiscard]] static constexpr int compare(  const _Elem* const _First1,
          const _Elem* const _First2, const size_t _Count) noexcept  {
        

        if constexpr (is_same_v<_Elem, wchar_t>) {
            return __builtin_wmemcmp(_First1, _First2, _Count);
        } else {
            return _Primary_char_traits::compare(_First1, _First2, _Count);
        }


#line 253 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
    }

    [[nodiscard]] static constexpr size_t length(  const _Elem* _First) noexcept  {
        

        if constexpr (is_same_v<_Elem, wchar_t>) {
            return __builtin_wcslen(_First);
        } else {
            return _Primary_char_traits::length(_First);
        }


#line 266 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
    }

    [[nodiscard]] static constexpr const _Elem* find(
          const _Elem* _First, const size_t _Count, const _Elem& _Ch) noexcept  {
        

        if constexpr (is_same_v<_Elem, wchar_t>) {
            return __builtin_wmemchr(_First, _Ch, _Count);
        } else {
            return _Primary_char_traits::find(_First, _Count, _Ch);
        }


#line 280 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
    }

    static constexpr _Elem* assign(
          _Elem* const _First, size_t _Count, const _Elem _Ch) noexcept  {
        

        if (::std:: is_constant_evaluated()) {
            return _Primary_char_traits::assign(_First, _Count, _Ch);
        }
#line 290 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

        return reinterpret_cast<_Elem*>(:: wmemset(reinterpret_cast<wchar_t*>(_First), _Ch, _Count));
    }

    static constexpr void assign(_Elem& _Left, const _Elem& _Right) noexcept {

        if (::std:: is_constant_evaluated()) {
            return _Primary_char_traits::assign(_Left, _Right);
        }
#line 300 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        _Left = _Right;
    }

    [[nodiscard]] static constexpr bool eq(const _Elem& _Left, const _Elem& _Right) noexcept {
        return _Left == _Right;
    }

    [[nodiscard]] static constexpr bool lt(const _Elem& _Left, const _Elem& _Right) noexcept {
        return _Left < _Right;
    }

    [[nodiscard]] static constexpr _Elem to_char_type(const int_type& _Meta) noexcept {
        return _Meta;
    }

    [[nodiscard]] static constexpr int_type to_int_type(const _Elem& _Ch) noexcept {
        return _Ch;
    }

    [[nodiscard]] static constexpr bool eq_int_type(const int_type& _Left, const int_type& _Right) noexcept {
        return _Left == _Right;
    }

    [[nodiscard]] static constexpr int_type not_eof(const int_type& _Meta) noexcept {
        return _Meta != eof() ? _Meta : static_cast<int_type>(!eof());
    }

    [[nodiscard]] static constexpr int_type eof() noexcept {
        return ((wint_t)(0xFFFF));
    }
};

template <class _Elem>
struct char_traits : _Char_traits<_Elem, long> {}; 

template <>
struct char_traits<char16_t> : _WChar_traits<char16_t> {};

template <>
struct char_traits<char32_t> : _Char_traits<char32_t, unsigned int> {};

template <>
struct char_traits<wchar_t> : _WChar_traits<wchar_t> {};


template <>
struct char_traits<unsigned short> : _WChar_traits<unsigned short> {};
#line 348 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"


#line 354 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

template <class _Elem, class _Int_type>
struct _Narrow_char_traits : private _Char_traits<_Elem, _Int_type> {
    
private:
    using _Primary_char_traits = _Char_traits<_Elem, _Int_type>;

public:
    using char_type  = _Elem;
    using int_type   = _Int_type;
    using pos_type   = streampos;
    using off_type   = streamoff;
    using state_type = mbstate_t;

    using comparison_category = strong_ordering;
#line 370 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    using _Primary_char_traits::_Copy_s;
    using _Primary_char_traits::copy;
    using _Primary_char_traits::move;

    [[nodiscard]] static constexpr int compare(  const _Elem* const _First1,
          const _Elem* const _First2, const size_t _Count) noexcept  {
        

        return __builtin_memcmp(_First1, _First2, _Count);


#line 383 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
    }

    [[nodiscard]] static constexpr size_t length(  const _Elem* const _First) noexcept  {
        

        if constexpr (is_same_v<_Elem, char8_t>) {

            return __builtin_u8strlen(_First);


#line 395 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        } else
#line 397 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        {
            return __builtin_strlen(_First);
        }


#line 403 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
    }

    [[nodiscard]] static constexpr const _Elem* find(  const _Elem* const _First, const size_t _Count,
        const _Elem& _Ch) noexcept  {
        

        if constexpr (is_same_v<_Elem, char8_t>) {

            return __builtin_u8memchr(_First, _Ch, _Count);


#line 416 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        } else
#line 418 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        {
            return __builtin_char_memchr(_First, _Ch, _Count);
        }


#line 424 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
    }

    static constexpr _Elem* assign(
          _Elem* const _First, size_t _Count, const _Elem _Ch) noexcept  {
        

        if (::std:: is_constant_evaluated()) {
            return _Primary_char_traits::assign(_First, _Count, _Ch);
        }
#line 434 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

        return static_cast<_Elem*>(:: memset(_First, _Ch, _Count));
    }

    static constexpr void assign(_Elem& _Left, const _Elem& _Right) noexcept {

        if (::std:: is_constant_evaluated()) {
            return _Primary_char_traits::assign(_Left, _Right);
        }
#line 444 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        _Left = _Right;
    }

    [[nodiscard]] static constexpr bool eq(const _Elem& _Left, const _Elem& _Right) noexcept {
        return _Left == _Right;
    }

    [[nodiscard]] static constexpr bool lt(const _Elem& _Left, const _Elem& _Right) noexcept {
        return static_cast<unsigned char>(_Left) < static_cast<unsigned char>(_Right);
    }

    [[nodiscard]] static constexpr _Elem to_char_type(const int_type& _Meta) noexcept {
        return static_cast<_Elem>(_Meta);
    }

    [[nodiscard]] static constexpr int_type to_int_type(const _Elem& _Ch) noexcept {
        return static_cast<unsigned char>(_Ch);
    }

    [[nodiscard]] static constexpr bool eq_int_type(const int_type& _Left, const int_type& _Right) noexcept {
        return _Left == _Right;
    }

    [[nodiscard]] static constexpr int_type not_eof(const int_type& _Meta) noexcept {
        return _Meta != eof() ? _Meta : !eof();
    }

    [[nodiscard]] static constexpr int_type eof() noexcept {
        return static_cast<int_type>((-1));
    }
};


template <>
struct char_traits<char> : _Narrow_char_traits<char, int> {}; 


template <>
struct char_traits<char8_t> : _Narrow_char_traits<char8_t, unsigned int> {};
#line 486 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

template <class _Elem, class _Traits, class _SizeT>
basic_ostream<_Elem, _Traits>& _Insert_string(
    basic_ostream<_Elem, _Traits>& _Ostr, const _Elem* const _Data, const _SizeT _Size) {
    
    using _Ostr_t                    = basic_ostream<_Elem, _Traits>;
    typename _Ostr_t::iostate _State = _Ostr_t::goodbit;

    _SizeT _Pad;
    if (_Ostr.width() <= 0 || static_cast<_SizeT>(_Ostr.width()) <= _Size) {
        _Pad = 0;
    } else {
        _Pad = static_cast<_SizeT>(_Ostr.width()) - _Size;
    }

    const typename _Ostr_t::sentry _Ok(_Ostr);

    if (!_Ok) {
        _State |= _Ostr_t::badbit;
    } else { 
        try {
        if ((_Ostr.flags() & _Ostr_t::adjustfield) != _Ostr_t::left) {
            for (; 0 < _Pad; --_Pad) { 
                if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
                    _State |= _Ostr_t::badbit; 
                    break;
                }
            }
        }

        if (_State == _Ostr_t::goodbit
            && _Ostr.rdbuf()->sputn(_Data, static_cast<streamsize>(_Size)) != static_cast<streamsize>(_Size)) {
            _State |= _Ostr_t::badbit;
        } else {
            for (; 0 < _Pad; --_Pad) { 
                if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
                    _State |= _Ostr_t::badbit; 
                    break;
                }
            }
        }

        _Ostr.width(0);
        } catch (...) { (_Ostr) .setstate(_Ostr_t::badbit, true); }
    }

    _Ostr.setstate(_State);
    return _Ostr;
}

template <class _Traits>
struct _Char_traits_eq {
    using _Elem = typename _Traits::char_type;

    bool operator()(_Elem _Left, _Elem _Right) const noexcept {
        return _Traits::eq(_Left, _Right);
    }
};

template <class _Traits>
struct _Char_traits_lt {
    using _Elem = typename _Traits::char_type;

    bool operator()(_Elem _Left, _Elem _Right) const noexcept {
        return _Traits::lt(_Left, _Right);
    }
};


template <class _Elem>
inline constexpr bool _Can_memcmp_elements_with_pred<_Elem, _Elem, _Char_traits_eq<char_traits<_Elem>>> =
    _Can_memcmp_elements<_Elem, _Elem>;


template <class _Elem>
struct _Lex_compare_memcmp_classify_pred<_Elem, _Elem, _Char_traits_lt<char_traits<_Elem>>> {
    using _UElem = make_unsigned_t<_Elem>;
    using _Pred  = conditional_t<_Lex_compare_memcmp_classify_elements<_UElem, _UElem>, less<int>, void>;
};

template <class _Traits>
using _Traits_ch_t = typename _Traits::char_type;

template <class _Traits>
using _Traits_ptr_t = const typename _Traits::char_type*;

template <class _Traits>
constexpr bool _Traits_equal(  const _Traits_ptr_t<_Traits> _Left, const size_t _Left_size,
      const _Traits_ptr_t<_Traits> _Right, const size_t _Right_size) noexcept {
    
    return _Left_size == _Right_size && _Traits::compare(_Left, _Right, _Left_size) == 0;
}

template <class _Traits>
constexpr int _Traits_compare(  const _Traits_ptr_t<_Traits> _Left, const size_t _Left_size,
      const _Traits_ptr_t<_Traits> _Right, const size_t _Right_size) noexcept {
    
    const int _Ans = _Traits::compare(_Left, _Right, (::std:: min)(_Left_size, _Right_size));

    if (_Ans != 0) {
        return _Ans;
    }

    if (_Left_size < _Right_size) {
        return -1;
    }

    if (_Left_size > _Right_size) {
        return 1;
    }

    return 0;
}

template <class _Traits>
constexpr size_t _Traits_find(  const _Traits_ptr_t<_Traits> _Haystack, const size_t _Hay_size,
    const size_t _Start_at,   const _Traits_ptr_t<_Traits> _Needle,
    const size_t _Needle_size) noexcept {
    
    if (_Needle_size > _Hay_size || _Start_at > _Hay_size - _Needle_size) {
        
        
        return static_cast<size_t>(-1);
    }

    if (_Needle_size == 0) { 
        return _Start_at;
    }

    const auto _Possible_matches_end = _Haystack + (_Hay_size - _Needle_size) + 1;
    for (auto _Match_try = _Haystack + _Start_at;; ++_Match_try) {
        _Match_try = _Traits::find(_Match_try, static_cast<size_t>(_Possible_matches_end - _Match_try), *_Needle);
        if (!_Match_try) { 
            return static_cast<size_t>(-1);
        }

        if (_Traits::compare(_Match_try, _Needle, _Needle_size) == 0) { 
            return static_cast<size_t>(_Match_try - _Haystack);
        }
    }
}

template <class _Traits>
constexpr size_t _Traits_find_ch(  const _Traits_ptr_t<_Traits> _Haystack, const size_t _Hay_size,
    const size_t _Start_at, const _Traits_ch_t<_Traits> _Ch) noexcept {
    
    if (_Start_at < _Hay_size) {
        const auto _Found_at = _Traits::find(_Haystack + _Start_at, _Hay_size - _Start_at, _Ch);
        if (_Found_at) {
            return static_cast<size_t>(_Found_at - _Haystack);
        }
    }

    return static_cast<size_t>(-1); 
}

template <class _Traits>
constexpr size_t _Traits_rfind(  const _Traits_ptr_t<_Traits> _Haystack, const size_t _Hay_size,
    const size_t _Start_at,   const _Traits_ptr_t<_Traits> _Needle,
    const size_t _Needle_size) noexcept {
    
    if (_Needle_size == 0) {
        return (::std:: min)(_Start_at, _Hay_size); 
    }

    if (_Needle_size <= _Hay_size) { 
        for (auto _Match_try = _Haystack + (::std:: min)(_Start_at, _Hay_size - _Needle_size);; --_Match_try) {
            if (_Traits::eq(*_Match_try, *_Needle) && _Traits::compare(_Match_try, _Needle, _Needle_size) == 0) {
                return static_cast<size_t>(_Match_try - _Haystack); 
            }

            if (_Match_try == _Haystack) {
                break; 
            }
        }
    }

    return static_cast<size_t>(-1); 
}

template <class _Traits>
constexpr size_t _Traits_rfind_ch(  const _Traits_ptr_t<_Traits> _Haystack, const size_t _Hay_size,
    const size_t _Start_at, const _Traits_ch_t<_Traits> _Ch) noexcept {
    
    if (_Hay_size != 0) { 
        for (auto _Match_try = _Haystack + (::std:: min)(_Start_at, _Hay_size - 1);; --_Match_try) {
            if (_Traits::eq(*_Match_try, _Ch)) {
                return static_cast<size_t>(_Match_try - _Haystack); 
            }

            if (_Match_try == _Haystack) {
                break; 
            }
        }
    }

    return static_cast<size_t>(-1); 
}

template <class _Elem, bool = _Is_character<_Elem>::value>
class _String_bitmap { 
public:
    constexpr bool _Mark(const _Elem* _First, const _Elem* const _Last) noexcept {
        
        
        for (; _First != _Last; ++_First) {
            _Matches[static_cast<unsigned char>(*_First)] = true;
        }

        return true;
    }

    constexpr bool _Match(const _Elem _Ch) const noexcept { 
        return _Matches[static_cast<unsigned char>(_Ch)];
    }

private:
    bool _Matches[256] = {};
};

template <class _Elem>
class _String_bitmap<_Elem, false> { 
public:
    static_assert(is_unsigned_v<_Elem>,
        "Standard char_traits is only provided for char, wchar_t, char16_t, and char32_t. See N5687 [char.traits]. "
        "Visual C++ accepts other unsigned integral types as an extension.");

    constexpr bool _Mark(const _Elem* _First, const _Elem* const _Last) noexcept {
        
        
        for (; _First != _Last; ++_First) {
            const auto _Ch = *_First;
            if (_Ch >= 256U) {
                return false;
            }

            _Matches[static_cast<unsigned char>(_Ch)] = true;
        }

        return true;
    }

    constexpr bool _Match(const _Elem _Ch) const noexcept { 
        return _Ch < 256U && _Matches[_Ch];
    }

private:
    bool _Matches[256] = {};
};

template <class _Traits>
constexpr size_t _Traits_find_first_of(  const _Traits_ptr_t<_Traits> _Haystack,
    const size_t _Hay_size, const size_t _Start_at,   const _Traits_ptr_t<_Traits> _Needle,
    const size_t _Needle_size, false_type) noexcept {
    
    
    if (_Needle_size != 0 && _Start_at < _Hay_size) { 
        const auto _End = _Haystack + _Hay_size;
        for (auto _Match_try = _Haystack + _Start_at; _Match_try < _End; ++_Match_try) {
            if (_Traits::find(_Needle, _Needle_size, *_Match_try)) {
                return static_cast<size_t>(_Match_try - _Haystack); 
            }
        }
    }

    return static_cast<size_t>(-1); 
}

template <class _Traits>
constexpr size_t _Traits_find_first_of(  const _Traits_ptr_t<_Traits> _Haystack,
    const size_t _Hay_size, const size_t _Start_at,   const _Traits_ptr_t<_Traits> _Needle,
    const size_t _Needle_size, true_type) noexcept {
    
    
    if (_Needle_size != 0 && _Start_at < _Hay_size) { 
        _String_bitmap<typename _Traits::char_type> _Matches;
        if (!_Matches._Mark(_Needle, _Needle + _Needle_size)) { 
                                                                
            return _Traits_find_first_of<_Traits>(_Haystack, _Hay_size, _Start_at, _Needle, _Needle_size, false_type{});
        }

        const auto _End = _Haystack + _Hay_size;
        for (auto _Match_try = _Haystack + _Start_at; _Match_try < _End; ++_Match_try) {
            if (_Matches._Match(*_Match_try)) {
                return static_cast<size_t>(_Match_try - _Haystack); 
            }
        }
    }

    return static_cast<size_t>(-1); 
}

template <class _Traits>
constexpr size_t _Traits_find_last_of(  const _Traits_ptr_t<_Traits> _Haystack,
    const size_t _Hay_size, const size_t _Start_at,   const _Traits_ptr_t<_Traits> _Needle,
    const size_t _Needle_size, false_type) noexcept {
    
    
    if (_Needle_size != 0 && _Hay_size != 0) { 
        for (auto _Match_try = _Haystack + (::std:: min)(_Start_at, _Hay_size - 1);; --_Match_try) {
            if (_Traits::find(_Needle, _Needle_size, *_Match_try)) {
                return static_cast<size_t>(_Match_try - _Haystack); 
            }

            if (_Match_try == _Haystack) {
                break; 
            }
        }
    }

    return static_cast<size_t>(-1); 
}

template <class _Traits>
constexpr size_t _Traits_find_last_of(  const _Traits_ptr_t<_Traits> _Haystack,
    const size_t _Hay_size, const size_t _Start_at,   const _Traits_ptr_t<_Traits> _Needle,
    const size_t _Needle_size, true_type) noexcept {
    
    
    if (_Needle_size != 0 && _Hay_size != 0) { 
        _String_bitmap<typename _Traits::char_type> _Matches;
        if (!_Matches._Mark(_Needle, _Needle + _Needle_size)) { 
                                                                
            return _Traits_find_last_of<_Traits>(_Haystack, _Hay_size, _Start_at, _Needle, _Needle_size, false_type{});
        }

        for (auto _Match_try = _Haystack + (::std:: min)(_Start_at, _Hay_size - 1);; --_Match_try) {
            if (_Matches._Match(*_Match_try)) {
                return static_cast<size_t>(_Match_try - _Haystack); 
            }

            if (_Match_try == _Haystack) {
                break; 
            }
        }
    }

    return static_cast<size_t>(-1); 
}

template <class _Traits>
constexpr size_t _Traits_find_first_not_of(  const _Traits_ptr_t<_Traits> _Haystack,
    const size_t _Hay_size, const size_t _Start_at,   const _Traits_ptr_t<_Traits> _Needle,
    const size_t _Needle_size, false_type) noexcept {
    
    
    if (_Start_at < _Hay_size) { 
        const auto _End = _Haystack + _Hay_size;
        for (auto _Match_try = _Haystack + _Start_at; _Match_try < _End; ++_Match_try) {
            if (!_Traits::find(_Needle, _Needle_size, *_Match_try)) {
                return static_cast<size_t>(_Match_try - _Haystack); 
            }
        }
    }

    return static_cast<size_t>(-1); 
}

template <class _Traits>
constexpr size_t _Traits_find_first_not_of(  const _Traits_ptr_t<_Traits> _Haystack,
    const size_t _Hay_size, const size_t _Start_at,   const _Traits_ptr_t<_Traits> _Needle,
    const size_t _Needle_size, true_type) noexcept {
    
    
    if (_Start_at < _Hay_size) { 
        _String_bitmap<typename _Traits::char_type> _Matches;
        if (!_Matches._Mark(_Needle, _Needle + _Needle_size)) { 
                                                                
            return _Traits_find_first_not_of<_Traits>(
                _Haystack, _Hay_size, _Start_at, _Needle, _Needle_size, false_type{});
        }

        const auto _End = _Haystack + _Hay_size;
        for (auto _Match_try = _Haystack + _Start_at; _Match_try < _End; ++_Match_try) {
            if (!_Matches._Match(*_Match_try)) {
                return static_cast<size_t>(_Match_try - _Haystack); 
            }
        }
    }

    return static_cast<size_t>(-1); 
}

template <class _Traits>
constexpr size_t _Traits_find_not_ch(  const _Traits_ptr_t<_Traits> _Haystack,
    const size_t _Hay_size, const size_t _Start_at, const _Traits_ch_t<_Traits> _Ch) noexcept {
    
    if (_Start_at < _Hay_size) { 
        const auto _End = _Haystack + _Hay_size;
        for (auto _Match_try = _Haystack + _Start_at; _Match_try < _End; ++_Match_try) {
            if (!_Traits::eq(*_Match_try, _Ch)) {
                return static_cast<size_t>(_Match_try - _Haystack); 
            }
        }
    }

    return static_cast<size_t>(-1); 
}

template <class _Traits>
constexpr size_t _Traits_find_last_not_of(  const _Traits_ptr_t<_Traits> _Haystack,
    const size_t _Hay_size, const size_t _Start_at,   const _Traits_ptr_t<_Traits> _Needle,
    const size_t _Needle_size, false_type) noexcept {
    
    
    if (_Hay_size != 0) { 
        for (auto _Match_try = _Haystack + (::std:: min)(_Start_at, _Hay_size - 1);; --_Match_try) {
            if (!_Traits::find(_Needle, _Needle_size, *_Match_try)) {
                return static_cast<size_t>(_Match_try - _Haystack); 
            }

            if (_Match_try == _Haystack) {
                break; 
            }
        }
    }

    return static_cast<size_t>(-1); 
}

template <class _Traits>
constexpr size_t _Traits_find_last_not_of(  const _Traits_ptr_t<_Traits> _Haystack,
    const size_t _Hay_size, const size_t _Start_at,   const _Traits_ptr_t<_Traits> _Needle,
    const size_t _Needle_size, true_type) noexcept {
    
    
    if (_Hay_size != 0) { 
        _String_bitmap<typename _Traits::char_type> _Matches;
        if (!_Matches._Mark(_Needle, _Needle + _Needle_size)) { 
                                                                
            return _Traits_find_last_not_of<_Traits>(
                _Haystack, _Hay_size, _Start_at, _Needle, _Needle_size, false_type{});
        }

        for (auto _Match_try = _Haystack + (::std:: min)(_Start_at, _Hay_size - 1);; --_Match_try) {
            if (!_Matches._Match(*_Match_try)) {
                return static_cast<size_t>(_Match_try - _Haystack); 
            }

            if (_Match_try == _Haystack) {
                break; 
            }
        }
    }

    return static_cast<size_t>(-1); 
}

template <class _Traits>
constexpr size_t _Traits_rfind_not_ch(  const _Traits_ptr_t<_Traits> _Haystack,
    const size_t _Hay_size, const size_t _Start_at, const _Traits_ch_t<_Traits> _Ch) noexcept {
    
    if (_Hay_size != 0) { 
        for (auto _Match_try = _Haystack + (::std:: min)(_Start_at, _Hay_size - 1);; --_Match_try) {
            if (!_Traits::eq(*_Match_try, _Ch)) {
                return static_cast<size_t>(_Match_try - _Haystack); 
            }

            if (_Match_try == _Haystack) {
                break; 
            }
        }
    }

    return static_cast<size_t>(-1); 
}


template <class _Elem, class _Traits = char_traits<_Elem>>
class basic_string_view;

template <class _Traits>
class _String_view_iterator {
public:

    using iterator_concept = contiguous_iterator_tag;
#line 972 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
    using iterator_category = random_access_iterator_tag;
    using value_type        = typename _Traits::char_type;
    using difference_type   = ptrdiff_t;
    using pointer           = const value_type*;
    using reference         = const value_type&;

    constexpr _String_view_iterator() noexcept = default;

private:
    friend basic_string_view<value_type, _Traits>;


#line 987 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
    constexpr explicit _String_view_iterator(const pointer _Ptr) noexcept : _Myptr(_Ptr) {}
#line 989 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

public:
    [[nodiscard]] constexpr reference operator*() const noexcept {


#line 997 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        return *_Myptr;
#line 999 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
    }

    [[nodiscard]] constexpr pointer operator->() const noexcept {


#line 1007 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        return _Myptr;
#line 1009 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
    }

    constexpr _String_view_iterator& operator++() noexcept {


#line 1017 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        ++_Myptr;
#line 1019 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        return *this;
    }

    constexpr _String_view_iterator operator++(int) noexcept {
        _String_view_iterator _Tmp{*this};
        ++*this;
        return _Tmp;
    }

    constexpr _String_view_iterator& operator--() noexcept {


#line 1034 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        --_Myptr;
#line 1036 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        return *this;
    }

    constexpr _String_view_iterator operator--(int) noexcept {
        _String_view_iterator _Tmp{*this};
        --*this;
        return _Tmp;
    }

    constexpr void _Verify_offset(const difference_type _Off) const noexcept {


#line 1060 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        (void) _Off;
#line 1062 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
    }

    constexpr _String_view_iterator& operator+=(const difference_type _Off) noexcept {


#line 1069 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        _Myptr += _Off;
#line 1071 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

        return *this;
    }

    [[nodiscard]] constexpr _String_view_iterator operator+(const difference_type _Off) const noexcept {
        _String_view_iterator _Tmp{*this};
        _Tmp += _Off;
        return _Tmp;
    }

    constexpr _String_view_iterator& operator-=(const difference_type _Off) noexcept {


#line 1098 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        _Myptr -= _Off;
#line 1100 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

        return *this;
    }

    [[nodiscard]] constexpr _String_view_iterator operator-(const difference_type _Off) const noexcept {
        _String_view_iterator _Tmp{*this};
        _Tmp -= _Off;
        return _Tmp;
    }

    [[nodiscard]] constexpr difference_type operator-(const _String_view_iterator& _Right) const noexcept {


#line 1116 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        return _Myptr - _Right._Myptr;
#line 1118 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
    }

    [[nodiscard]] constexpr reference operator[](const difference_type _Off) const noexcept {
        return *(*this + _Off);
    }

    [[nodiscard]] constexpr bool operator==(const _String_view_iterator& _Right) const noexcept {


#line 1130 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        return _Myptr == _Right._Myptr;
#line 1132 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
    }


    [[nodiscard]] constexpr strong_ordering operator<=>(const _String_view_iterator& _Right) const noexcept {


#line 1141 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        return _Myptr <=> _Right._Myptr;
#line 1143 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
    }


#line 1171 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"


#line 1179 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    using _Prevent_inheriting_unwrap = _String_view_iterator;

    [[nodiscard]] constexpr pointer _Unwrapped() const noexcept {


#line 1186 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        return _Myptr;
#line 1188 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
    }

    static constexpr bool _Unwrap_when_unverified = 0 == 0;

    constexpr void _Seek_to(pointer _It) noexcept {


#line 1196 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        _Myptr = _It;
#line 1198 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
    }

private:


#line 1206 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
    pointer _Myptr = nullptr;
#line 1208 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
};

template <class _Traits>
[[nodiscard]] constexpr _String_view_iterator<_Traits> operator+(
    const typename _String_view_iterator<_Traits>::difference_type _Off,
    _String_view_iterator<_Traits> _Right) noexcept {
    _Right += _Off;
    return _Right;
}


template <class _Traits>
struct pointer_traits<_String_view_iterator<_Traits>> {
    using pointer         = _String_view_iterator<_Traits>;
    using element_type    = const typename pointer::value_type;
    using difference_type = typename pointer::difference_type;

    [[nodiscard]] static constexpr element_type* to_address(const pointer& _Iter) noexcept {
        return _Iter._Unwrapped();
    }
};
#line 1230 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"


template <class _Elem, class _Traits>
class basic_string_view { 
public:
    static_assert(is_same_v<_Elem, typename _Traits::char_type>,
        "Bad char_traits for basic_string_view; "
        "N4659 24.4.2 [string.view.template]/1 \"the type traits::char_type shall name the same type as charT.\"");

    static_assert(!is_array_v<_Elem> && is_trivial_v<_Elem> && is_standard_layout_v<_Elem>,
        "The character type of basic_string_view must be a non-array trivial standard-layout type. See N4861 "
        "[strings.general]/1.");

    using traits_type            = _Traits;
    using value_type             = _Elem;
    using pointer                = _Elem*;
    using const_pointer          = const _Elem*;
    using reference              = _Elem&;
    using const_reference        = const _Elem&;
    using const_iterator         = _String_view_iterator<_Traits>;
    using iterator               = const_iterator;
    using const_reverse_iterator = ::std:: reverse_iterator<const_iterator>;
    using reverse_iterator       = const_reverse_iterator;
    using size_type              = size_t;
    using difference_type        = ptrdiff_t;

    static constexpr auto npos{static_cast<size_type>(-1)};

    constexpr basic_string_view() noexcept : _Mydata(), _Mysize(0) {}

    constexpr basic_string_view(const basic_string_view&) noexcept = default;
    constexpr basic_string_view& operator=(const basic_string_view&) noexcept = default;

     constexpr basic_string_view(  const const_pointer _Ntcts) noexcept 
        : _Mydata(_Ntcts), _Mysize(_Traits::length(_Ntcts)) {}


    basic_string_view(nullptr_t) = delete;
#line 1269 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    constexpr basic_string_view(
          const const_pointer _Cts, const size_type _Count) noexcept 
        : _Mydata(_Cts), _Mysize(_Count) {


#line 1276 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
    }


    template <contiguous_iterator _It, sized_sentinel_for<_It> _Se>
        requires (is_same_v<iter_value_t<_It>, _Elem> && !is_convertible_v<_Se, size_type>)
    constexpr basic_string_view(_It _First, _Se _Last) noexcept(noexcept(_Last - _First)) 
        : _Mydata(::std:: to_address(_First)), _Mysize(static_cast<size_type>(_Last - _First)) {}
    

    template <class _Range>
        requires (!same_as<remove_cvref_t<_Range>, basic_string_view>
            && ::std::ranges:: contiguous_range<_Range>
            && ::std::ranges:: sized_range<_Range>
            && same_as<::std::ranges:: range_value_t<_Range>, _Elem>
            && (!is_convertible_v<_Range, const _Elem*>)
            && (!requires(remove_cvref_t<_Range>& _Rng) {
                _Rng.operator ::std:: basic_string_view<_Elem, _Traits>();
            })
            && (!requires {
                typename remove_reference_t<_Range>::traits_type;
            } || same_as<typename remove_reference_t<_Range>::traits_type, _Traits>))
    constexpr basic_string_view(_Range&& _Rng) noexcept(
        noexcept(::std::ranges:: data(_Rng)) && noexcept(::std::ranges:: size(_Rng))) 
        : _Mydata(::std::ranges:: data(_Rng)), _Mysize(static_cast<size_t>(::std::ranges:: size(_Rng))) {}
    
#line 1305 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
#line 1306 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    [[nodiscard]] constexpr const_iterator begin() const noexcept {


#line 1311 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        return const_iterator(_Mydata);
#line 1313 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
    }

    [[nodiscard]] constexpr const_iterator end() const noexcept {


#line 1319 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        return const_iterator(_Mydata + _Mysize);
#line 1321 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
    }

    [[nodiscard]] constexpr const_iterator cbegin() const noexcept {
        return begin();
    }

    [[nodiscard]] constexpr const_iterator cend() const noexcept {
        return end();
    }

    [[nodiscard]] constexpr const_reverse_iterator rbegin() const noexcept {
        return const_reverse_iterator{end()};
    }

    [[nodiscard]] constexpr const_reverse_iterator rend() const noexcept {
        return const_reverse_iterator{begin()};
    }

    [[nodiscard]] constexpr const_reverse_iterator crbegin() const noexcept {
        return rbegin();
    }

    [[nodiscard]] constexpr const_reverse_iterator crend() const noexcept {
        return rend();
    }

    constexpr const_pointer _Unchecked_begin() const noexcept {
        return _Mydata;
    }

    constexpr const_pointer _Unchecked_end() const noexcept {
        return _Mydata + _Mysize;
    }

    [[nodiscard]] constexpr size_type size() const noexcept {
        return _Mysize;
    }

    [[nodiscard]] constexpr size_type length() const noexcept {
        return _Mysize;
    }

    [[nodiscard]] constexpr bool empty() const noexcept {
        return _Mysize == 0;
    }

    [[nodiscard]] constexpr const_pointer data() const noexcept {
        return _Mydata;
    }

    [[nodiscard]] constexpr size_type max_size() const noexcept {
        
        
        return (::std:: min)(static_cast<size_t>(2147483647i32), static_cast<size_t>(-1) / sizeof(_Elem));
    }

    [[nodiscard]] constexpr const_reference operator[](const size_type _Off) const noexcept  {


#line 1381 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        return _Mydata[_Off];
    }

    [[nodiscard]] constexpr const_reference at(const size_type _Off) const {
        
        _Check_offset_exclusive(_Off);
        return _Mydata[_Off];
    }

    [[nodiscard]] constexpr const_reference front() const noexcept  {


#line 1394 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        return _Mydata[0];
    }

    [[nodiscard]] constexpr const_reference back() const noexcept  {


#line 1401 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        return _Mydata[_Mysize - 1];
    }

    constexpr void remove_prefix(const size_type _Count) noexcept  {


#line 1408 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        _Mydata += _Count;
        _Mysize -= _Count;
    }

    constexpr void remove_suffix(const size_type _Count) noexcept  {


#line 1416 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        _Mysize -= _Count;
    }

    constexpr void swap(basic_string_view& _Other) noexcept {
        const basic_string_view _Tmp{_Other}; 
        _Other = *this;
        *this  = _Tmp;
    }

    constexpr size_type copy(
          _Elem* const _Ptr, size_type _Count, const size_type _Off = 0) const {
        
        _Check_offset(_Off);
        _Count = _Clamp_suffix_size(_Off, _Count);
        _Traits::copy(_Ptr, _Mydata + _Off, _Count);
        return _Count;
    }

      constexpr size_type
        _Copy_s(  _Elem* const _Dest, const size_type _Dest_size, size_type _Count,
            const size_type _Off = 0) const {
        
        _Check_offset(_Off);
        _Count = _Clamp_suffix_size(_Off, _Count);
        _Traits::_Copy_s(_Dest, _Dest_size, _Mydata + _Off, _Count);
        return _Count;
    }

    [[nodiscard]] constexpr basic_string_view substr(const size_type _Off = 0, size_type _Count = npos) const {
        
        _Check_offset(_Off);
        _Count = _Clamp_suffix_size(_Off, _Count);
        return basic_string_view(_Mydata + _Off, _Count);
    }

    constexpr bool _Equal(const basic_string_view _Right) const noexcept {
        return _Traits_equal<_Traits>(_Mydata, _Mysize, _Right._Mydata, _Right._Mysize);
    }

    [[nodiscard]] constexpr int compare(const basic_string_view _Right) const noexcept {
        return _Traits_compare<_Traits>(_Mydata, _Mysize, _Right._Mydata, _Right._Mysize);
    }

    [[nodiscard]] constexpr int compare(const size_type _Off, const size_type _Nx, const basic_string_view _Right) const {
        
        return substr(_Off, _Nx).compare(_Right);
    }

    [[nodiscard]] constexpr int compare(const size_type _Off, const size_type _Nx, const basic_string_view _Right,
        const size_type _Roff, const size_type _Count) const {
        
        return substr(_Off, _Nx).compare(_Right.substr(_Roff, _Count));
    }

    [[nodiscard]] constexpr int compare(  const _Elem* const _Ptr) const { 
        return compare(basic_string_view(_Ptr));
    }

    [[nodiscard]] constexpr int compare(const size_type _Off, const size_type _Nx,   const _Elem* const _Ptr) const {
        
        return substr(_Off, _Nx).compare(basic_string_view(_Ptr));
    }

    [[nodiscard]] constexpr int compare(const size_type _Off, const size_type _Nx,
          const _Elem* const _Ptr, const size_type _Count) const {
        
        return substr(_Off, _Nx).compare(basic_string_view(_Ptr, _Count));
    }


    [[nodiscard]] constexpr bool starts_with(const basic_string_view _Right) const noexcept {
        const auto _Rightsize = _Right._Mysize;
        if (_Mysize < _Rightsize) {
            return false;
        }
        return _Traits::compare(_Mydata, _Right._Mydata, _Rightsize) == 0;
    }

    [[nodiscard]] constexpr bool starts_with(const _Elem _Right) const noexcept {
        return !empty() && _Traits::eq(front(), _Right);
    }

    [[nodiscard]] constexpr bool starts_with(const _Elem* const _Right) const noexcept  {
        return starts_with(basic_string_view(_Right));
    }

    [[nodiscard]] constexpr bool ends_with(const basic_string_view _Right) const noexcept {
        const auto _Rightsize = _Right._Mysize;
        if (_Mysize < _Rightsize) {
            return false;
        }
        return _Traits::compare(_Mydata + (_Mysize - _Rightsize), _Right._Mydata, _Rightsize) == 0;
    }

    [[nodiscard]] constexpr bool ends_with(const _Elem _Right) const noexcept {
        return !empty() && _Traits::eq(back(), _Right);
    }

    [[nodiscard]] constexpr bool ends_with(const _Elem* const _Right) const noexcept  {
        return ends_with(basic_string_view(_Right));
    }
#line 1518 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"


    [[nodiscard]] constexpr bool contains(const basic_string_view _Right) const noexcept {
        return find(_Right) != npos;
    }

    [[nodiscard]] constexpr bool contains(const _Elem _Right) const noexcept {
        return find(_Right) != npos;
    }

    [[nodiscard]] constexpr bool contains(const _Elem* const _Right) const noexcept  {
        return find(_Right) != npos;
    }
#line 1532 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    [[nodiscard]] constexpr size_type find(const basic_string_view _Right, const size_type _Off = 0) const noexcept {
        
        return _Traits_find<_Traits>(_Mydata, _Mysize, _Off, _Right._Mydata, _Right._Mysize);
    }

    [[nodiscard]] constexpr size_type find(const _Elem _Ch, const size_type _Off = 0) const noexcept {
        
        return _Traits_find_ch<_Traits>(_Mydata, _Mysize, _Off, _Ch);
    }

    [[nodiscard]] constexpr size_type find(  const _Elem* const _Ptr, const size_type _Off,
        const size_type _Count) const noexcept  {
        
        return _Traits_find<_Traits>(_Mydata, _Mysize, _Off, _Ptr, _Count);
    }

    [[nodiscard]] constexpr size_type find(  const _Elem* const _Ptr, const size_type _Off = 0) const noexcept
     {
        
        return _Traits_find<_Traits>(_Mydata, _Mysize, _Off, _Ptr, _Traits::length(_Ptr));
    }

    [[nodiscard]] constexpr size_type rfind(const basic_string_view _Right, const size_type _Off = npos) const noexcept {
        
        return _Traits_rfind<_Traits>(_Mydata, _Mysize, _Off, _Right._Mydata, _Right._Mysize);
    }

    [[nodiscard]] constexpr size_type rfind(const _Elem _Ch, const size_type _Off = npos) const noexcept {
        
        return _Traits_rfind_ch<_Traits>(_Mydata, _Mysize, _Off, _Ch);
    }

    [[nodiscard]] constexpr size_type rfind(  const _Elem* const _Ptr, const size_type _Off,
        const size_type _Count) const noexcept  {
        
        return _Traits_rfind<_Traits>(_Mydata, _Mysize, _Off, _Ptr, _Count);
    }

    [[nodiscard]] constexpr size_type rfind(  const _Elem* const _Ptr, const size_type _Off = npos) const noexcept
     {
        
        return _Traits_rfind<_Traits>(_Mydata, _Mysize, _Off, _Ptr, _Traits::length(_Ptr));
    }

    [[nodiscard]] constexpr size_type find_first_of(const basic_string_view _Right,
        const size_type _Off = 0) const noexcept { 
        return _Traits_find_first_of<_Traits>(
            _Mydata, _Mysize, _Off, _Right._Mydata, _Right._Mysize, _Is_specialization<_Traits, char_traits>{});
    }

    [[nodiscard]] constexpr size_type find_first_of(const _Elem _Ch, const size_type _Off = 0) const noexcept {
        
        return _Traits_find_ch<_Traits>(_Mydata, _Mysize, _Off, _Ch);
    }

    [[nodiscard]] constexpr size_type find_first_of(  const _Elem* const _Ptr, const size_type _Off,
        const size_type _Count) const noexcept  {
        
        return _Traits_find_first_of<_Traits>(
            _Mydata, _Mysize, _Off, _Ptr, _Count, _Is_specialization<_Traits, char_traits>{});
    }

    [[nodiscard]] constexpr size_type find_first_of(
          const _Elem* const _Ptr, const size_type _Off = 0) const noexcept  {
        
        return _Traits_find_first_of<_Traits>(
            _Mydata, _Mysize, _Off, _Ptr, _Traits::length(_Ptr), _Is_specialization<_Traits, char_traits>{});
    }

    [[nodiscard]] constexpr size_type find_last_of(const basic_string_view _Right,
        const size_type _Off = npos) const noexcept { 
        return _Traits_find_last_of<_Traits>(
            _Mydata, _Mysize, _Off, _Right._Mydata, _Right._Mysize, _Is_specialization<_Traits, char_traits>{});
    }

    [[nodiscard]] constexpr size_type find_last_of(const _Elem _Ch, const size_type _Off = npos) const noexcept {
        
        return _Traits_rfind_ch<_Traits>(_Mydata, _Mysize, _Off, _Ch);
    }

    [[nodiscard]] constexpr size_type find_last_of(  const _Elem* const _Ptr, const size_type _Off,
        const size_type _Count) const noexcept  {
        
        return _Traits_find_last_of<_Traits>(
            _Mydata, _Mysize, _Off, _Ptr, _Count, _Is_specialization<_Traits, char_traits>{});
    }

    [[nodiscard]] constexpr size_type find_last_of(
          const _Elem* const _Ptr, const size_type _Off = npos) const noexcept  {
        
        return _Traits_find_last_of<_Traits>(
            _Mydata, _Mysize, _Off, _Ptr, _Traits::length(_Ptr), _Is_specialization<_Traits, char_traits>{});
    }

    [[nodiscard]] constexpr size_type find_first_not_of(const basic_string_view _Right,
        const size_type _Off = 0) const noexcept { 
        return _Traits_find_first_not_of<_Traits>(
            _Mydata, _Mysize, _Off, _Right._Mydata, _Right._Mysize, _Is_specialization<_Traits, char_traits>{});
    }

    [[nodiscard]] constexpr size_type find_first_not_of(const _Elem _Ch, const size_type _Off = 0) const noexcept {
        
        return _Traits_find_not_ch<_Traits>(_Mydata, _Mysize, _Off, _Ch);
    }

    [[nodiscard]] constexpr size_type find_first_not_of(  const _Elem* const _Ptr, const size_type _Off,
        const size_type _Count) const noexcept  {
        
        return _Traits_find_first_not_of<_Traits>(
            _Mydata, _Mysize, _Off, _Ptr, _Count, _Is_specialization<_Traits, char_traits>{});
    }

    [[nodiscard]] constexpr size_type find_first_not_of(
          const _Elem* const _Ptr, const size_type _Off = 0) const noexcept  {
        
        return _Traits_find_first_not_of<_Traits>(
            _Mydata, _Mysize, _Off, _Ptr, _Traits::length(_Ptr), _Is_specialization<_Traits, char_traits>{});
    }

    [[nodiscard]] constexpr size_type find_last_not_of(const basic_string_view _Right,
        const size_type _Off = npos) const noexcept { 
        return _Traits_find_last_not_of<_Traits>(
            _Mydata, _Mysize, _Off, _Right._Mydata, _Right._Mysize, _Is_specialization<_Traits, char_traits>{});
    }

    [[nodiscard]] constexpr size_type find_last_not_of(const _Elem _Ch, const size_type _Off = npos) const noexcept {
        
        return _Traits_rfind_not_ch<_Traits>(_Mydata, _Mysize, _Off, _Ch);
    }

    [[nodiscard]] constexpr size_type find_last_not_of(  const _Elem* const _Ptr, const size_type _Off,
        const size_type _Count) const noexcept  {
        
        return _Traits_find_last_not_of<_Traits>(
            _Mydata, _Mysize, _Off, _Ptr, _Count, _Is_specialization<_Traits, char_traits>{});
    }

    [[nodiscard]] constexpr size_type find_last_not_of(
          const _Elem* const _Ptr, const size_type _Off = npos) const noexcept  {
        
        return _Traits_find_last_not_of<_Traits>(
            _Mydata, _Mysize, _Off, _Ptr, _Traits::length(_Ptr), _Is_specialization<_Traits, char_traits>{});
    }

    [[nodiscard]] constexpr bool _Starts_with(const basic_string_view _View) const noexcept {
        return _Mysize >= _View._Mysize && _Traits::compare(_Mydata, _View._Mydata, _View._Mysize) == 0;
    }

private:
    constexpr void _Check_offset(const size_type _Off) const { 
        if (_Mysize < _Off) {
            _Xran();
        }
    }

    constexpr void _Check_offset_exclusive(const size_type _Off) const {
        
        if (_Mysize <= _Off) {
            _Xran();
        }
    }

    constexpr size_type _Clamp_suffix_size(const size_type _Off, const size_type _Size) const noexcept {
        
        return (::std:: min)(_Size, _Mysize - _Off);
    }

    [[noreturn]] static void _Xran() {
        _Xout_of_range("invalid string_view position");
    }

    const_pointer _Mydata;
    size_type _Mysize;
};


template <contiguous_iterator _It, sized_sentinel_for<_It> _Se>
basic_string_view(_It, _Se) -> basic_string_view<iter_value_t<_It>>;


template <::std::ranges:: contiguous_range _Range>
basic_string_view(_Range&&) -> basic_string_view<::std::ranges:: range_value_t<_Range>>;
#line 1716 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

namespace ranges {
    template <class _Elem, class _Traits>
    inline constexpr bool enable_view<basic_string_view<_Elem, _Traits>> = true;
    template <class _Elem, class _Traits>
    inline constexpr bool enable_borrowed_range<basic_string_view<_Elem, _Traits>> = true;
} 
#line 1724 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

template <class _Elem, class _Traits>
[[nodiscard]] constexpr bool operator==(
    const basic_string_view<_Elem, _Traits> _Lhs, const basic_string_view<_Elem, _Traits> _Rhs) noexcept {
    return _Lhs._Equal(_Rhs);
}


#line 1738 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

template <class _Elem, class _Traits, int = 2> 
[[nodiscard]] constexpr bool operator==(
    const basic_string_view<_Elem, _Traits> _Lhs, const _Identity_t<basic_string_view<_Elem, _Traits>> _Rhs) noexcept {
    return _Lhs._Equal(_Rhs);
}


#line 1840 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"


template <class _Traits, class = void>
struct _Get_comparison_category {
    using type = weak_ordering;
};

template <class _Traits>
struct _Get_comparison_category<_Traits, void_t<typename _Traits::comparison_category>> {
    using type = typename _Traits::comparison_category;

    static_assert(_Is_any_of_v<type, partial_ordering, weak_ordering, strong_ordering>,
        "N4878 [string.view.comparison]/4: Mandates: R denotes a comparison category type.");
};

template <class _Traits>
using _Get_comparison_category_t = typename _Get_comparison_category<_Traits>::type;

template <class _Elem, class _Traits>
[[nodiscard]] constexpr _Get_comparison_category_t<_Traits> operator<=>(
    const basic_string_view<_Elem, _Traits> _Lhs, const basic_string_view<_Elem, _Traits> _Rhs) noexcept {
    return static_cast<_Get_comparison_category_t<_Traits>>(_Lhs.compare(_Rhs) <=> 0);
}

template <class _Elem, class _Traits, int = 2> 
[[nodiscard]] constexpr _Get_comparison_category_t<_Traits> operator<=>(
    const basic_string_view<_Elem, _Traits> _Lhs, const _Identity_t<basic_string_view<_Elem, _Traits>> _Rhs) noexcept {
    return static_cast<_Get_comparison_category_t<_Traits>>(_Lhs.compare(_Rhs) <=> 0);
}
#line 1870 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

using string_view = basic_string_view<char>;

using u8string_view = basic_string_view<char8_t>;
#line 1875 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
using u16string_view = basic_string_view<char16_t>;
using u32string_view = basic_string_view<char32_t>;
using wstring_view   = basic_string_view<wchar_t>;


template <class _Elem, class _Traits>
struct hash<basic_string_view<_Elem, _Traits>> {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef basic_string_view<_Elem, _Traits> _Unnameable_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef size_t _Unnameable_result;

    [[nodiscard]] size_t operator()(const basic_string_view<_Elem, _Traits> _Keyval) const noexcept {
        return _Hash_array_representation(_Keyval.data(), _Keyval.size());
    }
};

template <class _Elem, class _Traits>
basic_ostream<_Elem, _Traits>& operator<<(
    basic_ostream<_Elem, _Traits>& _Ostr, const basic_string_view<_Elem, _Traits> _Str) {
    return _Insert_string(_Ostr, _Str.data(), _Str.size());
}


inline namespace literals {
    inline namespace string_view_literals {
        [[nodiscard]] constexpr string_view operator"" sv(const char* _Str, size_t _Len) noexcept {
            return string_view(_Str, _Len);
        }

        [[nodiscard]] constexpr wstring_view operator"" sv(const wchar_t* _Str, size_t _Len) noexcept {
            return wstring_view(_Str, _Len);
        }


        [[nodiscard]] constexpr basic_string_view<char8_t> operator"" sv(const char8_t* _Str, size_t _Len) noexcept {
            return basic_string_view<char8_t>(_Str, _Len);
        }
#line 1912 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

        [[nodiscard]] constexpr u16string_view operator"" sv(const char16_t* _Str, size_t _Len) noexcept {
            return u16string_view(_Str, _Len);
        }

        [[nodiscard]] constexpr u32string_view operator"" sv(const char32_t* _Str, size_t _Len) noexcept {
            return u32string_view(_Str, _Len);
        }
    } 
} 
#line 1923 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

template <class _Mystr>
class _String_const_iterator : public _Iterator_base {
public:

    using iterator_concept = contiguous_iterator_tag;
#line 1930 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
    using iterator_category = random_access_iterator_tag;
    using value_type        = typename _Mystr::value_type;
    using difference_type   = typename _Mystr::difference_type;
    using pointer           = typename _Mystr::const_pointer;
    using reference         = const value_type&;

    constexpr _String_const_iterator() noexcept : _Ptr() {}

    constexpr _String_const_iterator(pointer _Parg, const _Container_base* _Pstring) noexcept : _Ptr(_Parg) {
        this->_Adopt(_Pstring);
    }

    [[nodiscard]] constexpr reference operator*() const noexcept {


#line 1953 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

        ;
        return *_Ptr;
    }

    [[nodiscard]] constexpr pointer operator->() const noexcept {
        return pointer_traits<pointer>::pointer_to(**this);
    }

    constexpr _String_const_iterator& operator++() noexcept {


#line 1970 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

        ++_Ptr;
        return *this;
    }

    constexpr _String_const_iterator operator++(int) noexcept {
        _String_const_iterator _Tmp = *this;
        ++*this;
        return _Tmp;
    }

    constexpr _String_const_iterator& operator--() noexcept {


#line 1989 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

        --_Ptr;
        return *this;
    }

    constexpr _String_const_iterator operator--(int) noexcept {
        _String_const_iterator _Tmp = *this;
        --*this;
        return _Tmp;
    }

    constexpr void _Verify_offset(const difference_type _Off) const noexcept {


#line 2023 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        (void) _Off;
#line 2025 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
    }

    constexpr _String_const_iterator& operator+=(const difference_type _Off) noexcept {


#line 2031 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        _Ptr += _Off;
        return *this;
    }

    [[nodiscard]] constexpr _String_const_iterator operator+(const difference_type _Off) const noexcept {
        _String_const_iterator _Tmp = *this;
        _Tmp += _Off;
        return _Tmp;
    }

    constexpr _String_const_iterator& operator-=(const difference_type _Off) noexcept {
        return *this += -_Off;
    }

    [[nodiscard]] constexpr _String_const_iterator operator-(const difference_type _Off) const noexcept {
        _String_const_iterator _Tmp = *this;
        _Tmp -= _Off;
        return _Tmp;
    }

    [[nodiscard]] constexpr difference_type operator-(const _String_const_iterator& _Right) const noexcept {
        _Compat(_Right);
        return _Ptr - _Right._Ptr;
    }

    [[nodiscard]] constexpr reference operator[](const difference_type _Off) const noexcept {
        return *(*this + _Off);
    }

    [[nodiscard]] constexpr bool operator==(const _String_const_iterator& _Right) const noexcept {
        _Compat(_Right);
        return _Ptr == _Right._Ptr;
    }


    [[nodiscard]] constexpr strong_ordering operator<=>(const _String_const_iterator& _Right) const noexcept {
        _Compat(_Right);
        return _Unfancy(_Ptr) <=> _Unfancy(_Right._Ptr);
    }


#line 2092 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    constexpr void _Compat(const _String_const_iterator& _Right) const noexcept {
        

#line 2099 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        (void) _Right;
#line 2101 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
    }


#line 2110 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    using _Prevent_inheriting_unwrap = _String_const_iterator;

    [[nodiscard]] constexpr const value_type* _Unwrapped() const noexcept {
        return _Unfancy(_Ptr);
    }

    constexpr void _Seek_to(const value_type* _It) noexcept {
        _Ptr = _Refancy<pointer>(const_cast<value_type*>(_It));
    }

    pointer _Ptr; 
};

template <class _Mystr>
[[nodiscard]] constexpr _String_const_iterator<_Mystr> operator+(
    typename _String_const_iterator<_Mystr>::difference_type _Off, _String_const_iterator<_Mystr> _Next) noexcept {
    _Next += _Off;
    return _Next;
}


template <class _Mystr>
struct pointer_traits<_String_const_iterator<_Mystr>> {
    using pointer         = _String_const_iterator<_Mystr>;
    using element_type    = const typename pointer::value_type;
    using difference_type = typename pointer::difference_type;

    [[nodiscard]] static constexpr element_type* to_address(const pointer _Iter) noexcept {


#line 2146 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

        const auto _Rawptr = ::std:: to_address(_Iter._Ptr);


#line 2156 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

        return _Rawptr;
    }
};
#line 2161 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

template <class _Mystr>
class _String_iterator : public _String_const_iterator<_Mystr> {
public:
    using _Mybase = _String_const_iterator<_Mystr>;


    using iterator_concept = contiguous_iterator_tag;
#line 2170 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
    using iterator_category = random_access_iterator_tag;
    using value_type        = typename _Mystr::value_type;
    using difference_type   = typename _Mystr::difference_type;
    using pointer           = typename _Mystr::pointer;
    using reference         = value_type&;

    using _Mybase::_Mybase;

    [[nodiscard]] constexpr reference operator*() const noexcept {
        return const_cast<reference>(_Mybase::operator*());
    }

    [[nodiscard]] constexpr pointer operator->() const noexcept {
        return pointer_traits<pointer>::pointer_to(**this);
    }

    constexpr _String_iterator& operator++() noexcept {
        _Mybase::operator++();
        return *this;
    }

    constexpr _String_iterator operator++(int) noexcept {
        _String_iterator _Tmp = *this;
        _Mybase::operator++();
        return _Tmp;
    }

    constexpr _String_iterator& operator--() noexcept {
        _Mybase::operator--();
        return *this;
    }

    constexpr _String_iterator operator--(int) noexcept {
        _String_iterator _Tmp = *this;
        _Mybase::operator--();
        return _Tmp;
    }

    constexpr _String_iterator& operator+=(const difference_type _Off) noexcept {
        _Mybase::operator+=(_Off);
        return *this;
    }

    [[nodiscard]] constexpr _String_iterator operator+(const difference_type _Off) const noexcept {
        _String_iterator _Tmp = *this;
        _Tmp += _Off;
        return _Tmp;
    }

    constexpr _String_iterator& operator-=(const difference_type _Off) noexcept {
        _Mybase::operator-=(_Off);
        return *this;
    }

    using _Mybase::operator-;

    [[nodiscard]] constexpr _String_iterator operator-(const difference_type _Off) const noexcept {
        _String_iterator _Tmp = *this;
        _Tmp -= _Off;
        return _Tmp;
    }

    [[nodiscard]] constexpr reference operator[](const difference_type _Off) const noexcept {
        return const_cast<reference>(_Mybase::operator[](_Off));
    }

    using _Prevent_inheriting_unwrap = _String_iterator;

    [[nodiscard]] constexpr value_type* _Unwrapped() const noexcept {
        return const_cast<value_type*>(_Unfancy(this->_Ptr));
    }
};

template <class _Mystr>
[[nodiscard]] constexpr _String_iterator<_Mystr> operator+(
    typename _String_iterator<_Mystr>::difference_type _Off, _String_iterator<_Mystr> _Next) noexcept {
    _Next += _Off;
    return _Next;
}


template <class _Mystr>
struct pointer_traits<_String_iterator<_Mystr>> {
    using pointer         = _String_iterator<_Mystr>;
    using element_type    = typename pointer::value_type;
    using difference_type = typename pointer::difference_type;

    [[nodiscard]] static constexpr element_type* to_address(const pointer _Iter) noexcept {


#line 2265 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

        const auto _Rawptr = ::std:: to_address(_Iter._Ptr);


#line 2275 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

        return const_cast<element_type*>(_Rawptr);
    }
};
#line 2280 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

template <class _Value_type, class _Size_type, class _Difference_type, class _Pointer, class _Const_pointer,
    class _Reference, class _Const_reference>
struct _String_iter_types {
    using value_type      = _Value_type;
    using size_type       = _Size_type;
    using difference_type = _Difference_type;
    using pointer         = _Pointer;
    using const_pointer   = _Const_pointer;
};

template <class _Val_types>
class _String_val : public _Container_base {
public:
    using value_type      = typename _Val_types::value_type;
    using size_type       = typename _Val_types::size_type;
    using difference_type = typename _Val_types::difference_type;
    using pointer         = typename _Val_types::pointer;
    using const_pointer   = typename _Val_types::const_pointer;
    using reference       = value_type&;
    using const_reference = const value_type&;

    constexpr _String_val() noexcept : _Bx() {}

    
    static constexpr size_type _BUF_SIZE = 16 / sizeof(value_type) < 1 ? 1 : 16 / sizeof(value_type);
    
    static constexpr size_type _ALLOC_MASK = sizeof(value_type) <= 1 ? 15
                                           : sizeof(value_type) <= 2 ? 7
                                           : sizeof(value_type) <= 4 ? 3
                                           : sizeof(value_type) <= 8 ? 1
                                                                     : 0;

    constexpr value_type* _Myptr() noexcept {
        value_type* _Result = _Bx._Buf;
        if (_Large_string_engaged()) {
            _Result = _Unfancy(_Bx._Ptr);
        }

        return _Result;
    }

    constexpr const value_type* _Myptr() const noexcept {
        const value_type* _Result = _Bx._Buf;
        if (_Large_string_engaged()) {
            _Result = _Unfancy(_Bx._Ptr);
        }

        return _Result;
    }

    constexpr bool _Large_string_engaged() const noexcept {

        if (::std:: is_constant_evaluated()) {
            return true;
        }
#line 2337 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        return _BUF_SIZE <= _Myres;
    }

    constexpr void _Check_offset(const size_type _Off) const {
        
        if (_Mysize < _Off) {
            _Xran();
        }
    }

    constexpr void _Check_offset_exclusive(const size_type _Off) const {
        
        if (_Mysize <= _Off) {
            _Xran();
        }
    }

    [[noreturn]] static void _Xran() {
        _Xout_of_range("invalid string position");
    }

    constexpr size_type _Clamp_suffix_size(const size_type _Off, const size_type _Size) const noexcept {
        
        return (::std:: min)(_Size, _Mysize - _Off);
    }

    union _Bxty { 
        constexpr _Bxty() noexcept : _Ptr() {} 

        constexpr ~_Bxty() noexcept {} 

        value_type _Buf[_BUF_SIZE];
        pointer _Ptr;
        char _Alias[_BUF_SIZE]; 
    } _Bx;

    size_type _Mysize = 0; 
    size_type _Myres  = 0; 
};

template <class _Ty>
constexpr size_t _Size_after_ebco_v = is_empty_v<_Ty> ? 0 : sizeof(_Ty); 

struct _String_constructor_concat_tag {
    
    explicit _String_constructor_concat_tag() = default;
};

struct _String_constructor_rvalue_allocator_tag {
    
    explicit _String_constructor_rvalue_allocator_tag() = default;
};

[[noreturn]] inline void _Xlen_string() {
    _Xlength_error("string too long");
}

template <class _Elem, class _Traits = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
class basic_string { 
private:
    friend _Tidy_deallocate_guard<basic_string>;
    friend basic_stringbuf<_Elem, _Traits, _Alloc>;

    using _Alty        = _Rebind_alloc_t<_Alloc, _Elem>;
    using _Alty_traits = allocator_traits<_Alty>;

    using _Scary_val = _String_val<conditional_t<_Is_simple_alloc_v<_Alty>, _Simple_types<_Elem>,
        _String_iter_types<_Elem, typename _Alty_traits::size_type, typename _Alty_traits::difference_type,
            typename _Alty_traits::pointer, typename _Alty_traits::const_pointer, _Elem&, const _Elem&>>>;

    static_assert(!1 || is_same_v<_Elem, typename _Alloc::value_type>,
        "basic_string<T, Traits, Allocator>" " requires that Allocator's value_type match " "T" " (See N4659 26.2.1 [container.requirements.general]/16 allocator_type)" " Either fix the allocator value_type or define _ENFORCE_MATCHING_ALLOCATORS=0" " to suppress this diagnostic.");

    static_assert(is_same_v<_Elem, typename _Traits::char_type>,
        "N4659 24.3.2.1 [string.require]/3 requires that the supplied "
        "char_traits character type match the string's character type.");

    static_assert(!is_array_v<_Elem> && is_trivial_v<_Elem> && is_standard_layout_v<_Elem>,
        "The character type of basic_string must be a non-array trivial standard-layout type. See N4861 "
        "[strings.general]/1.");

public:
    using traits_type    = _Traits;
    using allocator_type = _Alloc;

    using value_type      = _Elem;
    using size_type       = typename _Alty_traits::size_type;
    using difference_type = typename _Alty_traits::difference_type;
    using pointer         = typename _Alty_traits::pointer;
    using const_pointer   = typename _Alty_traits::const_pointer;
    using reference       = value_type&;
    using const_reference = const value_type&;

    using iterator       = _String_iterator<_Scary_val>;
    using const_iterator = _String_const_iterator<_Scary_val>;

    using reverse_iterator       = ::std:: reverse_iterator<iterator>;
    using const_reverse_iterator = ::std:: reverse_iterator<const_iterator>;

private:
    static constexpr auto _BUF_SIZE   = _Scary_val::_BUF_SIZE;
    static constexpr auto _ALLOC_MASK = _Scary_val::_ALLOC_MASK;

    
    static constexpr bool _Can_memcpy_val = _Is_specialization_v<_Traits, char_traits> && is_trivial_v<pointer>;
    
    static constexpr size_t _Memcpy_val_offset = _Size_after_ebco_v<_Container_base>;
    static constexpr size_t _Memcpy_val_size   = sizeof(_Scary_val) - _Memcpy_val_offset;

    template <class _Iter>
    using _Is_elem_cptr = bool_constant<_Is_any_of_v<_Iter, const _Elem* const, _Elem* const, const _Elem*, _Elem*>>;


    template <class _StringViewIsh>
    using _Is_string_view_ish =
        enable_if_t<conjunction_v<is_convertible<const _StringViewIsh&, basic_string_view<_Elem, _Traits>>,
                        negation<is_convertible<const _StringViewIsh&, const _Elem*>>>,
            int>;
#line 2465 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

public:
    constexpr basic_string(const basic_string& _Right)
        : _Mypair(_One_then_variadic_args_t{}, _Alty_traits::select_on_container_copy_construction(_Right._Getal())) {
        auto&& _Alproxy = _Fake_alloc;
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
        _Construct_lv_contents(_Right);
        _Proxy._Release();
    }

    constexpr basic_string(const basic_string& _Right, const _Alloc& _Al)
        : _Mypair(_One_then_variadic_args_t{}, _Al) {
        auto&& _Alproxy = _Fake_alloc;
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
        _Construct_lv_contents(_Right);
        _Proxy._Release();
    }

    constexpr basic_string() noexcept(is_nothrow_default_constructible_v<_Alty>)
        : _Mypair(_Zero_then_variadic_args_t{}) {
        _Mypair._Myval2._Alloc_proxy(_Fake_alloc);
        _Tidy_init();
    }

    constexpr explicit basic_string(const _Alloc& _Al) noexcept : _Mypair(_One_then_variadic_args_t{}, _Al) {
        _Mypair._Myval2._Alloc_proxy(_Fake_alloc);
        _Tidy_init();
    }

    constexpr basic_string(const basic_string& _Right, const size_type _Roff, const _Alloc& _Al = _Alloc())
        : _Mypair(_One_then_variadic_args_t{}, _Al) { 
        auto&& _Alproxy = _Fake_alloc;
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
        _Tidy_init();
        assign(_Right, _Roff, npos);
        _Proxy._Release();
    }

    constexpr basic_string(
        const basic_string& _Right, const size_type _Roff, const size_type _Count, const _Alloc& _Al = _Alloc())
        : _Mypair(_One_then_variadic_args_t{}, _Al) { 
        auto&& _Alproxy = _Fake_alloc;
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
        _Tidy_init();
        assign(_Right, _Roff, _Count);
        _Proxy._Release();
    }

    constexpr basic_string(  const _Elem* const _Ptr,  const size_type _Count)
        : _Mypair(_Zero_then_variadic_args_t{}) {
        auto&& _Alproxy = _Fake_alloc;
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
        _Tidy_init();
        assign(_Ptr, _Count);
        _Proxy._Release();
    }

    constexpr basic_string(
          const _Elem* const _Ptr,  const size_type _Count, const _Alloc& _Al)
        : _Mypair(_One_then_variadic_args_t{}, _Al) {
        auto&& _Alproxy = _Fake_alloc;
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
        _Tidy_init();
        assign(_Ptr, _Count);
        _Proxy._Release();
    }

    constexpr basic_string(  const _Elem* const _Ptr) : _Mypair(_Zero_then_variadic_args_t{}) {
        auto&& _Alproxy = _Fake_alloc;
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
        _Tidy_init();
        assign(_Ptr);
        _Proxy._Release();
    }


    basic_string(nullptr_t) = delete;
#line 2543 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"


    template <class _Alloc2 = _Alloc, enable_if_t<_Is_allocator<_Alloc2>::value, int> = 0>
#line 2547 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
    constexpr basic_string(  const _Elem* const _Ptr, const _Alloc& _Al)
        : _Mypair(_One_then_variadic_args_t{}, _Al) {
        auto&& _Alproxy = _Fake_alloc;
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
        _Tidy_init();
        assign(_Ptr);
        _Proxy._Release();
    }

    constexpr basic_string( const size_type _Count, const _Elem _Ch)
        : _Mypair(_Zero_then_variadic_args_t{}) {
        
        auto&& _Alproxy = _Fake_alloc;
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
        _Tidy_init();
        assign(_Count, _Ch);
        _Proxy._Release();
    }


    template <class _Alloc2 = _Alloc, enable_if_t<_Is_allocator<_Alloc2>::value, int> = 0>
#line 2569 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
    constexpr basic_string( const size_type _Count, const _Elem _Ch, const _Alloc& _Al)
        : _Mypair(_One_then_variadic_args_t{}, _Al) { 
        auto&& _Alproxy = _Fake_alloc;
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
        _Tidy_init();
        assign(_Count, _Ch);
        _Proxy._Release();
    }

    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
    constexpr basic_string(_Iter _First, _Iter _Last, const _Alloc& _Al = _Alloc())
        : _Mypair(_One_then_variadic_args_t{}, _Al) {
        auto&& _Alproxy = _Fake_alloc;
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
        _Tidy_init();
        _Adl_verify_range(_First, _Last);
        auto _UFirst      = _Get_unwrapped(_First);
        const auto _ULast = _Get_unwrapped(_Last);

        if constexpr (is_same_v<remove_const_t<remove_pointer_t<decltype(_UFirst)>>, _Elem>) {
            if (_UFirst != _ULast) {
                assign(_UFirst, _Convert_size<size_type>(static_cast<size_t>(_ULast - _UFirst)));
            }
        } else {
            if constexpr (_Is_fwd_iter_v<_Iter>) {
                const auto _Count = _Convert_size<size_type>(static_cast<size_t>(::std:: distance(_UFirst, _ULast)));
                reserve(_Count);
            } else {
                static_assert(_Is_input_iter_v<_Iter>, "Should be at least input iterator");
            }

            
            _Tidy_deallocate_guard<basic_string> _Guard{this};
            for (; _UFirst != _ULast; ++_UFirst) {
                push_back(*_UFirst);
            }

            _Guard._Target = nullptr;
        }

        _Proxy._Release();
    }

    constexpr basic_string(basic_string&& _Right) noexcept
        : _Mypair(_One_then_variadic_args_t{}, ::std:: move(_Right._Getal())) {
        _Mypair._Myval2._Alloc_proxy(_Fake_alloc);
        _Take_contents(_Right);
    }

    constexpr basic_string(basic_string&& _Right, const _Alloc& _Al) noexcept(
        _Alty_traits::is_always_equal::value) 
        : _Mypair(_One_then_variadic_args_t{}, _Al) {
        auto&& _Alproxy = _Fake_alloc;
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
        if constexpr (!_Alty_traits::is_always_equal::value) {
            if (_Getal() != _Right._Getal()) {
                _Construct_lv_contents(_Right);
                _Proxy._Release();
                return;
            }
        }

        _Take_contents(_Right);
        _Proxy._Release();
    }

    constexpr basic_string(_String_constructor_concat_tag, const basic_string& _Source_of_al,
        const _Elem* const _Left_ptr, const size_type _Left_size, const _Elem* const _Right_ptr,
        const size_type _Right_size)
        : _Mypair(
            _One_then_variadic_args_t{}, _Alty_traits::select_on_container_copy_construction(_Source_of_al._Getal())) {
        ;
        ;
        ;
        const auto _New_size    = static_cast<size_type>(_Left_size + _Right_size);
        size_type _New_capacity = _BUF_SIZE - 1;
        auto& _My_data          = _Mypair._Myval2;
        _Elem* _Ptr             = _My_data._Bx._Buf;
        auto&& _Alproxy         = _Fake_alloc;
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _My_data); 


        const bool _Activate_large_mode = _New_capacity < _New_size || ::std:: is_constant_evaluated();


#line 2655 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

        if (_Activate_large_mode) {
            
            const size_type _Requested_size = (::std:: max)(_New_size, _BUF_SIZE);
            _New_capacity                   = _Calculate_growth(_Requested_size, _BUF_SIZE - 1, max_size());
            const pointer _Fancyptr         = _Getal().allocate(_New_capacity + 1); 
            _Ptr                            = _Unfancy(_Fancyptr);
            _Construct_in_place(_My_data._Bx._Ptr, _Fancyptr);
        }


        if (::std:: is_constant_evaluated()) { 
            _Traits::assign(_Ptr, _New_capacity + 1, _Elem());
        }
#line 2670 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

        _My_data._Mysize = _New_size;
        _My_data._Myres  = _New_capacity;
        _Traits::copy(_Ptr, _Left_ptr, _Left_size);
        _Traits::copy(_Ptr + static_cast<ptrdiff_t>(_Left_size), _Right_ptr, _Right_size);
        _Traits::assign(_Ptr[_New_size], _Elem());
        _Proxy._Release();
    }

    constexpr basic_string(_String_constructor_concat_tag, basic_string& _Left, basic_string& _Right)
        : _Mypair(_One_then_variadic_args_t{}, _Left._Getal()) {
        auto& _My_data    = _Mypair._Myval2;
        auto& _Left_data  = _Left._Mypair._Myval2;
        auto& _Right_data = _Right._Mypair._Myval2;
        _Left_data._Orphan_all();
        _Right_data._Orphan_all();
        const auto _Left_size  = _Left_data._Mysize;
        const auto _Right_size = _Right_data._Mysize;

        const auto _Left_capacity  = _Left_data._Myres;
        const auto _Right_capacity = _Right_data._Myres;
        
        const auto _New_size     = static_cast<size_type>(_Left_size + _Right_size);
        const bool _Fits_in_left = _Right_size <= _Left_capacity - _Left_size;
        if (_Fits_in_left && _Right_capacity <= _Left_capacity) {
            
            _My_data._Alloc_proxy(_Fake_alloc); 
            _Take_contents(_Left);
            const auto _Ptr = _My_data._Myptr();
            _Traits::copy(_Ptr + _Left_size, _Right_data._Myptr(), _Right_size + 1);
            _My_data._Mysize = _New_size;
            return;
        }

        const bool _Fits_in_right = _Left_size <= _Right_capacity - _Right_size;
        if (_Allocators_equal(_Getal(), _Right._Getal()) && _Fits_in_right) {
            
            
            ;
            _My_data._Alloc_proxy(_Fake_alloc); 
            _Take_contents(_Right);
            const auto _Ptr = _Unfancy(_My_data._Bx._Ptr);
            _Traits::move(_Ptr + _Left_size, _Ptr, _Right_size + 1);
            _Traits::copy(_Ptr, _Left_data._Myptr(), _Left_size);
            _My_data._Mysize = _New_size;
            return;
        }

        
        const auto _Max = max_size();
        if (_Max - _Left_size < _Right_size) { 
            _Xlen_string();
        }

        const auto _New_capacity = _Calculate_growth(_New_size, _BUF_SIZE - 1, _Max);
        auto&& _Alproxy          = _Fake_alloc;
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _My_data); 
        const pointer _Fancyptr = _Getal().allocate(_New_capacity + 1); 
        

        if (::std:: is_constant_evaluated()) { 
            _Traits::assign(_Unfancy(_Fancyptr), _New_capacity + 1, _Elem());
        }
#line 2741 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        _Construct_in_place(_My_data._Bx._Ptr, _Fancyptr);
        _My_data._Mysize = _New_size;
        _My_data._Myres  = _New_capacity;
        const auto _Ptr  = _Unfancy(_Fancyptr);
        _Traits::copy(_Ptr, _Left_data._Myptr(), _Left_size);
        _Traits::copy(_Ptr + _Left_size, _Right_data._Myptr(), _Right_size + 1);
        _Proxy._Release();
    }


    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
    constexpr explicit basic_string(const _StringViewIsh& _Right, const _Alloc& _Al = _Alloc())
        : _Mypair(_One_then_variadic_args_t{}, _Al) {
        auto&& _Alproxy = _Fake_alloc;
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
        _Tidy_init();
        assign(_Right);
        _Proxy._Release();
    }

    template <class _Ty, enable_if_t<is_convertible_v<const _Ty&, basic_string_view<_Elem, _Traits>>, int> = 0>
    constexpr basic_string(
        const _Ty& _Right, const size_type _Roff, const size_type _Count, const _Alloc& _Al = _Alloc())
        : _Mypair(_One_then_variadic_args_t{}, _Al) {
        
        auto&& _Alproxy = _Fake_alloc;
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
        _Tidy_init();
        assign(_Right, _Roff, _Count);
        _Proxy._Release();
    }
#line 2773 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"


    basic_string(_String_constructor_rvalue_allocator_tag, _Alloc&& _Al)
        : _Mypair(_One_then_variadic_args_t{}, ::std:: move(_Al)) {
        
        _Mypair._Myval2._Alloc_proxy(_Fake_alloc);
        _Tidy_init();
    }

    [[nodiscard]] bool _Move_assign_from_buffer(_Elem* const _Right, const size_type _Size, const size_type _Res) {
        
        _Tidy_deallocate();
        pointer _Fancy_right = _Refancy<pointer>(_Right);
        auto& _My_data       = _Mypair._Myval2;
        _My_data._Mysize     = _Size;
        _My_data._Myres      = _Res - 1;
        if (_My_data._Large_string_engaged()) {
            _Construct_in_place(_My_data._Bx._Ptr, _Fancy_right);
            return true;
        } else {
            _Traits::copy(_My_data._Bx._Buf, _Right, _Res);
            _My_data._Myres = _BUF_SIZE - 1;
            return false;
        }
    }

    
    struct _Released_buffer {
        pointer _Ptr;
        size_type _Size;
        size_type _Res;
    };

    [[nodiscard]] _Released_buffer _Release_to_buffer(_Alloc& _Al) {
        
        _Released_buffer _Result;
        auto& _My_data = _Mypair._Myval2;
        _Result._Size  = _My_data._Mysize;
        if (_My_data._Large_string_engaged()) {
            _Result._Ptr = _My_data._Bx._Ptr;
            _Result._Res = _My_data._Myres + 1;
        } else {
            
            _Result._Ptr = _Al.allocate(_BUF_SIZE + 1);
            _Traits::copy(_Unfancy(_Result._Ptr), _My_data._Bx._Buf, _BUF_SIZE);
            _Result._Res = _BUF_SIZE + 1;
        }
        _My_data._Orphan_all();
        _Tidy_init();
        return _Result;
    }
#line 2825 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    constexpr basic_string& operator=(basic_string&& _Right) noexcept(
        _Choose_pocma_v<_Alty> != _Pocma_values::_No_propagate_allocators) {
        if (this == ::std:: addressof(_Right)) {
            return *this;
        }

        auto& _Al                 = _Getal();
        auto& _Right_al           = _Right._Getal();
        constexpr auto _Pocma_val = _Choose_pocma_v<_Alty>;
        if constexpr (_Pocma_val == _Pocma_values::_Propagate_allocators) {
            if (_Al != _Right_al) {
                
                _Mypair._Myval2._Orphan_all();
                _Mypair._Myval2._Reload_proxy(_Fake_alloc, _Fake_alloc);
            }
        } else if constexpr (_Pocma_val == _Pocma_values::_No_propagate_allocators) {
            if (_Al != _Right_al) {
                assign(_Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
                return *this;
            }
        }

        _Tidy_deallocate();
        _Pocma(_Al, _Right_al);
        _Take_contents(_Right);
        return *this;
    }

    constexpr basic_string& assign(basic_string&& _Right) noexcept(noexcept(*this = ::std:: move(_Right))) {
        *this = ::std:: move(_Right);
        return *this;
    }

private:
    void _Memcpy_val_from(const basic_string& _Right) noexcept {
        ;
        const auto _My_data_mem =
            reinterpret_cast<unsigned char*>(::std:: addressof(_Mypair._Myval2)) + _Memcpy_val_offset;
        const auto _Right_data_mem =
            reinterpret_cast<const unsigned char*>(::std:: addressof(_Right._Mypair._Myval2)) + _Memcpy_val_offset;
        :: memcpy(_My_data_mem, _Right_data_mem, _Memcpy_val_size);
    }

    constexpr void _Take_contents(basic_string& _Right) noexcept {
        
        
        auto& _My_data    = _Mypair._Myval2;
        auto& _Right_data = _Right._Mypair._Myval2;

        if constexpr (_Can_memcpy_val) {

            if (!::std:: is_constant_evaluated())
#line 2882 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
            {


#line 2891 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

                _Memcpy_val_from(_Right);
                _Right._Tidy_init();
                return;
            }
        }

        if (_Right_data._Large_string_engaged()) { 
            _Construct_in_place(_My_data._Bx._Ptr, _Right_data._Bx._Ptr);
            _Right_data._Bx._Ptr = nullptr;
            _Swap_proxy_and_iterators(_Right);
        } else { 
            _Traits::copy(_My_data._Bx._Buf, _Right_data._Bx._Buf, _Right_data._Mysize + 1);
            _Right_data._Orphan_all();
        }

        _My_data._Mysize = _Right_data._Mysize;
        _My_data._Myres  = _Right_data._Myres;
        _Right._Tidy_init();
    }

    constexpr void _Construct_lv_contents(const basic_string& _Right) {
        
        
        auto& _Right_data             = _Right._Mypair._Myval2;
        const size_type _Right_size   = _Right_data._Mysize;
        const _Elem* const _Right_ptr = _Right_data._Myptr();
        auto& _My_data                = _Mypair._Myval2;


        const bool _Stay_small = _Right_size < _BUF_SIZE && !::std:: is_constant_evaluated();


#line 2927 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

        
        if (_Stay_small) { 
            _Traits::copy(_My_data._Bx._Buf, _Right_ptr, _BUF_SIZE);
            _My_data._Mysize = _Right_size;
            _My_data._Myres  = _BUF_SIZE - 1;
            return;
        }

        auto& _Al                     = _Getal();
        const size_type _New_capacity = (::std:: min)(_Right_size | _ALLOC_MASK, max_size());
        const pointer _New_array      = _Al.allocate(_New_capacity + 1); 
        _Construct_in_place(_My_data._Bx._Ptr, _New_array);


        if (::std:: is_constant_evaluated()) { 
            _Traits::assign(_Unfancy(_New_array), _New_capacity + 1, _Elem());
        }
#line 2947 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        _Traits::copy(_Unfancy(_New_array), _Right_ptr, _Right_size + 1);
        _My_data._Mysize = _Right_size;
        _My_data._Myres  = _New_capacity;
    }

public:
    constexpr basic_string(initializer_list<_Elem> _Ilist, const _Alloc& _Al = allocator_type())
        : _Mypair(_One_then_variadic_args_t{}, _Al) {
        auto&& _Alproxy = _Fake_alloc;
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
        _Tidy_init();
        assign(_Ilist.begin(), _Convert_size<size_type>(_Ilist.size()));
        _Proxy._Release();
    }

    constexpr basic_string& operator=(initializer_list<_Elem> _Ilist) {
        return assign(_Ilist.begin(), _Convert_size<size_type>(_Ilist.size()));
    }

    constexpr basic_string& operator+=(initializer_list<_Elem> _Ilist) {
        return append(_Ilist.begin(), _Convert_size<size_type>(_Ilist.size()));
    }

    constexpr basic_string& assign(initializer_list<_Elem> _Ilist) {
        return assign(_Ilist.begin(), _Convert_size<size_type>(_Ilist.size()));
    }

    constexpr basic_string& append(initializer_list<_Elem> _Ilist) {
        return append(_Ilist.begin(), _Convert_size<size_type>(_Ilist.size()));
    }

    constexpr iterator insert(const const_iterator _Where, const initializer_list<_Elem> _Ilist) {


#line 2982 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        const auto _Off = static_cast<size_type>(_Unfancy(_Where._Ptr) - _Mypair._Myval2._Myptr());
        insert(_Off, _Ilist.begin(), _Convert_size<size_type>(_Ilist.size()));
        return begin() + static_cast<difference_type>(_Off);
    }

    constexpr basic_string& replace(
        const const_iterator _First, const const_iterator _Last, const initializer_list<_Elem> _Ilist) {
        
        _Adl_verify_range(_First, _Last);


#line 2994 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        const auto _Offset = static_cast<size_type>(_Unfancy(_First._Ptr) - _Mypair._Myval2._Myptr());
        const auto _Length = static_cast<size_type>(_Last._Ptr - _First._Ptr);
        return replace(_Offset, _Length, _Ilist.begin(), _Convert_size<size_type>(_Ilist.size()));
    }

    constexpr ~basic_string() noexcept {
        _Tidy_deallocate();


#line 3007 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
    }

    static constexpr auto npos{static_cast<size_type>(-1)};

private:
    void _Copy_assign_val_from_small(const basic_string& _Right) {
        

        ;
#line 3017 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        _Tidy_deallocate();
        if constexpr (_Can_memcpy_val) {
            _Memcpy_val_from(_Right);
        } else {
            auto& _My_data    = _Mypair._Myval2;
            auto& _Right_data = _Right._Mypair._Myval2;

            _Traits::copy(_My_data._Bx._Buf, _Right_data._Bx._Buf, _Right_data._Mysize + 1);
            _My_data._Mysize = _Right_data._Mysize;
            _My_data._Myres  = _Right_data._Myres;
        }
    }

public:
    constexpr basic_string& operator=(const basic_string& _Right) {
        if (this == ::std:: addressof(_Right)) {
            return *this;
        }

        auto& _Al             = _Getal();
        const auto& _Right_al = _Right._Getal();
        if constexpr (_Choose_pocca_v<_Alty>) {
            if (_Al != _Right_al) {
                auto&& _Alproxy       = _Fake_alloc;
                auto&& _Right_alproxy = _Fake_alloc;
                _Container_proxy_ptr<_Alty> _New_proxy(_Right_alproxy, _Leave_proxy_unbound{}); 

                if (_Right._Mypair._Myval2._Large_string_engaged()) {
                    const auto _New_size     = _Right._Mypair._Myval2._Mysize;
                    const auto _New_capacity = _Calculate_growth(_New_size, 0, _Right.max_size());
                    auto _Right_al_non_const = _Right_al;
                    const auto _New_ptr      = _Right_al_non_const.allocate(_New_capacity + 1); 


                    if (::std:: is_constant_evaluated()) { 
                        _Traits::assign(_Unfancy(_New_ptr), _New_size + 1, _Elem());
                    }
#line 3055 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

                    _Traits::copy(_Unfancy(_New_ptr), _Unfancy(_Right._Mypair._Myval2._Bx._Ptr), _New_size + 1);
                    _Tidy_deallocate();
                    _Mypair._Myval2._Bx._Ptr = _New_ptr;
                    _Mypair._Myval2._Mysize  = _New_size;
                    _Mypair._Myval2._Myres   = _New_capacity;
                } else {
                    _Copy_assign_val_from_small(_Right);
                }

                _Pocca(_Al, _Right_al);
                _New_proxy._Bind(_Alproxy, ::std:: addressof(_Mypair._Myval2));
                return *this;
            }
        }

        _Pocca(_Al, _Right_al);
        assign(_Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
        return *this;
    }


    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
    constexpr basic_string& operator=(const _StringViewIsh& _Right) {
        return assign(_Right);
    }
#line 3082 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    constexpr basic_string& operator=(  const _Elem* const _Ptr) {
        return assign(_Ptr);
    }


    basic_string& operator=(nullptr_t) = delete;
#line 3090 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    constexpr basic_string& operator=(const _Elem _Ch) { 
        _Mypair._Myval2._Mysize = 1;
        _Elem* const _Ptr       = _Mypair._Myval2._Myptr();
        _Traits::assign(_Ptr[0], _Ch);
        _Traits::assign(_Ptr[1], _Elem());
        return *this;
    }

    constexpr basic_string& operator+=(const basic_string& _Right) {
        return append(_Right);
    }


    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
    constexpr basic_string& operator+=(const _StringViewIsh& _Right) {
        return append(_Right);
    }
#line 3109 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    constexpr basic_string& operator+=(  const _Elem* const _Ptr) { 
        return append(_Ptr);
    }

    constexpr basic_string& operator+=(_Elem _Ch) {
        push_back(_Ch);
        return *this;
    }

    constexpr basic_string& append(const basic_string& _Right) {
        return append(_Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
    }

    constexpr basic_string& append(const basic_string& _Right, const size_type _Roff, size_type _Count = npos) {
        
        _Right._Mypair._Myval2._Check_offset(_Roff);
        _Count = _Right._Mypair._Myval2._Clamp_suffix_size(_Roff, _Count);
        return append(_Right._Mypair._Myval2._Myptr() + _Roff, _Count);
    }


    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
    constexpr basic_string& append(const _StringViewIsh& _Right) {
        const basic_string_view<_Elem, _Traits> _As_view = _Right;
        return append(_As_view.data(), _Convert_size<size_type>(_As_view.size()));
    }

    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
    constexpr basic_string& append(
        const _StringViewIsh& _Right, const size_type _Roff, const size_type _Count = npos) {
        
        basic_string_view<_Elem, _Traits> _As_view = _Right;
        return append(_As_view.substr(_Roff, _Count));
    }
#line 3145 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    constexpr basic_string& append(
          const _Elem* const _Ptr,  const size_type _Count) {
        
        const size_type _Old_size = _Mypair._Myval2._Mysize;
        if (_Count <= _Mypair._Myval2._Myres - _Old_size) {
            _Mypair._Myval2._Mysize = _Old_size + _Count;
            _Elem* const _Old_ptr   = _Mypair._Myval2._Myptr();
            _Traits::move(_Old_ptr + _Old_size, _Ptr, _Count);
            _Traits::assign(_Old_ptr[_Old_size + _Count], _Elem());
            return *this;
        }

        return _Reallocate_grow_by(
            _Count,
            [](_Elem* const _New_ptr, const _Elem* const _Old_ptr, const size_type _Old_size, const _Elem* const _Ptr,
                const size_type _Count) {
                _Traits::copy(_New_ptr, _Old_ptr, _Old_size);
                _Traits::copy(_New_ptr + _Old_size, _Ptr, _Count);
                _Traits::assign(_New_ptr[_Old_size + _Count], _Elem());
            },
            _Ptr, _Count);
    }

    constexpr basic_string& append(  const _Elem* const _Ptr) { 
        return append(_Ptr, _Convert_size<size_type>(_Traits::length(_Ptr)));
    }

    constexpr basic_string& append( const size_type _Count, const _Elem _Ch) {
        
        const size_type _Old_size = _Mypair._Myval2._Mysize;
        if (_Count <= _Mypair._Myval2._Myres - _Old_size) {
            _Mypair._Myval2._Mysize = _Old_size + _Count;
            _Elem* const _Old_ptr   = _Mypair._Myval2._Myptr();
            _Traits::assign(_Old_ptr + _Old_size, _Count, _Ch);
            _Traits::assign(_Old_ptr[_Old_size + _Count], _Elem());
            return *this;
        }

        return _Reallocate_grow_by(
            _Count,
            [](_Elem* const _New_ptr, const _Elem* const _Old_ptr, const size_type _Old_size, const size_type _Count,
                const _Elem _Ch) {
                _Traits::copy(_New_ptr, _Old_ptr, _Old_size);
                _Traits::assign(_New_ptr + _Old_size, _Count, _Ch);
                _Traits::assign(_New_ptr[_Old_size + _Count], _Elem());
            },
            _Count, _Ch);
    }

    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
    constexpr basic_string& append(const _Iter _First, const _Iter _Last) {
        
        _Adl_verify_range(_First, _Last);
        const auto _UFirst = _Get_unwrapped(_First);
        const auto _ULast  = _Get_unwrapped(_Last);
        if constexpr (_Is_elem_cptr<decltype(_UFirst)>::value) {
            return append(_UFirst, _Convert_size<size_type>(static_cast<size_t>(_ULast - _UFirst)));
        } else {
            const basic_string _Right(_UFirst, _ULast, get_allocator());
            return append(_Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
        }
    }

    constexpr basic_string& assign(const basic_string& _Right) {
        *this = _Right;
        return *this;
    }

    constexpr basic_string& assign(const basic_string& _Right, const size_type _Roff, size_type _Count = npos) {
        
        _Right._Mypair._Myval2._Check_offset(_Roff);
        _Count = _Right._Mypair._Myval2._Clamp_suffix_size(_Roff, _Count);
        return assign(_Right._Mypair._Myval2._Myptr() + _Roff, _Count);
    }


    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
    constexpr basic_string& assign(const _StringViewIsh& _Right) {
        const basic_string_view<_Elem, _Traits> _As_view = _Right;
        return assign(_As_view.data(), _Convert_size<size_type>(_As_view.size()));
    }

    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
    constexpr basic_string& assign(
        const _StringViewIsh& _Right, const size_type _Roff, const size_type _Count = npos) {
        
        basic_string_view<_Elem, _Traits> _As_view = _Right;
        return assign(_As_view.substr(_Roff, _Count));
    }
#line 3236 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    constexpr basic_string& assign(
          const _Elem* const _Ptr,  const size_type _Count) {
        
        if (_Count <= _Mypair._Myval2._Myres) {
            _Elem* const _Old_ptr   = _Mypair._Myval2._Myptr();
            _Mypair._Myval2._Mysize = _Count;
            _Traits::move(_Old_ptr, _Ptr, _Count);
            _Traits::assign(_Old_ptr[_Count], _Elem());
            return *this;
        }

        return _Reallocate_for(
            _Count,
            [](_Elem* const _New_ptr, const size_type _Count, const _Elem* const _Ptr) {
                _Traits::copy(_New_ptr, _Ptr, _Count);
                _Traits::assign(_New_ptr[_Count], _Elem());
            },
            _Ptr);
    }

    constexpr basic_string& assign(  const _Elem* const _Ptr) {
        return assign(_Ptr, _Convert_size<size_type>(_Traits::length(_Ptr)));
    }

    constexpr basic_string& assign( const size_type _Count, const _Elem _Ch) {
        
        if (_Count <= _Mypair._Myval2._Myres) {
            _Elem* const _Old_ptr   = _Mypair._Myval2._Myptr();
            _Mypair._Myval2._Mysize = _Count;
            _Traits::assign(_Old_ptr, _Count, _Ch);
            _Traits::assign(_Old_ptr[_Count], _Elem());
            return *this;
        }

        return _Reallocate_for(
            _Count,
            [](_Elem* const _New_ptr, const size_type _Count, const _Elem _Ch) {
                _Traits::assign(_New_ptr, _Count, _Ch);
                _Traits::assign(_New_ptr[_Count], _Elem());
            },
            _Ch);
    }

    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
    constexpr basic_string& assign(const _Iter _First, const _Iter _Last) {
        _Adl_verify_range(_First, _Last);
        const auto _UFirst = _Get_unwrapped(_First);
        const auto _ULast  = _Get_unwrapped(_Last);
        if constexpr (_Is_elem_cptr<decltype(_UFirst)>::value) {
            return assign(_UFirst, _Convert_size<size_type>(static_cast<size_t>(_ULast - _UFirst)));
        } else {
            basic_string _Right(_UFirst, _ULast, get_allocator());
            if (_Mypair._Myval2._Myres < _Right._Mypair._Myval2._Myres) {
                _Mypair._Myval2._Orphan_all();
                _Swap_data(_Right);
                return *this;
            } else {
                return assign(_Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
            }
        }
    }

    constexpr basic_string& insert(const size_type _Off, const basic_string& _Right) {
        
        return insert(_Off, _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
    }

    constexpr basic_string& insert(
        const size_type _Off, const basic_string& _Right, const size_type _Roff, size_type _Count = npos) {
        
        _Right._Mypair._Myval2._Check_offset(_Roff);
        _Count = _Right._Mypair._Myval2._Clamp_suffix_size(_Roff, _Count);
        return insert(_Off, _Right._Mypair._Myval2._Myptr() + _Roff, _Count);
    }


    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
    constexpr basic_string& insert(const size_type _Off, const _StringViewIsh& _Right) {
        
        const basic_string_view<_Elem, _Traits> _As_view = _Right;
        return insert(_Off, _As_view.data(), _Convert_size<size_type>(_As_view.size()));
    }

    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
    constexpr basic_string& insert(
        const size_type _Off, const _StringViewIsh& _Right, const size_type _Roff, const size_type _Count = npos) {
        
        basic_string_view<_Elem, _Traits> _As_view = _Right;
        return insert(_Off, _As_view.substr(_Roff, _Count));
    }
#line 3328 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    constexpr basic_string& insert(
        const size_type _Off,   const _Elem* const _Ptr,  const size_type _Count) {
        
        _Mypair._Myval2._Check_offset(_Off);
        const size_type _Old_size = _Mypair._Myval2._Mysize;

        
        const bool _Check_overlap = _Count <= _Mypair._Myval2._Myres - _Old_size && !::std:: is_constant_evaluated();


#line 3342 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

        if (_Check_overlap) {
            _Mypair._Myval2._Mysize = _Old_size + _Count;
            _Elem* const _Old_ptr   = _Mypair._Myval2._Myptr();
            _Elem* const _Insert_at = _Old_ptr + _Off;
            
            
            size_type _Ptr_shifted_after;
            if (_Ptr + _Count <= _Insert_at || _Ptr > _Old_ptr + _Old_size) {
                
                _Ptr_shifted_after = _Count; 
            } else if (_Insert_at <= _Ptr) { 
                _Ptr_shifted_after = 0;
            } else { 
                _Ptr_shifted_after = static_cast<size_type>(_Insert_at - _Ptr);
            }

            _Traits::move(_Insert_at + _Count, _Insert_at, _Old_size - _Off + 1); 
            _Traits::copy(_Insert_at, _Ptr, _Ptr_shifted_after);
            _Traits::copy(
                _Insert_at + _Ptr_shifted_after, _Ptr + _Count + _Ptr_shifted_after, _Count - _Ptr_shifted_after);
            return *this;
        }

        return _Reallocate_grow_by(
            _Count,
            [](_Elem* const _New_ptr, const _Elem* const _Old_ptr, const size_type _Old_size, const size_type _Off,
                const _Elem* const _Ptr, const size_type _Count) {
                _Traits::copy(_New_ptr, _Old_ptr, _Off);
                _Traits::copy(_New_ptr + _Off, _Ptr, _Count);
                _Traits::copy(_New_ptr + _Off + _Count, _Old_ptr + _Off, _Old_size - _Off + 1);
            },
            _Off, _Ptr, _Count);
    }

    constexpr basic_string& insert(const size_type _Off,   const _Elem* const _Ptr) {
        
        return insert(_Off, _Ptr, _Convert_size<size_type>(_Traits::length(_Ptr)));
    }

    constexpr basic_string& insert(
        const size_type _Off,  const size_type _Count, const _Elem _Ch) {
        
        _Mypair._Myval2._Check_offset(_Off);
        const size_type _Old_size = _Mypair._Myval2._Mysize;
        if (_Count <= _Mypair._Myval2._Myres - _Old_size) {
            _Mypair._Myval2._Mysize = _Old_size + _Count;
            _Elem* const _Old_ptr   = _Mypair._Myval2._Myptr();
            _Elem* const _Insert_at = _Old_ptr + _Off;
            _Traits::move(_Insert_at + _Count, _Insert_at, _Old_size - _Off + 1); 
            _Traits::assign(_Insert_at, _Count, _Ch); 
            return *this;
        }

        return _Reallocate_grow_by(
            _Count,
            [](_Elem* const _New_ptr, const _Elem* const _Old_ptr, const size_type _Old_size, const size_type _Off,
                const size_type _Count, const _Elem _Ch) {
                _Traits::copy(_New_ptr, _Old_ptr, _Off);
                _Traits::assign(_New_ptr + _Off, _Count, _Ch);
                _Traits::copy(_New_ptr + _Off + _Count, _Old_ptr + _Off, _Old_size - _Off + 1);
            },
            _Off, _Count, _Ch);
    }

    constexpr iterator insert(const const_iterator _Where, const _Elem _Ch) { 


#line 3411 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        const auto _Off = static_cast<size_type>(_Unfancy(_Where._Ptr) - _Mypair._Myval2._Myptr());
        insert(_Off, 1, _Ch);
        return begin() + static_cast<difference_type>(_Off);
    }

    constexpr iterator insert(
        const const_iterator _Where,  const size_type _Count, const _Elem _Ch) {
        

#line 3422 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        const auto _Off = static_cast<size_type>(_Unfancy(_Where._Ptr) - _Mypair._Myval2._Myptr());
        insert(_Off, _Count, _Ch);
        return begin() + static_cast<difference_type>(_Off);
    }

    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
    constexpr iterator insert(const const_iterator _Where, const _Iter _First, const _Iter _Last) {
        

#line 3433 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        const auto _Off = static_cast<size_type>(_Unfancy(_Where._Ptr) - _Mypair._Myval2._Myptr());
        _Adl_verify_range(_First, _Last);
        const auto _UFirst = _Get_unwrapped(_First);
        const auto _ULast  = _Get_unwrapped(_Last);
        if constexpr (_Is_elem_cptr<decltype(_UFirst)>::value) {
            insert(_Off, _UFirst, _Convert_size<size_type>(static_cast<size_t>(_ULast - _UFirst)));
        } else {
            const basic_string _Right(_UFirst, _ULast, get_allocator());
            insert(_Off, _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
        }

        return begin() + static_cast<difference_type>(_Off);
    }

    constexpr basic_string& erase(const size_type _Off = 0) { 
        _Mypair._Myval2._Check_offset(_Off);
        _Eos(_Off);
        return *this;
    }

private:
    constexpr basic_string& _Erase_noexcept(const size_type _Off, size_type _Count) noexcept {
        _Count                    = _Mypair._Myval2._Clamp_suffix_size(_Off, _Count);
        const size_type _Old_size = _Mypair._Myval2._Mysize;
        _Elem* const _My_ptr      = _Mypair._Myval2._Myptr();
        _Elem* const _Erase_at    = _My_ptr + _Off;
        const size_type _New_size = _Old_size - _Count;
        _Mypair._Myval2._Mysize   = _New_size;
        _Traits::move(_Erase_at, _Erase_at + _Count, _New_size - _Off + 1); 
        return *this;
    }

public:
    constexpr basic_string& erase(const size_type _Off, const size_type _Count) {
        
        _Mypair._Myval2._Check_offset(_Off);
        return _Erase_noexcept(_Off, _Count);
    }

    constexpr iterator erase(const const_iterator _Where) noexcept  {


#line 3476 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        const auto _Off = static_cast<size_type>(_Unfancy(_Where._Ptr) - _Mypair._Myval2._Myptr());
        _Erase_noexcept(_Off, 1);
        return begin() + static_cast<difference_type>(_Off);
    }

    constexpr iterator erase(const const_iterator _First, const const_iterator _Last) noexcept
     {
        _Adl_verify_range(_First, _Last);


#line 3487 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        const auto _Off = static_cast<size_type>(_Unfancy(_First._Ptr) - _Mypair._Myval2._Myptr());
        _Erase_noexcept(_Off, static_cast<size_type>(_Last._Ptr - _First._Ptr));
        return begin() + static_cast<difference_type>(_Off);
    }

    constexpr void clear() noexcept { 
        _Eos(0);
    }

    constexpr basic_string& replace(const size_type _Off, const size_type _Nx, const basic_string& _Right) {
        
        return replace(_Off, _Nx, _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
    }

    constexpr basic_string& replace(const size_type _Off, size_type _Nx, const basic_string& _Right,
        const size_type _Roff, size_type _Count = npos) {
        
        _Right._Mypair._Myval2._Check_offset(_Roff);
        _Count = _Right._Mypair._Myval2._Clamp_suffix_size(_Roff, _Count);
        return replace(_Off, _Nx, _Right._Mypair._Myval2._Myptr() + _Roff, _Count);
    }


    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
    constexpr basic_string& replace(const size_type _Off, const size_type _Nx, const _StringViewIsh& _Right) {
        
        basic_string_view<_Elem, _Traits> _As_view = _Right;
        return replace(_Off, _Nx, _As_view.data(), _Convert_size<size_type>(_As_view.size()));
    }

    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
    constexpr basic_string& replace(const size_type _Off, const size_type _Nx, const _StringViewIsh& _Right,
        const size_type _Roff, const size_type _Count = npos) {
        
        basic_string_view<_Elem, _Traits> _As_view = _Right;
        return replace(_Off, _Nx, _As_view.substr(_Roff, _Count));
    }
#line 3525 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    constexpr basic_string& replace(
        const size_type _Off, size_type _Nx,   const _Elem* const _Ptr, const size_type _Count) {
        
        _Mypair._Myval2._Check_offset(_Off);
        _Nx = _Mypair._Myval2._Clamp_suffix_size(_Off, _Nx);
        if (_Nx == _Count) { 
            _Traits::move(_Mypair._Myval2._Myptr() + _Off, _Ptr, _Count);
            return *this;
        }

        const size_type _Old_size    = _Mypair._Myval2._Mysize;
        const size_type _Suffix_size = _Old_size - _Nx - _Off + 1;
        if (_Count < _Nx) { 
            _Mypair._Myval2._Mysize = _Old_size - (_Nx - _Count);
            _Elem* const _Old_ptr   = _Mypair._Myval2._Myptr();
            _Elem* const _Insert_at = _Old_ptr + _Off;
            _Traits::move(_Insert_at, _Ptr, _Count);
            _Traits::move(_Insert_at + _Count, _Insert_at + _Nx, _Suffix_size);
            return *this;
        }

        const size_type _Growth = static_cast<size_type>(_Count - _Nx);

        
        if (!::std:: is_constant_evaluated())
#line 3554 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        {
            if (_Growth <= _Mypair._Myval2._Myres - _Old_size) { 
                _Mypair._Myval2._Mysize = _Old_size + _Growth;
                _Elem* const _Old_ptr   = _Mypair._Myval2._Myptr();
                _Elem* const _Insert_at = _Old_ptr + _Off;
                _Elem* const _Suffix_at = _Insert_at + _Nx;

                size_type _Ptr_shifted_after; 
                if (_Ptr + _Count <= _Insert_at || _Ptr > _Old_ptr + _Old_size) {
                    _Ptr_shifted_after = _Count;
                } else if (_Suffix_at <= _Ptr) {
                    _Ptr_shifted_after = 0;
                } else {
                    _Ptr_shifted_after = static_cast<size_type>(_Suffix_at - _Ptr);
                }

                _Traits::move(_Suffix_at + _Growth, _Suffix_at, _Suffix_size);
                
                
                _Traits::move(_Insert_at, _Ptr, _Ptr_shifted_after);
                
                
                _Traits::copy(
                    _Insert_at + _Ptr_shifted_after, _Ptr + _Growth + _Ptr_shifted_after, _Count - _Ptr_shifted_after);
                return *this;
            }
        }

        return _Reallocate_grow_by(
            _Growth,
            [](_Elem* const _New_ptr, const _Elem* const _Old_ptr, const size_type _Old_size, const size_type _Off,
                const size_type _Nx, const _Elem* const _Ptr, const size_type _Count) {
                _Traits::copy(_New_ptr, _Old_ptr, _Off);
                _Traits::copy(_New_ptr + _Off, _Ptr, _Count);
                _Traits::copy(_New_ptr + _Off + _Count, _Old_ptr + _Off + _Nx, _Old_size - _Nx - _Off + 1);
            },
            _Off, _Nx, _Ptr, _Count);
    }

    constexpr basic_string& replace(const size_type _Off, const size_type _Nx,   const _Elem* const _Ptr) {
        
        return replace(_Off, _Nx, _Ptr, _Convert_size<size_type>(_Traits::length(_Ptr)));
    }

    constexpr basic_string& replace(const size_type _Off, size_type _Nx, const size_type _Count, const _Elem _Ch) {
        
        _Mypair._Myval2._Check_offset(_Off);
        _Nx = _Mypair._Myval2._Clamp_suffix_size(_Off, _Nx);
        if (_Count == _Nx) {
            _Traits::assign(_Mypair._Myval2._Myptr() + _Off, _Count, _Ch);
            return *this;
        }

        const size_type _Old_size = _Mypair._Myval2._Mysize;
        if (_Count < _Nx || _Count - _Nx <= _Mypair._Myval2._Myres - _Old_size) {
            
            _Mypair._Myval2._Mysize = _Old_size + _Count - _Nx; 
                                                                
            _Elem* const _Old_ptr   = _Mypair._Myval2._Myptr();
            _Elem* const _Insert_at = _Old_ptr + _Off;
            _Traits::move(_Insert_at + _Count, _Insert_at + _Nx, _Old_size - _Nx - _Off + 1);
            _Traits::assign(_Insert_at, _Count, _Ch);
            return *this;
        }

        return _Reallocate_grow_by(
            _Count - _Nx,
            [](_Elem* const _New_ptr, const _Elem* const _Old_ptr, const size_type _Old_size, const size_type _Off,
                const size_type _Nx, const size_type _Count, const _Elem _Ch) {
                _Traits::copy(_New_ptr, _Old_ptr, _Off);
                _Traits::assign(_New_ptr + _Off, _Count, _Ch);
                _Traits::copy(_New_ptr + _Off + _Count, _Old_ptr + _Off + _Nx, _Old_size - _Nx - _Off + 1);
            },
            _Off, _Nx, _Count, _Ch);
    }

    constexpr basic_string& replace(
        const const_iterator _First, const const_iterator _Last, const basic_string& _Right) {
        
        _Adl_verify_range(_First, _Last);


#line 3638 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        return replace(static_cast<size_type>(_Unfancy(_First._Ptr) - _Mypair._Myval2._Myptr()),
            static_cast<size_type>(_Last._Ptr - _First._Ptr), _Right);
    }


    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
    constexpr basic_string& replace(
        const const_iterator _First, const const_iterator _Last, const _StringViewIsh& _Right) {
        
        _Adl_verify_range(_First, _Last);


#line 3651 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        return replace(static_cast<size_type>(_Unfancy(_First._Ptr) - _Mypair._Myval2._Myptr()),
            static_cast<size_type>(_Last._Ptr - _First._Ptr), _Right);
    }
#line 3655 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    constexpr basic_string& replace(const const_iterator _First, const const_iterator _Last,
          const _Elem* const _Ptr, const size_type _Count) {
        
        _Adl_verify_range(_First, _Last);


#line 3663 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        return replace(static_cast<size_type>(_Unfancy(_First._Ptr) - _Mypair._Myval2._Myptr()),
            static_cast<size_type>(_Last._Ptr - _First._Ptr), _Ptr, _Count);
    }

    constexpr basic_string& replace(
        const const_iterator _First, const const_iterator _Last,   const _Elem* const _Ptr) {
        
        _Adl_verify_range(_First, _Last);


#line 3674 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        return replace(static_cast<size_type>(_Unfancy(_First._Ptr) - _Mypair._Myval2._Myptr()),
            static_cast<size_type>(_Last._Ptr - _First._Ptr), _Ptr);
    }

    constexpr basic_string& replace(
        const const_iterator _First, const const_iterator _Last, const size_type _Count, const _Elem _Ch) {
        
        _Adl_verify_range(_First, _Last);


#line 3685 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        return replace(static_cast<size_type>(_Unfancy(_First._Ptr) - _Mypair._Myval2._Myptr()),
            static_cast<size_type>(_Last._Ptr - _First._Ptr), _Count, _Ch);
    }

    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
    constexpr basic_string& replace(
        const const_iterator _First, const const_iterator _Last, const _Iter _First2, const _Iter _Last2) {
        
        _Adl_verify_range(_First, _Last);


#line 3697 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        const auto _Off    = static_cast<size_type>(_Unfancy(_First._Ptr) - _Mypair._Myval2._Myptr());
        const auto _Length = static_cast<size_type>(_Last._Ptr - _First._Ptr);
        _Adl_verify_range(_First2, _Last2);
        const auto _UFirst2 = _Get_unwrapped(_First2);
        const auto _ULast2  = _Get_unwrapped(_Last2);
        if constexpr (_Is_elem_cptr<decltype(_UFirst2)>::value) {
            return replace(_Off, _Length, _UFirst2, _Convert_size<size_type>(static_cast<size_t>(_ULast2 - _UFirst2)));
        } else {
            const basic_string _Right(_UFirst2, _ULast2, get_allocator());
            return replace(_Off, _Length, _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
        }
    }

    [[nodiscard]] constexpr iterator begin() noexcept {
        return iterator(_Refancy<pointer>(_Mypair._Myval2._Myptr()), ::std:: addressof(_Mypair._Myval2));
    }

    [[nodiscard]] constexpr const_iterator begin() const noexcept {
        return const_iterator(_Refancy<const_pointer>(_Mypair._Myval2._Myptr()), ::std:: addressof(_Mypair._Myval2));
    }

    [[nodiscard]] constexpr iterator end() noexcept {
        return iterator(
            _Refancy<pointer>(_Mypair._Myval2._Myptr()) + static_cast<difference_type>(_Mypair._Myval2._Mysize),
            ::std:: addressof(_Mypair._Myval2));
    }

    [[nodiscard]] constexpr const_iterator end() const noexcept {
        return const_iterator(
            _Refancy<const_pointer>(_Mypair._Myval2._Myptr()) + static_cast<difference_type>(_Mypair._Myval2._Mysize),
            ::std:: addressof(_Mypair._Myval2));
    }

    [[nodiscard]] constexpr _Elem* _Unchecked_begin() noexcept {
        return _Mypair._Myval2._Myptr();
    }

    [[nodiscard]] constexpr const _Elem* _Unchecked_begin() const noexcept {
        return _Mypair._Myval2._Myptr();
    }

    [[nodiscard]] constexpr _Elem* _Unchecked_end() noexcept {
        return _Mypair._Myval2._Myptr() + _Mypair._Myval2._Mysize;
    }

    [[nodiscard]] constexpr const _Elem* _Unchecked_end() const noexcept {
        return _Mypair._Myval2._Myptr() + _Mypair._Myval2._Mysize;
    }

    [[nodiscard]] constexpr reverse_iterator rbegin() noexcept {
        return reverse_iterator(end());
    }

    [[nodiscard]] constexpr const_reverse_iterator rbegin() const noexcept {
        return const_reverse_iterator(end());
    }

    [[nodiscard]] constexpr reverse_iterator rend() noexcept {
        return reverse_iterator(begin());
    }

    [[nodiscard]] constexpr const_reverse_iterator rend() const noexcept {
        return const_reverse_iterator(begin());
    }

    [[nodiscard]] constexpr const_iterator cbegin() const noexcept {
        return begin();
    }

    [[nodiscard]] constexpr const_iterator cend() const noexcept {
        return end();
    }

    [[nodiscard]] constexpr const_reverse_iterator crbegin() const noexcept {
        return rbegin();
    }

    [[nodiscard]] constexpr const_reverse_iterator crend() const noexcept {
        return rend();
    }

    constexpr void shrink_to_fit() { 
        auto& _My_data = _Mypair._Myval2;


        if (!::std:: is_constant_evaluated())
#line 3784 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        {
            if (!_My_data._Large_string_engaged()) { 
                return;
            }

            if (_My_data._Mysize < _BUF_SIZE) {
                _Become_small();
                return;
            }
        }

        size_type _Target_capacity = (::std:: min)(_My_data._Mysize | _ALLOC_MASK, max_size());

        
        _Target_capacity = (::std:: max)(_Target_capacity, _BUF_SIZE);
#line 3800 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

        if (_Target_capacity < _My_data._Myres) { 
            auto& _Al              = _Getal();
            const pointer _New_ptr = _Al.allocate(_Target_capacity + 1); 


            if (::std:: is_constant_evaluated()) { 
                _Traits::assign(_Unfancy(_New_ptr), _Target_capacity + 1, _Elem());
            }
#line 3810 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

            _My_data._Orphan_all();
            _Traits::copy(_Unfancy(_New_ptr), _Unfancy(_My_data._Bx._Ptr), _My_data._Mysize + 1);
            _Al.deallocate(_My_data._Bx._Ptr, _My_data._Myres + 1);
            _My_data._Bx._Ptr = _New_ptr;
            _My_data._Myres   = _Target_capacity;
        }
    }

    [[nodiscard]] constexpr reference at(const size_type _Off) {
        _Mypair._Myval2._Check_offset_exclusive(_Off);
        return _Mypair._Myval2._Myptr()[_Off];
    }

    [[nodiscard]] constexpr const_reference at(const size_type _Off) const {
        _Mypair._Myval2._Check_offset_exclusive(_Off);
        return _Mypair._Myval2._Myptr()[_Off];
    }

    [[nodiscard]] constexpr reference operator[](const size_type _Off) noexcept  {


#line 3833 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        return _Mypair._Myval2._Myptr()[_Off];
    }

    [[nodiscard]] constexpr const_reference operator[](const size_type _Off) const noexcept
     {


#line 3841 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        return _Mypair._Myval2._Myptr()[_Off];
    }


     constexpr operator basic_string_view<_Elem, _Traits>() const noexcept {
        
        return basic_string_view<_Elem, _Traits>{_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize};
    }
#line 3850 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    constexpr void push_back(const _Elem _Ch) { 
        const size_type _Old_size = _Mypair._Myval2._Mysize;
        if (_Old_size < _Mypair._Myval2._Myres) {
            _Mypair._Myval2._Mysize = _Old_size + 1;
            _Elem* const _Ptr       = _Mypair._Myval2._Myptr();
            _Traits::assign(_Ptr[_Old_size], _Ch);
            _Traits::assign(_Ptr[_Old_size + 1], _Elem());
            return;
        }

        _Reallocate_grow_by(
            1,
            [](_Elem* const _New_ptr, const _Elem* const _Old_ptr, const size_type _Old_size, const _Elem _Ch) {
                _Traits::copy(_New_ptr, _Old_ptr, _Old_size);
                _Traits::assign(_New_ptr[_Old_size], _Ch);
                _Traits::assign(_New_ptr[_Old_size + 1], _Elem());
            },
            _Ch);
    }

    constexpr void pop_back() noexcept  {
        const size_type _Old_size = _Mypair._Myval2._Mysize;


#line 3876 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        _Eos(_Old_size - 1);
    }

    [[nodiscard]] constexpr reference front() noexcept  {


#line 3883 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

        return _Mypair._Myval2._Myptr()[0];
    }

    [[nodiscard]] constexpr const_reference front() const noexcept  {


#line 3891 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

        return _Mypair._Myval2._Myptr()[0];
    }

    [[nodiscard]] constexpr reference back() noexcept  {


#line 3899 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

        return _Mypair._Myval2._Myptr()[_Mypair._Myval2._Mysize - 1];
    }

    [[nodiscard]] constexpr const_reference back() const noexcept  {


#line 3907 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

        return _Mypair._Myval2._Myptr()[_Mypair._Myval2._Mysize - 1];
    }

    [[nodiscard]] constexpr   const _Elem* c_str() const noexcept {
        return _Mypair._Myval2._Myptr();
    }

    [[nodiscard]] constexpr   const _Elem* data() const noexcept {
        return _Mypair._Myval2._Myptr();
    }


    [[nodiscard]] constexpr   _Elem* data() noexcept {
        return _Mypair._Myval2._Myptr();
    }
#line 3924 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    [[nodiscard]] constexpr size_type length() const noexcept {
        return _Mypair._Myval2._Mysize;
    }

    [[nodiscard]] constexpr size_type size() const noexcept {
        return _Mypair._Myval2._Mysize;
    }

    [[nodiscard]] constexpr size_type max_size() const noexcept {
        const size_type _Alloc_max   = _Alty_traits::max_size(_Getal());
        const size_type _Storage_max = 
            (::std:: max)(_Alloc_max, static_cast<size_type>(_BUF_SIZE));
        return (::std:: min)(static_cast<size_type>((numeric_limits<difference_type>::max)()),
            _Storage_max - 1 
        );
    }

    constexpr void resize( const size_type _New_size, const _Elem _Ch = _Elem()) {
        
        const size_type _Old_size = size();
        if (_New_size <= _Old_size) {
            _Eos(_New_size);
        } else {
            append(_New_size - _Old_size, _Ch);
        }
    }


    template <class _Operation>
    constexpr void resize_and_overwrite( const size_type _New_size, _Operation _Op) {
        if (_Mypair._Myval2._Myres < _New_size) {
            _Reallocate_grow_by(_New_size - _Mypair._Myval2._Mysize,
                [](_Elem* const _New_ptr, const _Elem* const _Old_ptr, const size_type _Old_size) {
                    _Traits::copy(_New_ptr, _Old_ptr, _Old_size + 1);
                });
        }

        const auto _Result_size = ::std:: move(_Op)(_Mypair._Myval2._Myptr(), _New_size);


#line 3968 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        _Eos(static_cast<size_type>(_Result_size));
    }
#line 3971 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    [[nodiscard]] constexpr size_type capacity() const noexcept {
        return _Mypair._Myval2._Myres;
    }


    constexpr void reserve( const size_type _Newcap) {
        
        if (_Mypair._Myval2._Myres >= _Newcap) { 
            return; 
        }

        const size_type _Old_size = _Mypair._Myval2._Mysize;
        _Reallocate_grow_by(
            _Newcap - _Old_size, [](_Elem* const _New_ptr, const _Elem* const _Old_ptr, const size_type _Old_size) {
                _Traits::copy(_New_ptr, _Old_ptr, _Old_size + 1);
            });

        _Mypair._Myval2._Mysize = _Old_size;
    }

    [[deprecated("warning STL4024: " "std::string::reserve() without an argument is deprecated in C++20. " "To shrink the string's capacity, use std::string::shrink_to_fit() instead. Otherwise, provide an " "argument to std::string::reserve(). " "You can define _SILENCE_CXX20_STRING_RESERVE_WITHOUT_ARGUMENT_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] void reserve() {
        if (_Mypair._Myval2._Mysize == 0 && _Mypair._Myval2._Large_string_engaged()) {
            _Become_small();
        }
    }


#line 4027 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    [[nodiscard]] constexpr bool empty() const noexcept {
        return _Mypair._Myval2._Mysize == 0;
    }

    constexpr size_type copy(
          _Elem* const _Ptr, size_type _Count, const size_type _Off = 0) const {
        
        _Mypair._Myval2._Check_offset(_Off);
        _Count = _Mypair._Myval2._Clamp_suffix_size(_Off, _Count);
        _Traits::copy(_Ptr, _Mypair._Myval2._Myptr() + _Off, _Count);
        return _Count;
    }

    constexpr   size_type
        _Copy_s(  _Elem* const _Dest, const size_type _Dest_size, size_type _Count,
            const size_type _Off = 0) const {
        
        _Mypair._Myval2._Check_offset(_Off);
        _Count = _Mypair._Myval2._Clamp_suffix_size(_Off, _Count);
        _Traits::_Copy_s(_Dest, _Dest_size, _Mypair._Myval2._Myptr() + _Off, _Count);
        return _Count;
    }

    void _Swap_bx_large_with_small(_Scary_val& _Starts_large, _Scary_val& _Starts_small) {
        
        
        const pointer _Ptr = _Starts_large._Bx._Ptr;
        _Destroy_in_place(_Starts_large._Bx._Ptr);
        _Traits::copy(_Starts_large._Bx._Buf, _Starts_small._Bx._Buf, _BUF_SIZE);
        _Construct_in_place(_Starts_small._Bx._Ptr, _Ptr);
    }

    constexpr void _Swap_data(basic_string& _Right) {
        auto& _My_data    = _Mypair._Myval2;
        auto& _Right_data = _Right._Mypair._Myval2;

        if constexpr (_Can_memcpy_val) {

            if (!::std:: is_constant_evaluated())
#line 4069 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
            {
                const auto _My_data_mem =
                    reinterpret_cast<unsigned char*>(::std:: addressof(_My_data)) + _Memcpy_val_offset;
                const auto _Right_data_mem =
                    reinterpret_cast<unsigned char*>(::std:: addressof(_Right_data)) + _Memcpy_val_offset;
                unsigned char _Temp_mem[_Memcpy_val_size];
                :: memcpy(_Temp_mem, _My_data_mem, _Memcpy_val_size);
                :: memcpy(_My_data_mem, _Right_data_mem, _Memcpy_val_size);
                :: memcpy(_Right_data_mem, _Temp_mem, _Memcpy_val_size);
                return;
            }
        }

        const bool _My_large    = _My_data._Large_string_engaged();
        const bool _Right_large = _Right_data._Large_string_engaged();
        if (_My_large) {
            if (_Right_large) { 
                _Swap_adl(_My_data._Bx._Ptr, _Right_data._Bx._Ptr);
            } else { 
                _Swap_bx_large_with_small(_My_data, _Right_data);
            }
        } else {
            if (_Right_large) { 
                _Swap_bx_large_with_small(_Right_data, _My_data);
            } else {
                _Elem _Temp_buf[_BUF_SIZE];
                _Traits::copy(_Temp_buf, _My_data._Bx._Buf, _BUF_SIZE);
                _Traits::copy(_My_data._Bx._Buf, _Right_data._Bx._Buf, _BUF_SIZE);
                _Traits::copy(_Right_data._Bx._Buf, _Temp_buf, _BUF_SIZE);
            }
        }

        ::std:: swap(_My_data._Mysize, _Right_data._Mysize);
        ::std:: swap(_My_data._Myres, _Right_data._Myres);
    }

    constexpr void swap(basic_string& _Right) noexcept  {
        if (this != ::std:: addressof(_Right)) {
            _Pocs(_Getal(), _Right._Getal());


#line 4123 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

            _Swap_data(_Right);
        }
    }


    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
    [[nodiscard]] constexpr size_type find(const _StringViewIsh& _Right, const size_type _Off = 0) const
        noexcept(_Is_nothrow_convertible_v<const _StringViewIsh&, basic_string_view<_Elem, _Traits>>) {
        
        basic_string_view<_Elem, _Traits> _As_view = _Right;
        return static_cast<size_type>(_Traits_find<_Traits>(
            _Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _As_view.data(), _As_view.size()));
    }
#line 4138 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    [[nodiscard]] constexpr size_type find(const basic_string& _Right, const size_type _Off = 0) const noexcept {
        
        return static_cast<size_type>(_Traits_find<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off,
            _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize));
    }

    [[nodiscard]] constexpr size_type find(  const _Elem* const _Ptr, const size_type _Off,
        const size_type _Count) const noexcept  {
        
        return static_cast<size_type>(
            _Traits_find<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _Ptr, _Count));
    }

    [[nodiscard]] constexpr size_type find(  const _Elem* const _Ptr, const size_type _Off = 0) const noexcept
     {
        
        return static_cast<size_type>(_Traits_find<_Traits>(
            _Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _Ptr, _Traits::length(_Ptr)));
    }

    [[nodiscard]] constexpr size_type find(const _Elem _Ch, const size_type _Off = 0) const noexcept {
        
        return static_cast<size_type>(
            _Traits_find_ch<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _Ch));
    }


    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
    [[nodiscard]] constexpr size_type rfind(const _StringViewIsh& _Right, const size_type _Off = npos) const
        noexcept(_Is_nothrow_convertible_v<const _StringViewIsh&, basic_string_view<_Elem, _Traits>>) {
        
        basic_string_view<_Elem, _Traits> _As_view = _Right;
        return static_cast<size_type>(_Traits_rfind<_Traits>(
            _Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _As_view.data(), _As_view.size()));
    }
#line 4175 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    [[nodiscard]] constexpr size_type rfind(const basic_string& _Right, const size_type _Off = npos) const noexcept {
        
        return static_cast<size_type>(_Traits_rfind<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off,
            _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize));
    }

    [[nodiscard]] constexpr size_type rfind(  const _Elem* const _Ptr, const size_type _Off,
        const size_type _Count) const noexcept  {
        
        return static_cast<size_type>(
            _Traits_rfind<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _Ptr, _Count));
    }

    [[nodiscard]] constexpr size_type rfind(  const _Elem* const _Ptr, const size_type _Off = npos) const noexcept
     {
        
        return static_cast<size_type>(_Traits_rfind<_Traits>(
            _Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _Ptr, _Traits::length(_Ptr)));
    }

    [[nodiscard]] constexpr size_type rfind(const _Elem _Ch, const size_type _Off = npos) const noexcept {
        
        return static_cast<size_type>(
            _Traits_rfind_ch<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _Ch));
    }


    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
    [[nodiscard]] constexpr size_type find_first_of(const _StringViewIsh& _Right, const size_type _Off = 0) const
        noexcept(_Is_nothrow_convertible_v<const _StringViewIsh&, basic_string_view<_Elem, _Traits>>) {
        
        basic_string_view<_Elem, _Traits> _As_view = _Right;
        return static_cast<size_type>(_Traits_find_first_of<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize,
            _Off, _As_view.data(), _As_view.size(), _Is_specialization<_Traits, char_traits>{}));
    }
#line 4212 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    [[nodiscard]] constexpr size_type find_first_of(
        const basic_string& _Right, const size_type _Off = 0) const noexcept {
        
        return static_cast<size_type>(_Traits_find_first_of<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize,
            _Off, _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize,
            _Is_specialization<_Traits, char_traits>{}));
    }

    [[nodiscard]] constexpr size_type find_first_of(  const _Elem* const _Ptr, const size_type _Off,
        const size_type _Count) const noexcept  {
        
        return static_cast<size_type>(_Traits_find_first_of<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize,
            _Off, _Ptr, _Count, _Is_specialization<_Traits, char_traits>{}));
    }

    [[nodiscard]] constexpr size_type find_first_of(
          const _Elem* const _Ptr, const size_type _Off = 0) const noexcept  {
        
        return static_cast<size_type>(_Traits_find_first_of<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize,
            _Off, _Ptr, _Traits::length(_Ptr), _Is_specialization<_Traits, char_traits>{}));
    }

    [[nodiscard]] constexpr size_type find_first_of(const _Elem _Ch, const size_type _Off = 0) const noexcept {
        
        return static_cast<size_type>(
            _Traits_find_ch<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _Ch));
    }


    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
    [[nodiscard]] constexpr size_type find_last_of(const _StringViewIsh& _Right, const size_type _Off = npos) const
        noexcept(_Is_nothrow_convertible_v<const _StringViewIsh&, basic_string_view<_Elem, _Traits>>) {
        
        basic_string_view<_Elem, _Traits> _As_view = _Right;
        return static_cast<size_type>(_Traits_find_last_of<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize,
            _Off, _As_view.data(), _As_view.size(), _Is_specialization<_Traits, char_traits>{}));
    }
#line 4251 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    [[nodiscard]] constexpr size_type find_last_of(const basic_string& _Right, size_type _Off = npos) const noexcept {
        
        return static_cast<size_type>(_Traits_find_last_of<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize,
            _Off, _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize,
            _Is_specialization<_Traits, char_traits>{}));
    }

    [[nodiscard]] constexpr size_type find_last_of(  const _Elem* const _Ptr, const size_type _Off,
        const size_type _Count) const noexcept  {
        
        return static_cast<size_type>(_Traits_find_last_of<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize,
            _Off, _Ptr, _Count, _Is_specialization<_Traits, char_traits>{}));
    }

    [[nodiscard]] constexpr size_type find_last_of(
          const _Elem* const _Ptr, const size_type _Off = npos) const noexcept  {
        
        return static_cast<size_type>(_Traits_find_last_of<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize,
            _Off, _Ptr, _Traits::length(_Ptr), _Is_specialization<_Traits, char_traits>{}));
    }

    [[nodiscard]] constexpr size_type find_last_of(const _Elem _Ch, const size_type _Off = npos) const noexcept {
        
        return static_cast<size_type>(
            _Traits_rfind_ch<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _Ch));
    }


    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
    [[nodiscard]] constexpr size_type find_first_not_of(const _StringViewIsh& _Right, const size_type _Off = 0) const
        noexcept(_Is_nothrow_convertible_v<const _StringViewIsh&, basic_string_view<_Elem, _Traits>>) {
        
        basic_string_view<_Elem, _Traits> _As_view = _Right;
        return static_cast<size_type>(
            _Traits_find_first_not_of<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _As_view.data(),
                _As_view.size(), _Is_specialization<_Traits, char_traits>{}));
    }
#line 4290 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    [[nodiscard]] constexpr size_type find_first_not_of(
        const basic_string& _Right, const size_type _Off = 0) const noexcept {
        
        return static_cast<size_type>(_Traits_find_first_not_of<_Traits>(_Mypair._Myval2._Myptr(),
            _Mypair._Myval2._Mysize, _Off, _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize,
            _Is_specialization<_Traits, char_traits>{}));
    }

    [[nodiscard]] constexpr size_type find_first_not_of(  const _Elem* const _Ptr,
        const size_type _Off, const size_type _Count) const noexcept  {
        
        return static_cast<size_type>(_Traits_find_first_not_of<_Traits>(_Mypair._Myval2._Myptr(),
            _Mypair._Myval2._Mysize, _Off, _Ptr, _Count, _Is_specialization<_Traits, char_traits>{}));
    }

    [[nodiscard]] constexpr size_type find_first_not_of(
          const _Elem* const _Ptr, size_type _Off = 0) const noexcept  {
        
        return static_cast<size_type>(_Traits_find_first_not_of<_Traits>(_Mypair._Myval2._Myptr(),
            _Mypair._Myval2._Mysize, _Off, _Ptr, _Traits::length(_Ptr), _Is_specialization<_Traits, char_traits>{}));
    }

    [[nodiscard]] constexpr size_type find_first_not_of(const _Elem _Ch, const size_type _Off = 0) const noexcept {
        
        return static_cast<size_type>(
            _Traits_find_not_ch<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _Ch));
    }


    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
    [[nodiscard]] constexpr size_type find_last_not_of(const _StringViewIsh& _Right, const size_type _Off = npos) const
        noexcept(_Is_nothrow_convertible_v<const _StringViewIsh&, basic_string_view<_Elem, _Traits>>) {
        
        basic_string_view<_Elem, _Traits> _As_view = _Right;
        return static_cast<size_type>(
            _Traits_find_last_not_of<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _As_view.data(),
                _As_view.size(), _Is_specialization<_Traits, char_traits>{}));
    }
#line 4330 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    [[nodiscard]] constexpr size_type find_last_not_of(
        const basic_string& _Right, const size_type _Off = npos) const noexcept {
        
        return static_cast<size_type>(_Traits_find_last_not_of<_Traits>(_Mypair._Myval2._Myptr(),
            _Mypair._Myval2._Mysize, _Off, _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize,
            _Is_specialization<_Traits, char_traits>{}));
    }

    [[nodiscard]] constexpr size_type find_last_not_of(  const _Elem* const _Ptr, const size_type _Off,
        const size_type _Count) const noexcept  {
        
        return static_cast<size_type>(_Traits_find_last_not_of<_Traits>(_Mypair._Myval2._Myptr(),
            _Mypair._Myval2._Mysize, _Off, _Ptr, _Count, _Is_specialization<_Traits, char_traits>{}));
    }

    [[nodiscard]] constexpr size_type find_last_not_of(
          const _Elem* const _Ptr, const size_type _Off = npos) const noexcept  {
        
        return static_cast<size_type>(_Traits_find_last_not_of<_Traits>(_Mypair._Myval2._Myptr(),
            _Mypair._Myval2._Mysize, _Off, _Ptr, _Traits::length(_Ptr), _Is_specialization<_Traits, char_traits>{}));
    }

    [[nodiscard]] constexpr size_type find_last_not_of(const _Elem _Ch, const size_type _Off = npos) const noexcept {
        
        return static_cast<size_type>(
            _Traits_rfind_not_ch<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Off, _Ch));
    }


    [[nodiscard]] bool _Starts_with(const basic_string_view<_Elem, _Traits> _Right) const noexcept {
        
        return basic_string_view<_Elem, _Traits>(*this)._Starts_with(_Right);
    }
#line 4365 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    [[nodiscard]] constexpr basic_string substr(const size_type _Off = 0, const size_type _Count = npos) const {
        
        return basic_string(*this, _Off, _Count, get_allocator());
    }

    constexpr bool _Equal(const basic_string& _Right) const noexcept {
        
        return _Traits_equal<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize,
            _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
    }

    constexpr bool _Equal(  const _Elem* const _Ptr) const noexcept {
        
        return _Traits_equal<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Ptr, _Traits::length(_Ptr));
    }


    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
    [[nodiscard]] constexpr int compare(const _StringViewIsh& _Right) const
        noexcept(_Is_nothrow_convertible_v<const _StringViewIsh&, basic_string_view<_Elem, _Traits>>) {
        
        basic_string_view<_Elem, _Traits> _As_view = _Right;
        return _Traits_compare<_Traits>(
            _Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _As_view.data(), _As_view.size());
    }

    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
    [[nodiscard]] constexpr int compare(const size_type _Off, const size_type _Nx, const _StringViewIsh& _Right) const {
        
        basic_string_view<_Elem, _Traits> _As_view = _Right;
        _Mypair._Myval2._Check_offset(_Off);
        return _Traits_compare<_Traits>(_Mypair._Myval2._Myptr() + _Off, _Mypair._Myval2._Clamp_suffix_size(_Off, _Nx),
            _As_view.data(), _As_view.size());
    }

    template <class _StringViewIsh, _Is_string_view_ish<_StringViewIsh> = 0>
    [[nodiscard]] constexpr int compare(const size_type _Off, const size_type _Nx, const _StringViewIsh& _Right,
        const size_type _Roff, const size_type _Count = npos) const {
        
        basic_string_view<_Elem, _Traits> _As_view = _Right;
        _Mypair._Myval2._Check_offset(_Off);
        const auto _With_substr = _As_view.substr(_Roff, _Count);
        return _Traits_compare<_Traits>(_Mypair._Myval2._Myptr() + _Off, _Mypair._Myval2._Clamp_suffix_size(_Off, _Nx),
            _With_substr.data(), _With_substr.size());
    }
#line 4412 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    [[nodiscard]] constexpr int compare(const basic_string& _Right) const noexcept {
        
        return _Traits_compare<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize,
            _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
    }

    [[nodiscard]] constexpr int compare(size_type _Off, size_type _Nx, const basic_string& _Right) const {
        
        _Mypair._Myval2._Check_offset(_Off);
        return _Traits_compare<_Traits>(_Mypair._Myval2._Myptr() + _Off, _Mypair._Myval2._Clamp_suffix_size(_Off, _Nx),
            _Right._Mypair._Myval2._Myptr(), _Right._Mypair._Myval2._Mysize);
    }

    [[nodiscard]] constexpr int compare(const size_type _Off, const size_type _Nx, const basic_string& _Right,
        const size_type _Roff, const size_type _Count = npos) const {
        
        _Mypair._Myval2._Check_offset(_Off);
        _Right._Mypair._Myval2._Check_offset(_Roff);
        return _Traits_compare<_Traits>(_Mypair._Myval2._Myptr() + _Off, _Mypair._Myval2._Clamp_suffix_size(_Off, _Nx),
            _Right._Mypair._Myval2._Myptr() + _Roff, _Right._Mypair._Myval2._Clamp_suffix_size(_Roff, _Count));
    }

    [[nodiscard]] constexpr int compare(  const _Elem* const _Ptr) const noexcept  {
        
        return _Traits_compare<_Traits>(_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize, _Ptr, _Traits::length(_Ptr));
    }

    [[nodiscard]] constexpr int compare(
        const size_type _Off, const size_type _Nx,   const _Elem* const _Ptr) const {
        
        _Mypair._Myval2._Check_offset(_Off);
        return _Traits_compare<_Traits>(_Mypair._Myval2._Myptr() + _Off, _Mypair._Myval2._Clamp_suffix_size(_Off, _Nx),
            _Ptr, _Traits::length(_Ptr));
    }

    [[nodiscard]] constexpr int compare(const size_type _Off, const size_type _Nx,
          const _Elem* const _Ptr, const size_type _Count) const {
        
        _Mypair._Myval2._Check_offset(_Off);
        return _Traits_compare<_Traits>(
            _Mypair._Myval2._Myptr() + _Off, _Mypair._Myval2._Clamp_suffix_size(_Off, _Nx), _Ptr, _Count);
    }


    [[nodiscard]] constexpr bool starts_with(const basic_string_view<_Elem, _Traits> _Right) const noexcept {
        return basic_string_view<_Elem, _Traits>{_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize}.starts_with(_Right);
    }

    [[nodiscard]] constexpr bool starts_with(const _Elem _Right) const noexcept {
        return basic_string_view<_Elem, _Traits>{_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize}.starts_with(_Right);
    }

    [[nodiscard]] constexpr bool starts_with(const _Elem* const _Right) const noexcept  {
        return basic_string_view<_Elem, _Traits>{_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize}.starts_with(_Right);
    }

    [[nodiscard]] constexpr bool ends_with(const basic_string_view<_Elem, _Traits> _Right) const noexcept {
        return basic_string_view<_Elem, _Traits>{_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize}.ends_with(_Right);
    }

    [[nodiscard]] constexpr bool ends_with(const _Elem _Right) const noexcept {
        return basic_string_view<_Elem, _Traits>{_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize}.ends_with(_Right);
    }

    [[nodiscard]] constexpr bool ends_with(const _Elem* const _Right) const noexcept  {
        return basic_string_view<_Elem, _Traits>{_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize}.ends_with(_Right);
    }
#line 4481 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"


    [[nodiscard]] constexpr bool contains(const basic_string_view<_Elem, _Traits> _Right) const noexcept {
        return basic_string_view<_Elem, _Traits>{_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize}.contains(_Right);
    }

    [[nodiscard]] constexpr bool contains(const _Elem _Right) const noexcept {
        return basic_string_view<_Elem, _Traits>{_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize}.contains(_Right);
    }

    [[nodiscard]] constexpr bool contains(const _Elem* const _Right) const noexcept  {
        return basic_string_view<_Elem, _Traits>{_Mypair._Myval2._Myptr(), _Mypair._Myval2._Mysize}.contains(_Right);
    }
#line 4495 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

    [[nodiscard]] constexpr allocator_type get_allocator() const noexcept {
        return static_cast<allocator_type>(_Getal());
    }

private:
    [[nodiscard]] static constexpr size_type _Calculate_growth(
        const size_type _Requested, const size_type _Old, const size_type _Max) noexcept {
        const size_type _Masked = _Requested | _ALLOC_MASK;
        if (_Masked > _Max) { 
            return _Max;
        }

        if (_Old > _Max - _Old / 2) { 
            return _Max;
        }

        return (::std:: max)(_Masked, _Old + _Old / 2);
    }

    [[nodiscard]] constexpr size_type _Calculate_growth(const size_type _Requested) const noexcept {
        return _Calculate_growth(_Requested, _Mypair._Myval2._Myres, max_size());
    }

    template <class _Fty, class... _ArgTys>
    constexpr basic_string& _Reallocate_for(const size_type _New_size, _Fty _Fn, _ArgTys... _Args) {
        
        
        if (_New_size > max_size()) {
            _Xlen_string(); 
        }

        const size_type _Old_capacity = _Mypair._Myval2._Myres;
        const size_type _New_capacity = _Calculate_growth(_New_size);
        auto& _Al                     = _Getal();
        const pointer _New_ptr        = _Al.allocate(_New_capacity + 1); 


        if (::std:: is_constant_evaluated()) { 
            _Traits::assign(_Unfancy(_New_ptr), _New_capacity + 1, _Elem());
        }
#line 4537 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        _Mypair._Myval2._Orphan_all();
        _Mypair._Myval2._Mysize = _New_size;
        _Mypair._Myval2._Myres  = _New_capacity;
        _Fn(_Unfancy(_New_ptr), _New_size, _Args...);
        if (_BUF_SIZE <= _Old_capacity) {
            _Al.deallocate(_Mypair._Myval2._Bx._Ptr, _Old_capacity + 1);
            _Mypair._Myval2._Bx._Ptr = _New_ptr;
        } else {
            _Construct_in_place(_Mypair._Myval2._Bx._Ptr, _New_ptr);
        }

        return *this;
    }

    template <class _Fty, class... _ArgTys>
    constexpr basic_string& _Reallocate_grow_by(const size_type _Size_increase, _Fty _Fn, _ArgTys... _Args) {
        
        
        auto& _My_data            = _Mypair._Myval2;
        const size_type _Old_size = _My_data._Mysize;
        if (max_size() - _Old_size < _Size_increase) {
            _Xlen_string(); 
        }

        const size_type _New_size     = _Old_size + _Size_increase;
        const size_type _Old_capacity = _My_data._Myres;
        const size_type _New_capacity = _Calculate_growth(_New_size);
        auto& _Al                     = _Getal();
        const pointer _New_ptr        = _Al.allocate(_New_capacity + 1); 


        if (::std:: is_constant_evaluated()) { 
            _Traits::assign(_Unfancy(_New_ptr), _New_capacity + 1, _Elem());
        }
#line 4572 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        _My_data._Orphan_all();
        _My_data._Mysize      = _New_size;
        _My_data._Myres       = _New_capacity;
        _Elem* const _Raw_new = _Unfancy(_New_ptr);
        if (_BUF_SIZE <= _Old_capacity) {
            const pointer _Old_ptr = _My_data._Bx._Ptr;
            _Fn(_Raw_new, _Unfancy(_Old_ptr), _Old_size, _Args...);
            _Al.deallocate(_Old_ptr, _Old_capacity + 1);
            _My_data._Bx._Ptr = _New_ptr;
        } else {
            _Fn(_Raw_new, _My_data._Bx._Buf, _Old_size, _Args...);
            _Construct_in_place(_My_data._Bx._Ptr, _New_ptr);
        }

        return *this;
    }

    void _Become_small() {
        
        
        _Mypair._Myval2._Orphan_all();
        const pointer _Ptr = _Mypair._Myval2._Bx._Ptr;
        auto& _Al          = _Getal();
        _Destroy_in_place(_Mypair._Myval2._Bx._Ptr);
        _Traits::copy(_Mypair._Myval2._Bx._Buf, _Unfancy(_Ptr), _Mypair._Myval2._Mysize + 1);
        _Al.deallocate(_Ptr, _Mypair._Myval2._Myres + 1);
        _Mypair._Myval2._Myres = _BUF_SIZE - 1;
    }

    constexpr void _Eos(const size_type _New_size) { 
        _Traits::assign(_Mypair._Myval2._Myptr()[_Mypair._Myval2._Mysize = _New_size], _Elem());
    }

    constexpr void _Tidy_init() noexcept { 
        auto& _My_data   = _Mypair._Myval2;
        _My_data._Mysize = 0;


        if (::std:: is_constant_evaluated()) {
            _My_data._Myres        = _BUF_SIZE; 
            auto& _Al              = _Getal();
            const pointer _New_ptr = _Al.allocate(_BUF_SIZE + 1); 
            _My_data._Bx._Ptr      = _New_ptr;

            _Elem* const _Raw_new = _Unfancy(_New_ptr);
            _Traits::assign(_Raw_new, _BUF_SIZE + 1, _Elem());
        } else
#line 4623 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        {
            _My_data._Myres = _BUF_SIZE - 1;
            
            _Traits::assign(_My_data._Bx._Buf[0], _Elem());
        }
    }

    constexpr void _Tidy_deallocate() noexcept { 
        _Mypair._Myval2._Orphan_all();
        if (_Mypair._Myval2._Large_string_engaged()) {
            const pointer _Ptr = _Mypair._Myval2._Bx._Ptr;
            auto& _Al          = _Getal();
            _Destroy_in_place(_Mypair._Myval2._Bx._Ptr);
            _Al.deallocate(_Ptr, _Mypair._Myval2._Myres + 1);
        }


        if (::std:: is_constant_evaluated()) {
            _Mypair._Myval2._Bx._Ptr = nullptr;
            _Mypair._Myval2._Mysize  = 0;
            _Mypair._Myval2._Myres   = 0;
        } else
#line 4646 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
        {
            _Mypair._Myval2._Mysize = 0;
            _Mypair._Myval2._Myres  = _BUF_SIZE - 1;
            
            _Traits::assign(_Mypair._Myval2._Bx._Buf[0], _Elem());
        }
    }

public:
    constexpr void _Orphan_all() noexcept { 
        _Mypair._Myval2._Orphan_all();
    }

private:
    constexpr void _Swap_proxy_and_iterators(basic_string& _Right) {
        _Mypair._Myval2._Swap_proxy_and_iterators(_Right._Mypair._Myval2);
    }

    constexpr _Alty& _Getal() noexcept {
        return _Mypair._Get_first();
    }

    constexpr const _Alty& _Getal() const noexcept {
        return _Mypair._Get_first();
    }

    _Compressed_pair<_Alty, _Scary_val> _Mypair;
};


template <class _Iter, class _Alloc = allocator<_Iter_value_t<_Iter>>,
    enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
basic_string(_Iter, _Iter, _Alloc = _Alloc())
    -> basic_string<_Iter_value_t<_Iter>, char_traits<_Iter_value_t<_Iter>>, _Alloc>;

template <class _Elem, class _Traits, class _Alloc = allocator<_Elem>,
    enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
explicit basic_string(basic_string_view<_Elem, _Traits>, const _Alloc& = _Alloc())
    -> basic_string<_Elem, _Traits, _Alloc>;

template <class _Elem, class _Traits, class _Alloc = allocator<_Elem>,
    enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
basic_string(basic_string_view<_Elem, _Traits>, _Guide_size_type_t<_Alloc>, _Guide_size_type_t<_Alloc>,
    const _Alloc& = _Alloc()) -> basic_string<_Elem, _Traits, _Alloc>;
#line 4691 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

template <class _Elem, class _Traits, class _Alloc>
constexpr void swap(basic_string<_Elem, _Traits, _Alloc>& _Left,
    basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept  {
    _Left.swap(_Right);
}

template <class _Elem, class _Traits, class _Alloc>
[[nodiscard]] constexpr basic_string<_Elem, _Traits, _Alloc> operator+(
    const basic_string<_Elem, _Traits, _Alloc>& _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) {
    const auto _Left_size  = _Left.size();
    const auto _Right_size = _Right.size();
    if (_Left.max_size() - _Left_size < _Right_size) {
        _Xlen_string();
    }

    return {_String_constructor_concat_tag{}, _Left, _Left.c_str(), _Left_size, _Right.c_str(), _Right_size};
}

template <class _Elem, class _Traits, class _Alloc>
[[nodiscard]] constexpr basic_string<_Elem, _Traits, _Alloc> operator+(
      const _Elem* const _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) {
    using _Size_type       = typename basic_string<_Elem, _Traits, _Alloc>::size_type;
    const auto _Left_size  = _Convert_size<_Size_type>(_Traits::length(_Left));
    const auto _Right_size = _Right.size();
    if (_Right.max_size() - _Right_size < _Left_size) {
        _Xlen_string();
    }

    return {_String_constructor_concat_tag{}, _Right, _Left, _Left_size, _Right.c_str(), _Right_size};
}

template <class _Elem, class _Traits, class _Alloc>
[[nodiscard]] constexpr basic_string<_Elem, _Traits, _Alloc> operator+(
    const _Elem _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) {
    const auto _Right_size = _Right.size();
    if (_Right_size == _Right.max_size()) {
        _Xlen_string();
    }

    return {_String_constructor_concat_tag{}, _Right, ::std:: addressof(_Left), 1, _Right.c_str(), _Right_size};
}

template <class _Elem, class _Traits, class _Alloc>
[[nodiscard]] constexpr basic_string<_Elem, _Traits, _Alloc> operator+(
    const basic_string<_Elem, _Traits, _Alloc>& _Left,   const _Elem* const _Right) {
    using _Size_type       = typename basic_string<_Elem, _Traits, _Alloc>::size_type;
    const auto _Left_size  = _Left.size();
    const auto _Right_size = _Convert_size<_Size_type>(_Traits::length(_Right));
    if (_Left.max_size() - _Left_size < _Right_size) {
        _Xlen_string();
    }

    return {_String_constructor_concat_tag{}, _Left, _Left.c_str(), _Left_size, _Right, _Right_size};
}

template <class _Elem, class _Traits, class _Alloc>
[[nodiscard]] constexpr basic_string<_Elem, _Traits, _Alloc> operator+(
    const basic_string<_Elem, _Traits, _Alloc>& _Left, const _Elem _Right) {
    const auto _Left_size = _Left.size();
    if (_Left_size == _Left.max_size()) {
        _Xlen_string();
    }

    return {_String_constructor_concat_tag{}, _Left, _Left.c_str(), _Left_size, ::std:: addressof(_Right), 1};
}

template <class _Elem, class _Traits, class _Alloc>
[[nodiscard]] constexpr basic_string<_Elem, _Traits, _Alloc> operator+(
    const basic_string<_Elem, _Traits, _Alloc>& _Left, basic_string<_Elem, _Traits, _Alloc>&& _Right) {
    return ::std:: move(_Right.insert(0, _Left));
}

template <class _Elem, class _Traits, class _Alloc>
[[nodiscard]] constexpr basic_string<_Elem, _Traits, _Alloc> operator+(
    basic_string<_Elem, _Traits, _Alloc>&& _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) {
    return ::std:: move(_Left.append(_Right));
}

template <class _Elem, class _Traits, class _Alloc>
[[nodiscard]] constexpr basic_string<_Elem, _Traits, _Alloc> operator+(
    basic_string<_Elem, _Traits, _Alloc>&& _Left, basic_string<_Elem, _Traits, _Alloc>&& _Right) {


#line 4780 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
    return {_String_constructor_concat_tag{}, _Left, _Right};
}

template <class _Elem, class _Traits, class _Alloc>
[[nodiscard]] constexpr basic_string<_Elem, _Traits, _Alloc> operator+(
      const _Elem* const _Left, basic_string<_Elem, _Traits, _Alloc>&& _Right) {
    return ::std:: move(_Right.insert(0, _Left));
}

template <class _Elem, class _Traits, class _Alloc>
[[nodiscard]] constexpr basic_string<_Elem, _Traits, _Alloc> operator+(
    const _Elem _Left, basic_string<_Elem, _Traits, _Alloc>&& _Right) {
    return ::std:: move(_Right.insert(0, 1, _Left));
}

template <class _Elem, class _Traits, class _Alloc>
[[nodiscard]] constexpr basic_string<_Elem, _Traits, _Alloc> operator+(
    basic_string<_Elem, _Traits, _Alloc>&& _Left,   const _Elem* const _Right) {
    return ::std:: move(_Left.append(_Right));
}

template <class _Elem, class _Traits, class _Alloc>
[[nodiscard]] constexpr basic_string<_Elem, _Traits, _Alloc> operator+(
    basic_string<_Elem, _Traits, _Alloc>&& _Left, const _Elem _Right) {
    _Left.push_back(_Right);
    return ::std:: move(_Left);
}

template <class _Elem, class _Traits, class _Alloc>
[[nodiscard]] constexpr bool operator==(
    const basic_string<_Elem, _Traits, _Alloc>& _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept {
    return _Left._Equal(_Right);
}

template <class _Elem, class _Traits, class _Alloc>
[[nodiscard]] constexpr bool operator==(
    const basic_string<_Elem, _Traits, _Alloc>& _Left,   const _Elem* const _Right) {
    return _Left._Equal(_Right);
}


template <class _Elem, class _Traits, class _Alloc>
[[nodiscard]] constexpr _Get_comparison_category_t<_Traits> operator<=>(
    const basic_string<_Elem, _Traits, _Alloc>& _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) noexcept {
    return static_cast<_Get_comparison_category_t<_Traits>>(_Left.compare(_Right) <=> 0);
}

template <class _Elem, class _Traits, class _Alloc>
[[nodiscard]] constexpr _Get_comparison_category_t<_Traits> operator<=>(
    const basic_string<_Elem, _Traits, _Alloc>& _Left,   const _Elem* const _Right) {
    return static_cast<_Get_comparison_category_t<_Traits>>(_Left.compare(_Right) <=> 0);
}


#line 4918 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

using string  = basic_string<char, char_traits<char>, allocator<char>>;
using wstring = basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t>>;

using u8string = basic_string<char8_t, char_traits<char8_t>, allocator<char8_t>>;
#line 4924 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
using u16string = basic_string<char16_t, char_traits<char16_t>, allocator<char16_t>>;
using u32string = basic_string<char32_t, char_traits<char32_t>, allocator<char32_t>>;

template <class _Elem, class _Traits, class _Alloc>
struct hash<basic_string<_Elem, _Traits, _Alloc>> {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef basic_string<_Elem, _Traits, _Alloc> _Unnameable_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef size_t _Unnameable_result;

    [[nodiscard]] size_t operator()(const basic_string<_Elem, _Traits, _Alloc>& _Keyval) const noexcept {
        return _Hash_array_representation(_Keyval.c_str(), _Keyval.size());
    }
};

template <class _Elem, class _Traits, class _Alloc>
basic_istream<_Elem, _Traits>& operator>>(
    basic_istream<_Elem, _Traits>& _Istr, basic_string<_Elem, _Traits, _Alloc>& _Str) {
    using _Myis   = basic_istream<_Elem, _Traits>;
    using _Ctype  = typename _Myis::_Ctype;
    using _Mystr  = basic_string<_Elem, _Traits, _Alloc>;
    using _Mysizt = typename _Mystr::size_type;

    typename _Myis::iostate _State = _Myis::goodbit;
    bool _Changed                  = false;
    const typename _Myis::sentry _Ok(_Istr);

    if (_Ok) { 
        const _Ctype& _Ctype_fac = ::std:: use_facet<_Ctype>(_Istr.getloc());
        _Str.erase();

        try {
        _Mysizt _Size;
        if (0 < _Istr.width() && static_cast<_Mysizt>(_Istr.width()) < _Str.max_size()) {
            _Size = static_cast<_Mysizt>(_Istr.width());
        } else {
            _Size = _Str.max_size();
        }

        typename _Traits::int_type _Meta = _Istr.rdbuf()->sgetc();

        for (; 0 < _Size; --_Size, _Meta = _Istr.rdbuf()->snextc()) {
            if (_Traits::eq_int_type(_Traits::eof(), _Meta)) { 
                _State |= _Myis::eofbit;
                break;
            } else if (_Ctype_fac.is(_Ctype::space, _Traits::to_char_type(_Meta))) {
                break; 
            } else { 
                _Str.push_back(_Traits::to_char_type(_Meta));
                _Changed = true;
            }
        }
        } catch (...) { (_Istr) .setstate(_Myis::badbit, true); }
    }

    _Istr.width(0);
    if (!_Changed) {
        _State |= _Myis::failbit;
    }

    _Istr.setstate(_State);
    return _Istr;
}

template <class _Elem, class _Traits, class _Alloc>
basic_ostream<_Elem, _Traits>& operator<<(
    basic_ostream<_Elem, _Traits>& _Ostr, const basic_string<_Elem, _Traits, _Alloc>& _Str) {
    return _Insert_string(_Ostr, _Str.data(), _Str.size());
}

inline namespace literals {
    inline namespace string_literals {


#line 5000 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

        [[nodiscard]] constexpr string operator"" s(const char* _Str, size_t _Len) {
            return string(_Str, _Len);
        }

        [[nodiscard]] constexpr wstring operator"" s(const wchar_t* _Str, size_t _Len) {
            return wstring(_Str, _Len);
        }


        [[nodiscard]] constexpr basic_string<char8_t> operator"" s(const char8_t* _Str, size_t _Len) {
            return basic_string<char8_t>(_Str, _Len);
        }
#line 5014 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"

        [[nodiscard]] constexpr u16string operator"" s(const char16_t* _Str, size_t _Len) {
            return u16string(_Str, _Len);
        }

        [[nodiscard]] constexpr u32string operator"" s(const char32_t* _Str, size_t _Len) {
            return u32string(_Str, _Len);
        }


    } 
} 


template <class _Elem, class _Traits, class _Alloc, class _Uty>
constexpr typename basic_string<_Elem, _Traits, _Alloc>::size_type erase(
    basic_string<_Elem, _Traits, _Alloc>& _Cont, const _Uty& _Val) {
    return _Erase_remove(_Cont, _Val);
}

template <class _Elem, class _Traits, class _Alloc, class _Pr>
constexpr typename basic_string<_Elem, _Traits, _Alloc>::size_type erase_if(
    basic_string<_Elem, _Traits, _Alloc>& _Cont, _Pr _Pred) {
    return _Erase_remove_if(_Cont, _Pass_fn(_Pred));
}
#line 5041 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"


namespace pmr {
    template <class _Elem, class _Traits = char_traits<_Elem>>
    using basic_string = ::std:: basic_string<_Elem, _Traits, polymorphic_allocator<_Elem>>;

    using string = basic_string<char>;

    using u8string = basic_string<char8_t>;
#line 5051 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
    using u16string = basic_string<char16_t>;
    using u32string = basic_string<char32_t>;
    using wstring   = basic_string<wchar_t>;
} 
#line 5056 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
}


#pragma warning(pop)
#pragma pack(pop)
#line 5063 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
#line 5064 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xstring"
#line 14 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\bitset"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
template <size_t _Bits>
class bitset { 
public:
#pragma warning(push)
#pragma warning(disable : 4296) 
    using _Ty = conditional_t<_Bits <= sizeof(unsigned long) * 8, unsigned long, unsigned long long>;
#pragma warning(pop)

    class reference { 
        friend bitset<_Bits>;

    public:
        ~reference() noexcept {} 

        reference& operator=(bool _Val) noexcept {
            _Pbitset->_Set_unchecked(_Mypos, _Val);
            return *this;
        }

        reference& operator=(const reference& _Bitref) noexcept {
            _Pbitset->_Set_unchecked(_Mypos, static_cast<bool>(_Bitref));
            return *this;
        }

        reference& flip() noexcept {
            _Pbitset->_Flip_unchecked(_Mypos);
            return *this;
        }

        [[nodiscard]] bool operator~() const noexcept {
            return !_Pbitset->_Subscript(_Mypos);
        }

        operator bool() const noexcept {
            return _Pbitset->_Subscript(_Mypos);
        }

    private:
        reference() noexcept : _Pbitset(nullptr), _Mypos(0) {}

        reference(bitset<_Bits>& _Bitset, size_t _Pos) : _Pbitset(&_Bitset), _Mypos(_Pos) {}

        bitset<_Bits>* _Pbitset;
        size_t _Mypos; 
    };

    static void _Validate(size_t _Pos) { 

        (void) _Pos;


#line 75 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\bitset"
    }

    constexpr bool _Subscript(size_t _Pos) const {
        return (_Array[_Pos / _Bitsperword] & (_Ty{1} << _Pos % _Bitsperword)) != 0;
    }

    [[nodiscard]] constexpr bool operator[](size_t _Pos) const {

        return _Subscript(_Pos);


#line 88 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\bitset"
    }

    [[nodiscard]] reference operator[](size_t _Pos) {
        _Validate(_Pos);
        return reference(*this, _Pos);
    }

    constexpr bitset() noexcept : _Array() {} 

    static constexpr bool _Need_mask = _Bits < 8 * sizeof(unsigned long long);

    static constexpr unsigned long long _Mask = (1ULL << (_Need_mask ? _Bits : 0)) - 1ULL;

    constexpr bitset(unsigned long long _Val) noexcept : _Array{static_cast<_Ty>(_Need_mask ? _Val & _Mask : _Val)} {}

    template <class _Traits, class _Elem>
    void _Construct(const _Elem* const _Ptr, size_t _Count, const _Elem _Elem0, const _Elem _Elem1) {
        if (_Count > _Bits) {
            for (size_t _Idx = _Bits; _Idx < _Count; ++_Idx) {
                const auto _Ch = _Ptr[_Idx];
                if (!_Traits::eq(_Elem1, _Ch) && !_Traits::eq(_Elem0, _Ch)) {
                    _Xinv();
                }
            }

            _Count = _Bits;
        }

        size_t _Wpos = 0;
        if (_Count != 0) {
            size_t _Bits_used_in_word = 0;
            auto _Last                = _Ptr + _Count;
            _Ty _This_word            = 0;
            do {
                --_Last;
                const auto _Ch = *_Last;
                _This_word |= static_cast<_Ty>(_Traits::eq(_Elem1, _Ch)) << _Bits_used_in_word;
                if (!_Traits::eq(_Elem1, _Ch) && !_Traits::eq(_Elem0, _Ch)) {
                    _Xinv();
                }

                if (++_Bits_used_in_word == _Bitsperword) {
                    _Array[_Wpos] = _This_word;
                    ++_Wpos;
                    _This_word         = 0;
                    _Bits_used_in_word = 0;
                }
            } while (_Ptr != _Last);

            if (_Bits_used_in_word != 0) {
                _Array[_Wpos] = _This_word;
                ++_Wpos;
            }
        }

        for (; _Wpos <= _Words; ++_Wpos) {
            _Array[_Wpos] = 0;
        }
    }

    template <class _Elem, class _Traits, class _Alloc>
    explicit bitset(const basic_string<_Elem, _Traits, _Alloc>& _Str,
        typename basic_string<_Elem, _Traits, _Alloc>::size_type _Pos   = 0,
        typename basic_string<_Elem, _Traits, _Alloc>::size_type _Count = basic_string<_Elem, _Traits, _Alloc>::npos,
        _Elem _Elem0 = static_cast<_Elem>('0'), _Elem _Elem1 = static_cast<_Elem>('1')) {
        
        if (_Str.size() < _Pos) {
            _Xran(); 
        }

        if (_Str.size() - _Pos < _Count) {
            _Count = _Str.size() - _Pos; 
        }

        _Construct<_Traits>(_Str.data() + _Pos, _Count, _Elem0, _Elem1);
    }

    template <class _Elem>
    explicit bitset(const _Elem* _Ntcts, typename basic_string<_Elem>::size_type _Count = basic_string<_Elem>::npos,
        _Elem _Elem0 = static_cast<_Elem>('0'), _Elem _Elem1 = static_cast<_Elem>('1')) {
        if (_Count == basic_string<_Elem>::npos) {
            _Count = char_traits<_Elem>::length(_Ntcts);
        }

        _Construct<char_traits<_Elem>>(_Ntcts, _Count, _Elem0, _Elem1);
    }

    bitset& operator&=(const bitset& _Right) noexcept {
        for (size_t _Wpos = 0; _Wpos <= _Words; ++_Wpos) {
            _Array[_Wpos] &= _Right._Array[_Wpos];
        }

        return *this;
    }

    bitset& operator|=(const bitset& _Right) noexcept {
        for (size_t _Wpos = 0; _Wpos <= _Words; ++_Wpos) {
            _Array[_Wpos] |= _Right._Array[_Wpos];
        }

        return *this;
    }

    bitset& operator^=(const bitset& _Right) noexcept {
        for (size_t _Wpos = 0; _Wpos <= _Words; ++_Wpos) {
            _Array[_Wpos] ^= _Right._Array[_Wpos];
        }

        return *this;
    }

    bitset& operator<<=(size_t _Pos) noexcept { 
        const auto _Wordshift = static_cast<ptrdiff_t>(_Pos / _Bitsperword);
        if (_Wordshift != 0) {
            for (ptrdiff_t _Wpos = _Words; 0 <= _Wpos; --_Wpos) {
                _Array[_Wpos] = _Wordshift <= _Wpos ? _Array[_Wpos - _Wordshift] : 0;
            }
        }

        if ((_Pos %= _Bitsperword) != 0) { 
            for (ptrdiff_t _Wpos = _Words; 0 < _Wpos; --_Wpos) {
                _Array[_Wpos] = (_Array[_Wpos] << _Pos) | (_Array[_Wpos - 1] >> (_Bitsperword - _Pos));
            }

            _Array[0] <<= _Pos;
        }
        _Trim();
        return *this;
    }

    bitset& operator>>=(size_t _Pos) noexcept { 
        const auto _Wordshift = static_cast<ptrdiff_t>(_Pos / _Bitsperword);
        if (_Wordshift != 0) {
            for (ptrdiff_t _Wpos = 0; _Wpos <= _Words; ++_Wpos) {
                _Array[_Wpos] = _Wordshift <= _Words - _Wpos ? _Array[_Wpos + _Wordshift] : 0;
            }
        }

        if ((_Pos %= _Bitsperword) != 0) { 
            for (ptrdiff_t _Wpos = 0; _Wpos < _Words; ++_Wpos) {
                _Array[_Wpos] = (_Array[_Wpos] >> _Pos) | (_Array[_Wpos + 1] << (_Bitsperword - _Pos));
            }

            _Array[_Words] >>= _Pos;
        }
        return *this;
    }

    bitset& set() noexcept { 
        :: memset(&_Array, 0xFF, sizeof(_Array));
        _Trim();
        return *this;
    }

    bitset& set(size_t _Pos, bool _Val = true) { 
        if (_Bits <= _Pos) {
            _Xran(); 
        }

        return _Set_unchecked(_Pos, _Val);
    }

    bitset& reset() noexcept { 
        :: memset(&_Array, 0, sizeof(_Array));
        return *this;
    }

    bitset& reset(size_t _Pos) { 
        return set(_Pos, false);
    }

    [[nodiscard]] bitset operator~() const noexcept { 
        bitset _Tmp = *this;
        _Tmp.flip();
        return _Tmp;
    }

    bitset& flip() noexcept { 
        for (size_t _Wpos = 0; _Wpos <= _Words; ++_Wpos) {
            _Array[_Wpos] = ~_Array[_Wpos];
        }

        _Trim();
        return *this;
    }

    bitset& flip(size_t _Pos) { 
        if (_Bits <= _Pos) {
            _Xran(); 
        }

        return _Flip_unchecked(_Pos);
    }

    [[nodiscard]] unsigned long to_ulong() const {
        constexpr bool _Bits_zero  = _Bits == 0;
        constexpr bool _Bits_small = _Bits <= 32;
        constexpr bool _Bits_large = _Bits > 64;
        if constexpr (_Bits_zero) {
            return 0;
        } else if constexpr (_Bits_small) {
            return static_cast<unsigned long>(_Array[0]);
        } else {
            if constexpr (_Bits_large) {
                for (size_t _Idx = 1; _Idx <= _Words; ++_Idx) {
                    if (_Array[_Idx] != 0) {
                        _Xoflo(); 
                    }
                }
            }

            if (_Array[0] > 0xffffffffUL) {
                _Xoflo();
            }

            return static_cast<unsigned long>(_Array[0]);
        }
    }

    [[nodiscard]] unsigned long long to_ullong() const {
        constexpr bool _Bits_zero  = _Bits == 0;
        constexpr bool _Bits_large = _Bits > 64;
        if constexpr (_Bits_zero) {
            return 0;
        } else {
            if constexpr (_Bits_large) {
                for (size_t _Idx = 1; _Idx <= _Words; ++_Idx) {
                    if (_Array[_Idx] != 0) {
                        _Xoflo(); 
                    }
                }
            }

            return _Array[0];
        }
    }

    template <class _Elem = char, class _Tr = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
    [[nodiscard]] basic_string<_Elem, _Tr, _Alloc> to_string(
        _Elem _Elem0 = static_cast<_Elem>('0'), _Elem _Elem1 = static_cast<_Elem>('1')) const {
        
        basic_string<_Elem, _Tr, _Alloc> _Str;
        _Str.reserve(_Bits);

        for (auto _Pos = _Bits; 0 < _Pos;) {
            _Str.push_back(_Subscript(--_Pos) ? _Elem1 : _Elem0);
        }

        return _Str;
    }

    [[nodiscard]] size_t count() const noexcept { 
        return _Select_popcount_impl<_Ty>([this](auto _Popcount_impl) {
            size_t _Val = 0;
            for (size_t _Wpos = 0; _Wpos <= _Words; ++_Wpos) {
                _Val += _Popcount_impl(_Array[_Wpos]);
            }

            return _Val;
        });
    }

    [[nodiscard]] constexpr size_t size() const noexcept {
        return _Bits;
    }

    [[nodiscard]] bool operator==(const bitset& _Right) const noexcept {
        return :: memcmp(&_Array[0], &_Right._Array[0], sizeof(_Array)) == 0;
    }


#line 363 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\bitset"

    [[nodiscard]] bool test(size_t _Pos) const {
        if (_Bits <= _Pos) {
            _Xran(); 
        }

        return _Subscript(_Pos);
    }

    [[nodiscard]] bool any() const noexcept {
        for (size_t _Wpos = 0; _Wpos <= _Words; ++_Wpos) {
            if (_Array[_Wpos] != 0) {
                return true;
            }
        }

        return false;
    }

    [[nodiscard]] bool none() const noexcept {
        return !any();
    }

    [[nodiscard]] bool all() const noexcept {
        constexpr bool _Zero_length = _Bits == 0;
        if constexpr (_Zero_length) { 
            return true;
        }

        constexpr bool _No_padding = _Bits % _Bitsperword == 0;
        for (size_t _Wpos = 0; _Wpos < _Words + _No_padding; ++_Wpos) {
            if (_Array[_Wpos] != ~static_cast<_Ty>(0)) {
                return false;
            }
        }

        return _No_padding || _Array[_Words] == (static_cast<_Ty>(1) << (_Bits % _Bitsperword)) - 1;
    }

    [[nodiscard]] bitset operator<<(size_t _Pos) const noexcept {
        bitset _Tmp = *this;
        _Tmp <<= _Pos;
        return _Tmp;
    }

    [[nodiscard]] bitset operator>>(size_t _Pos) const noexcept {
        bitset _Tmp = *this;
        _Tmp >>= _Pos;
        return _Tmp;
    }

    [[nodiscard]] _Ty _Getword(size_t _Wpos) const noexcept { 
        return _Array[_Wpos];
    }

private:
    friend hash<bitset<_Bits>>;

    static constexpr ptrdiff_t _Bitsperword = 8 * sizeof(_Ty);
    static constexpr ptrdiff_t _Words       = _Bits == 0 ? 0 : (_Bits - 1) / _Bitsperword; 

    void _Trim() noexcept { 
        constexpr bool _Work_to_do = _Bits == 0 || _Bits % _Bitsperword != 0;
        if constexpr (_Work_to_do) {
            _Array[_Words] &= (_Ty{1} << _Bits % _Bitsperword) - 1;
        }
    }

    bitset& _Set_unchecked(size_t _Pos, bool _Val) noexcept { 
        auto& _Selected_word = _Array[_Pos / _Bitsperword];
        const auto _Bit      = _Ty{1} << _Pos % _Bitsperword;
        if (_Val) {
            _Selected_word |= _Bit;
        } else {
            _Selected_word &= ~_Bit;
        }

        return *this;
    }

    bitset& _Flip_unchecked(size_t _Pos) noexcept { 
        _Array[_Pos / _Bitsperword] ^= _Ty{1} << _Pos % _Bitsperword;
        return *this;
    }

    [[noreturn]] void _Xinv() const {
        _Xinvalid_argument("invalid bitset char");
    }

    [[noreturn]] void _Xoflo() const {
        _Xoverflow_error("bitset overflow");
    }

    [[noreturn]] void _Xran() const {
        _Xout_of_range("invalid bitset position");
    }

    _Ty _Array[_Words + 1];
};

template <size_t _Bits>
[[nodiscard]] bitset<_Bits> operator&(const bitset<_Bits>& _Left, const bitset<_Bits>& _Right) noexcept {
    bitset<_Bits> _Ans = _Left;
    _Ans &= _Right;
    return _Ans;
}

template <size_t _Bits>
[[nodiscard]] bitset<_Bits> operator|(const bitset<_Bits>& _Left, const bitset<_Bits>& _Right) noexcept {
    bitset<_Bits> _Ans = _Left;
    _Ans |= _Right;
    return _Ans;
}

template <size_t _Bits>
[[nodiscard]] bitset<_Bits> operator^(const bitset<_Bits>& _Left, const bitset<_Bits>& _Right) noexcept {
    bitset<_Bits> _Ans = _Left;
    _Ans ^= _Right;
    return _Ans;
}

template <class _Elem, class _Tr, size_t _Bits>
basic_ostream<_Elem, _Tr>& operator<<(basic_ostream<_Elem, _Tr>& _Ostr, const bitset<_Bits>& _Right) {
    using _Ctype             = typename basic_ostream<_Elem, _Tr>::_Ctype;
    const _Ctype& _Ctype_fac = ::std:: use_facet<_Ctype>(_Ostr.getloc());
    const _Elem _Elem0       = _Ctype_fac.widen('0');
    const _Elem _Elem1       = _Ctype_fac.widen('1');

    return _Ostr << _Right.template to_string<_Elem, _Tr, allocator<_Elem>>(_Elem0, _Elem1);
}

template <class _Elem, class _Tr, size_t _Bits>
basic_istream<_Elem, _Tr>& operator>>(basic_istream<_Elem, _Tr>& _Istr, bitset<_Bits>& _Right) {
    using _Istr_t                    = basic_istream<_Elem, _Tr>;
    using _Ctype                     = typename _Istr_t::_Ctype;
    const _Ctype& _Ctype_fac         = ::std:: use_facet<_Ctype>(_Istr.getloc());
    const _Elem _Elem0               = _Ctype_fac.widen('0');
    const _Elem _Elem1               = _Ctype_fac.widen('1');
    typename _Istr_t::iostate _State = _Istr_t::goodbit;
    bool _Changed                    = false;
    string _Str;
    const typename _Istr_t::sentry _Ok(_Istr);

    if (_Ok) { 
        try {
        typename _Tr::int_type _Meta = _Istr.rdbuf()->sgetc();
        for (size_t _Count = _Right.size(); 0 < _Count; _Meta = _Istr.rdbuf()->snextc(), (void) --_Count) {
            
            _Elem _Char;
            if (_Tr::eq_int_type(_Tr::eof(), _Meta)) { 
                _State |= _Istr_t::eofbit;
                break;
            } else if ((_Char = _Tr::to_char_type(_Meta)) != _Elem0 && _Char != _Elem1) {
                break; 
            } else if (_Str.max_size() <= _Str.size()) { 
                _State |= _Istr_t::failbit;
                break;
            } else { 
                _Str.push_back('0' + (_Char == _Elem1));
                _Changed = true;
            }
        }
        } catch (...) { (_Istr) .setstate(_Istr_t::badbit, true); }
    }

    constexpr bool _Has_bits = _Bits > 0;

    if constexpr (_Has_bits) {
        if (!_Changed) {
            _State |= _Istr_t::failbit;
        }
    }

    _Istr.setstate(_State);
    _Right = bitset<_Bits>(_Str); 
    return _Istr;
}

template <size_t _Bits>
struct hash<bitset<_Bits>> {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef bitset<_Bits> _Unnameable_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef size_t _Unnameable_result;

    [[nodiscard]] size_t operator()(const bitset<_Bits>& _Keyval) const noexcept {
        return _Hash_representation(_Keyval._Array);
    }
};
}


#pragma warning(pop)
#pragma pack(pop)
#line 557 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\bitset"
#line 558 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\bitset"
#line 14 "all-std.cxx"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ctime"


#pragma once


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\time.h"


#pragma once


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


typedef long clock_t;

struct _timespec32
{
    __time32_t tv_sec;
    long       tv_nsec;
};

struct _timespec64
{
    __time64_t tv_sec;
    long       tv_nsec;
};


    struct timespec
    {
        time_t tv_sec;  
        long   tv_nsec; 
    };
#line 49 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\time.h"


  __declspec(deprecated("This function or variable may be unsafe. Consider using " "_get_daylight" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
 int* __cdecl __daylight(void);


  __declspec(deprecated("This function or variable may be unsafe. Consider using " "_get_dstbias" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
 long* __cdecl __dstbias(void);


  __declspec(deprecated("This function or variable may be unsafe. Consider using " "_get_timezone" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
 long* __cdecl __timezone(void);


    __declspec(deprecated("This function or variable may be unsafe. Consider using " "_get_tzname" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
 char** __cdecl __tzname(void);


 errno_t __cdecl _get_daylight(
      int* _Daylight
    );

 
 errno_t __cdecl _get_dstbias(
      long* _DaylightSavingsBias
    );

  
 errno_t __cdecl _get_timezone(
      long* _TimeZone
    );

 
 errno_t __cdecl _get_tzname(
                             size_t* _ReturnValue,
      char*   _Buffer,
                              size_t  _SizeInBytes,
                              int     _Index
    );


  __declspec(deprecated("This function or variable may be unsafe. Consider using " "asctime_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
 char* __cdecl asctime(
      struct tm const* _Tm
    );


     errno_t __cdecl asctime_s(
            char*            _Buffer,
                                            size_t           _SizeInBytes,
                                                         struct tm const* _Tm
        );
#line 134 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\time.h"

extern "C++" { template <size_t _Size> inline errno_t __cdecl asctime_s(  char (&_Buffer)[_Size],   struct tm const* _Time) throw() { return asctime_s(_Buffer, _Size, _Time); } }
#line 140 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\time.h"

 
 clock_t __cdecl clock(void);

 
  __declspec(deprecated("This function or variable may be unsafe. Consider using " "_ctime32_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
 char* __cdecl _ctime32(
      __time32_t const* _Time
    );


 errno_t __cdecl _ctime32_s(
        char*             _Buffer,
                                        size_t            _SizeInBytes,
                                                     __time32_t const* _Time
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl _ctime32_s(  char (&_Buffer)[_Size],   __time32_t const* _Time) throw() { return _ctime32_s(_Buffer, _Size, _Time); } }
#line 163 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\time.h"

 
  __declspec(deprecated("This function or variable may be unsafe. Consider using " "_ctime64_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
 char* __cdecl _ctime64(
      __time64_t const* _Time
    );


 errno_t __cdecl _ctime64_s(
        char*             _Buffer,
                                          size_t            _SizeInBytes,
                                                       __time64_t const* _Time
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl _ctime64_s(  char (&_Buffer)[_Size],   __time64_t const* _Time) throw() { return _ctime64_s(_Buffer, _Size, _Time); } }
#line 183 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\time.h"

 
 double __cdecl _difftime32(
      __time32_t _Time1,
      __time32_t _Time2
    );

 
 double __cdecl _difftime64(
      __time64_t _Time1,
      __time64_t _Time2
    );

 
  __declspec(deprecated("This function or variable may be unsafe. Consider using " "_gmtime32_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
 struct tm* __cdecl _gmtime32(
      __time32_t const* _Time
    );


 errno_t __cdecl _gmtime32_s(
      struct tm*        _Tm,
       __time32_t const* _Time
    );

 
  __declspec(deprecated("This function or variable may be unsafe. Consider using " "_gmtime64_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
 struct tm* __cdecl _gmtime64(
      __time64_t const* _Time
    );


 errno_t __cdecl _gmtime64_s(
      struct tm*        _Tm,
       __time64_t const* _Time
    );

 
  __declspec(deprecated("This function or variable may be unsafe. Consider using " "_localtime32_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
 struct tm* __cdecl _localtime32(
      __time32_t const* _Time
    );


 errno_t __cdecl _localtime32_s(
      struct tm*        _Tm,
       __time32_t const* _Time
    );

 
  __declspec(deprecated("This function or variable may be unsafe. Consider using " "_localtime64_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
 struct tm* __cdecl _localtime64(
      __time64_t const* _Time
    );


 errno_t __cdecl _localtime64_s(
      struct tm*        _Tm,
       __time64_t const* _Time
    );

 
 __time32_t __cdecl _mkgmtime32(
      struct tm* _Tm
    );

 
 __time64_t __cdecl _mkgmtime64(
      struct tm* _Tm
    );


 __time32_t __cdecl _mktime32(
      struct tm* _Tm
    );


 __time64_t __cdecl _mktime64(
      struct tm* _Tm
    );

 
 size_t __cdecl strftime(
       char*            _Buffer,
                               size_t           _SizeInBytes,
        char const*      _Format,
                               struct tm const* _Tm
    );

 
 size_t __cdecl _strftime_l(
           char*            _Buffer,
                               size_t           _MaxSize,
        char const*      _Format,
                               struct tm const* _Tm,
                           _locale_t        _Locale
    );


 errno_t __cdecl _strdate_s(
       char*  _Buffer,
                                                                              size_t _SizeInBytes
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl _strdate_s(  char (&_Buffer)[_Size]) throw() { return _strdate_s(_Buffer, _Size); } }
#line 293 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\time.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "_strdate_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))   char* __cdecl _strdate( char *_Buffer);
#line 298 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\time.h"


 errno_t __cdecl _strtime_s(
       char*  _Buffer,
                                                                              size_t _SizeInBytes
    );

extern "C++" { template <size_t _Size> inline errno_t __cdecl _strtime_s(  char (&_Buffer)[_Size]) throw() { return _strtime_s(_Buffer, _Size); } }
#line 309 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\time.h"

__declspec(deprecated("This function or variable may be unsafe. Consider using " "_strtime_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))  char* __cdecl _strtime( char *_Buffer);
#line 314 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\time.h"

 __time32_t __cdecl _time32(
      __time32_t* _Time
    );

 __time64_t __cdecl _time64(
      __time64_t* _Time
    );

 
 int __cdecl _timespec32_get(
      struct _timespec32* _Ts,
       int                 _Base
    );

 
 int __cdecl _timespec64_get(
      struct _timespec64* _Ts,
       int                 _Base
    );


     void __cdecl _tzset(void);

    
    __declspec(deprecated("This function or variable has been superceded by newer library " "or operating system functionality. Consider using " "GetLocalTime" " " "instead. See online help for details."))
     unsigned __cdecl _getsystime(
          struct tm* _Tm
        );

    __declspec(deprecated("This function or variable has been superceded by newer library " "or operating system functionality. Consider using " "SetLocalTime" " " "instead. See online help for details."))
     unsigned __cdecl _setsystime(
          struct tm* _Tm,
          unsigned   _Milliseconds
        );

#line 361 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\time.h"


          __declspec(deprecated("This function or variable may be unsafe. Consider using " "ctime_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
        static __inline char* __cdecl ctime(
              time_t const* const _Time
            )
        {
            return _ctime64(_Time);
        }

         
        static __inline double __cdecl difftime(
              time_t const _Time1,
              time_t const _Time2
            )
        {
            return _difftime64(_Time1, _Time2);
        }

          __declspec(deprecated("This function or variable may be unsafe. Consider using " "gmtime_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
        static __inline struct tm* __cdecl gmtime(
              time_t const* const _Time)
        {
            return _gmtime64(_Time);
        }

        __declspec(deprecated("This function or variable may be unsafe. Consider using " "localtime_s" " instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. " "See online help for details."))
        static __inline struct tm* __cdecl localtime(
              time_t const* const _Time
            )
        {
            return _localtime64(_Time);
        }

         
        static __inline time_t __cdecl _mkgmtime(
              struct tm* const _Tm
            )
        {
            return _mkgmtime64(_Tm);
        }

        
        static __inline time_t __cdecl mktime(
              struct tm* const _Tm
            )
        {
            return _mktime64(_Tm);
        }

        static __inline time_t __cdecl time(
              time_t* const _Time
            )
        {
            return _time64(_Time);
        }

         
        static __inline int __cdecl timespec_get(
              struct timespec* const _Ts,
               int              const _Base
            )
        {
            return _timespec64_get((struct _timespec64*)_Ts, _Base);
        }

        
            static __inline errno_t __cdecl ctime_s(
                    char*         const _Buffer,
                                                    size_t        const _SizeInBytes,
                                                                 time_t const* const _Time
                )
            {
                return _ctime64_s(_Buffer, _SizeInBytes, _Time);
            }

            
            static __inline errno_t __cdecl gmtime_s(
                  struct tm*    const _Tm,
                   time_t const* const _Time
                )
            {
                return _gmtime64_s(_Tm, _Time);
            }

            
            static __inline errno_t __cdecl localtime_s(
                  struct tm*    const _Tm,
                   time_t const* const _Time
                )
            {
                return _localtime64_s(_Tm, _Time);
            }
        #line 563 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\time.h"

    #line 565 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\time.h"

#line 567 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\time.h"


        __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_tzset" ". See online help for details."))  void __cdecl tzset(void);
    #line 582 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\time.h"

#line 584 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\time.h"


} __pragma(pack(pop))

#pragma warning(pop) 
#line 591 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\time.h"
#line 13 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ctime"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
using :: clock_t;
using :: size_t;
using :: time_t;
using :: tm;
using :: asctime;
using :: clock;
using :: ctime;
using :: difftime;
using :: gmtime;
using :: localtime;
using :: mktime;
using :: strftime;
using :: time;

using :: timespec;
using :: timespec_get;
#line 39 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ctime"
}


#pragma warning(pop)
#pragma pack(pop)

#line 47 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ctime"
#line 48 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ctime"
#line 12 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ratio"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
[[nodiscard]] constexpr intmax_t _Abs(const intmax_t _Val) noexcept {
    return _Val < 0 ? -_Val : _Val;
}

template <intmax_t _Ax, intmax_t _Bx, bool _Sfinae = false,
    bool _Good = _Abs(_Ax) <= 9223372036854775807i64 / (_Bx == 0 ? 1 : _Abs(_Bx))>
struct _Safe_mult : integral_constant<intmax_t, _Ax * _Bx> {}; 

template <intmax_t _Ax, intmax_t _Bx, bool _Sfinae>
struct _Safe_mult<_Ax, _Bx, _Sfinae, false> { 
    static_assert(_Sfinae, "integer arithmetic overflow");
};

[[nodiscard]] constexpr intmax_t _Sign_of(const intmax_t _Val) noexcept {
    return _Val < 0 ? -1 : 1;
}

inline void _Safe_add_integer_arithmetic_overflow_error() noexcept {}

[[nodiscard]] constexpr intmax_t _Safe_add(const intmax_t _Ax, const intmax_t _Bx) noexcept {
    if (_Sign_of(_Ax) == _Sign_of(_Bx) && _Abs(_Ax) > 9223372036854775807i64 - _Abs(_Bx)) {
        _Safe_add_integer_arithmetic_overflow_error();
    }

    return _Ax + _Bx;
}

[[nodiscard]] constexpr intmax_t _Gcd(intmax_t _Ax, intmax_t _Bx) noexcept {
    
    if (_Ax == 0 && _Bx == 0) {
        return 1; 
    }

    _Ax = _Abs(_Ax);
    _Bx = _Abs(_Bx);

    while (_Bx != 0) {
        const intmax_t _Ax2 = _Ax;
        _Ax                 = _Bx;
        _Bx                 = _Ax2 % _Bx;
    }

    return _Ax;
}

template <intmax_t _Nx, intmax_t _Dx = 1>
struct ratio { 
    static_assert(_Dx != 0, "zero denominator");
    static_assert(-9223372036854775807i64 <= _Nx, "numerator too negative");
    static_assert(-9223372036854775807i64 <= _Dx, "denominator too negative");

    static constexpr intmax_t num = _Sign_of(_Nx) * _Sign_of(_Dx) * _Abs(_Nx) / _Gcd(_Nx, _Dx);
    static constexpr intmax_t den = _Abs(_Dx) / _Gcd(_Nx, _Dx);

    using type = ratio<num, den>;
};

template <class _Ty>
inline constexpr bool _Is_ratio_v = false; 

template <intmax_t _Rx1, intmax_t _Rx2>
inline constexpr bool _Is_ratio_v<ratio<_Rx1, _Rx2>> = true;

template <class _Rx1, class _Rx2>
struct _Ratio_add { 
    static_assert(_Is_ratio_v<_Rx1> && _Is_ratio_v<_Rx2>, "ratio_add<R1, R2> requires R1 and R2 to be ratio<>s.");

    static constexpr intmax_t _Nx1 = _Rx1::num;
    static constexpr intmax_t _Dx1 = _Rx1::den;
    static constexpr intmax_t _Nx2 = _Rx2::num;
    static constexpr intmax_t _Dx2 = _Rx2::den;

    static constexpr intmax_t _Gx = _Gcd(_Dx1, _Dx2);

    
    using type = typename ratio<_Safe_add(_Safe_mult<_Nx1, _Dx2 / _Gx>::value, _Safe_mult<_Nx2, _Dx1 / _Gx>::value),
        _Safe_mult<_Dx1, _Dx2 / _Gx>::value>::type;
};

template <class _Rx1, class _Rx2>
using ratio_add = typename _Ratio_add<_Rx1, _Rx2>::type;

template <class _Rx1, class _Rx2>
struct _Ratio_subtract { 
    static_assert(_Is_ratio_v<_Rx1> && _Is_ratio_v<_Rx2>, "ratio_subtract<R1, R2> requires R1 and R2 to be ratio<>s.");

    static constexpr intmax_t _Nx2 = _Rx2::num;
    static constexpr intmax_t _Dx2 = _Rx2::den;

    using type = ratio_add<_Rx1, ratio<-_Nx2, _Dx2>>;
};

template <class _Rx1, class _Rx2>
using ratio_subtract = typename _Ratio_subtract<_Rx1, _Rx2>::type;

template <class _Rx1, class _Rx2>
struct _Ratio_multiply { 
    static_assert(_Is_ratio_v<_Rx1> && _Is_ratio_v<_Rx2>, "ratio_multiply<R1, R2> requires R1 and R2 to be ratio<>s.");

    static constexpr intmax_t _Nx1 = _Rx1::num;
    static constexpr intmax_t _Dx1 = _Rx1::den;
    static constexpr intmax_t _Nx2 = _Rx2::num;
    static constexpr intmax_t _Dx2 = _Rx2::den;

    static constexpr intmax_t _Gx = _Gcd(_Nx1, _Dx2);
    static constexpr intmax_t _Gy = _Gcd(_Nx2, _Dx1);

    using _Num = _Safe_mult<_Nx1 / _Gx, _Nx2 / _Gy, true>;
    using _Den = _Safe_mult<_Dx1 / _Gy, _Dx2 / _Gx, true>;
};

template <class _Rx1, class _Rx2, bool _Sfinae = true, class = void>
struct _Ratio_multiply_sfinae { 
    static_assert(_Sfinae, "integer arithmetic overflow");
};

template <class _Rx1, class _Rx2, bool _Sfinae>
struct _Ratio_multiply_sfinae<_Rx1, _Rx2, _Sfinae,
    void_t<typename _Ratio_multiply<_Rx1, _Rx2>::_Num::type,
        typename _Ratio_multiply<_Rx1, _Rx2>::_Den::type>> { 
    using type = ratio<_Ratio_multiply<_Rx1, _Rx2>::_Num::value, _Ratio_multiply<_Rx1, _Rx2>::_Den::value>;
};

template <class _Rx1, class _Rx2>
using ratio_multiply = typename _Ratio_multiply_sfinae<_Rx1, _Rx2, false>::type;

template <class _Rx1, class _Rx2>
struct _Ratio_divide { 
    static_assert(_Is_ratio_v<_Rx1> && _Is_ratio_v<_Rx2>, "ratio_divide<R1, R2> requires R1 and R2 to be ratio<>s.");

    static constexpr intmax_t _Nx2 = _Rx2::num;
    static constexpr intmax_t _Dx2 = _Rx2::den;

    using _Rx2_inverse = ratio<_Dx2, _Nx2>;
};

template <class _Rx1, class _Rx2, bool _Sfinae = true>
using _Ratio_divide_sfinae =
    typename _Ratio_multiply_sfinae<_Rx1, typename _Ratio_divide<_Rx1, _Rx2>::_Rx2_inverse, _Sfinae>::type;

template <class _Rx1, class _Rx2>
using ratio_divide = _Ratio_divide_sfinae<_Rx1, _Rx2, false>;

template <class _Rx1, class _Rx2>
struct ratio_equal : bool_constant<_Rx1::num == _Rx2::num && _Rx1::den == _Rx2::den> { 
    static_assert(_Is_ratio_v<_Rx1> && _Is_ratio_v<_Rx2>, "ratio_equal<R1, R2> requires R1 and R2 to be ratio<>s.");
};

template <class _Rx1, class _Rx2>
inline constexpr bool ratio_equal_v = ratio_equal<_Rx1, _Rx2>::value;

template <class _Rx1, class _Rx2>
struct ratio_not_equal : bool_constant<!ratio_equal_v<_Rx1, _Rx2>> { 
    static_assert(_Is_ratio_v<_Rx1> && _Is_ratio_v<_Rx2>, "ratio_not_equal<R1, R2> requires R1 and R2 to be ratio<>s.");
};

template <class _Rx1, class _Rx2>
inline constexpr bool ratio_not_equal_v = ratio_not_equal<_Rx1, _Rx2>::value;

struct _Big_uint128 {
    uint64_t _Upper;
    uint64_t _Lower;

    constexpr bool operator<(const _Big_uint128 _Rhs) const noexcept {
        if (_Upper != _Rhs._Upper) {
            return _Upper < _Rhs._Upper;
        }

        return _Lower < _Rhs._Lower;
    }
};

constexpr _Big_uint128 _Big_multiply(const uint64_t _Lfactor,
    const uint64_t _Rfactor) noexcept { 
    const uint64_t _Llow  = _Lfactor & 0xFFFF'FFFFULL;
    const uint64_t _Lhigh = _Lfactor >> 32;
    const uint64_t _Rlow  = _Rfactor & 0xFFFF'FFFFULL;
    const uint64_t _Rhigh = _Rfactor >> 32;

    uint64_t _Temp          = _Llow * _Rlow;
    const uint64_t _Lower32 = _Temp & 0xFFFF'FFFFULL;
    uint64_t _Carry         = _Temp >> 32;

    _Temp                     = _Llow * _Rhigh + _Carry;
    const uint64_t _Mid_lower = _Temp & 0xFFFF'FFFFULL;
    const uint64_t _Mid_upper = _Temp >> 32;

    _Temp  = _Lhigh * _Rlow + _Mid_lower;
    _Carry = _Temp >> 32;

    return {_Lhigh * _Rhigh + _Mid_upper + _Carry, (_Temp << 32) + _Lower32};
}

constexpr bool _Ratio_less(const int64_t _Nx1, const int64_t _Dx1, const int64_t _Nx2, const int64_t _Dx2) noexcept {
    if (_Nx1 >= 0 && _Nx2 >= 0) {
        return _Big_multiply(static_cast<uint64_t>(_Nx1), static_cast<uint64_t>(_Dx2))
             < _Big_multiply(static_cast<uint64_t>(_Nx2), static_cast<uint64_t>(_Dx1));
    }

    if (_Nx1 < 0 && _Nx2 < 0) {
        return _Big_multiply(static_cast<uint64_t>(-_Nx2), static_cast<uint64_t>(_Dx1))
             < _Big_multiply(static_cast<uint64_t>(-_Nx1), static_cast<uint64_t>(_Dx2));
    }

    return _Nx1 < _Nx2;
}

template <class _Rx1, class _Rx2>
struct ratio_less : bool_constant<_Ratio_less(_Rx1::num, _Rx1::den, _Rx2::num, _Rx2::den)> { 
    static_assert(_Is_ratio_v<_Rx1> && _Is_ratio_v<_Rx2>, "ratio_less<R1, R2> requires R1 and R2 to be ratio<>s.");
};

template <class _Rx1, class _Rx2>
inline constexpr bool ratio_less_v = ratio_less<_Rx1, _Rx2>::value;

template <class _Rx1, class _Rx2>
struct ratio_less_equal : bool_constant<!ratio_less_v<_Rx2, _Rx1>> { 
    static_assert(
        _Is_ratio_v<_Rx1> && _Is_ratio_v<_Rx2>, "ratio_less_equal<R1, R2> requires R1 and R2 to be ratio<>s.");
};

template <class _Rx1, class _Rx2>
inline constexpr bool ratio_less_equal_v = ratio_less_equal<_Rx1, _Rx2>::value;

template <class _Rx1, class _Rx2>
struct ratio_greater : ratio_less<_Rx2, _Rx1>::type { 
    static_assert(_Is_ratio_v<_Rx1> && _Is_ratio_v<_Rx2>, "ratio_greater<R1, R2> requires R1 and R2 to be ratio<>s.");
};

template <class _Rx1, class _Rx2>
inline constexpr bool ratio_greater_v = ratio_greater<_Rx1, _Rx2>::value;

template <class _Rx1, class _Rx2>
struct ratio_greater_equal : bool_constant<!ratio_less_v<_Rx1, _Rx2>> { 
    static_assert(
        _Is_ratio_v<_Rx1> && _Is_ratio_v<_Rx2>, "ratio_greater_equal<R1, R2> requires R1 and R2 to be ratio<>s.");
};

template <class _Rx1, class _Rx2>
inline constexpr bool ratio_greater_equal_v = ratio_greater_equal<_Rx1, _Rx2>::value;

using atto  = ratio<1, 1000000000000000000LL>;
using femto = ratio<1, 1000000000000000LL>;
using pico  = ratio<1, 1000000000000LL>;
using nano  = ratio<1, 1000000000>;
using micro = ratio<1, 1000000>;
using milli = ratio<1, 1000>;
using centi = ratio<1, 100>;
using deci  = ratio<1, 10>;
using deca  = ratio<10, 1>;
using hecto = ratio<100, 1>;
using kilo  = ratio<1000, 1>;
using mega  = ratio<1000000, 1>;
using giga  = ratio<1000000000, 1>;
using tera  = ratio<1000000000000LL, 1>;
using peta  = ratio<1000000000000000LL, 1>;
using exa   = ratio<1000000000000000000LL, 1>;
}


#pragma warning(pop)
#pragma pack(pop)
#line 285 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ratio"
#line 286 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ratio"
#line 14 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtimec.h"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


extern "C" {

struct xtime { 
    __time64_t sec;
    long nsec;
};

 int __cdecl xtime_get(xtime*, int);

 long __cdecl _Xtime_diff_to_millis(const xtime*);
 long __cdecl _Xtime_diff_to_millis2(const xtime*, const xtime*);
 long long __cdecl _Xtime_get_ticks();

 long long __cdecl _Query_perf_counter();
 long long __cdecl _Query_perf_frequency();

}


#pragma warning(pop)
#pragma pack(pop)
#line 44 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtimec.h"
#line 45 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtimec.h"


#line 17 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_tzdb.hpp"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


using __std_tzdb_epoch_milli = double;

struct __std_tzdb_leap_info {
    uint16_t _Year;
    uint16_t _Month;
    uint16_t _Day;
    uint16_t _Hour;
    uint16_t _Negative;
    uint16_t _Reserved;
};

enum class __std_tzdb_error {
    _Success   = 0,
    _Win_error = 1,
    _Icu_error = 2,
};

struct __std_tzdb_time_zones_info {
    __std_tzdb_error _Err;
    
    const char* _Version;
    size_t _Num_time_zones;
    
    const char** _Names;
    
    
    const char** _Links;
};

struct __std_tzdb_current_zone_info {
    __std_tzdb_error _Err;
    const char* _Tz_name;
};

struct __std_tzdb_sys_info {
    __std_tzdb_error _Err;
    __std_tzdb_epoch_milli _Begin;
    __std_tzdb_epoch_milli _End;
    int32_t _Offset;
    int32_t _Save;
    const char* _Abbrev;
};

extern "C" {

[[nodiscard]] __std_tzdb_time_zones_info* __stdcall __std_tzdb_get_time_zones() noexcept;
void __stdcall __std_tzdb_delete_time_zones(__std_tzdb_time_zones_info* _Info) noexcept;

[[nodiscard]] __std_tzdb_current_zone_info* __stdcall __std_tzdb_get_current_zone() noexcept;
void __stdcall __std_tzdb_delete_current_zone(__std_tzdb_current_zone_info* _Info) noexcept;

[[nodiscard]] __std_tzdb_sys_info* __stdcall __std_tzdb_get_sys_info(
    const char* _Tz, size_t _Tz_len, __std_tzdb_epoch_milli _Local) noexcept;
void __stdcall __std_tzdb_delete_sys_info(__std_tzdb_sys_info* _Info) noexcept;

[[nodiscard]] __std_tzdb_leap_info* __stdcall __std_tzdb_get_leap_seconds(
    size_t _Prev_ls_size, size_t* _Current_ls_size) noexcept;
void __stdcall __std_tzdb_delete_leap_seconds(__std_tzdb_leap_info* _Info) noexcept;

[[nodiscard]] void* __stdcall __std_calloc_crt(size_t _Count, size_t _Size) noexcept;
void __stdcall __std_free_crt(void* _Ptr) noexcept;

}

namespace std {

template <class _Ty>
struct _Tzdb_deleter;

template <>
struct _Tzdb_deleter<__std_tzdb_time_zones_info> {
    void operator()(__std_tzdb_time_zones_info* _Info) const noexcept {
        __std_tzdb_delete_time_zones(_Info);
    }
};

template <>
struct _Tzdb_deleter<__std_tzdb_current_zone_info> {
    void operator()(__std_tzdb_current_zone_info* _Info) const noexcept {
        __std_tzdb_delete_current_zone(_Info);
    }
};

template <>
struct _Tzdb_deleter<__std_tzdb_sys_info> {
    void operator()(__std_tzdb_sys_info* _Info) const noexcept {
        __std_tzdb_delete_sys_info(_Info);
    }
};

template <>
struct _Tzdb_deleter<__std_tzdb_leap_info[]> {
    void operator()(__std_tzdb_leap_info* _Info) const noexcept {
        __std_tzdb_delete_leap_seconds(_Info);
    }
};

template <class _Ty>
class _Crt_allocator {
public:
    using value_type                             = _Ty;
    using propagate_on_container_move_assignment = true_type;
    using is_always_equal                        = true_type;

    constexpr _Crt_allocator() noexcept = default;

    constexpr _Crt_allocator(const _Crt_allocator&) noexcept = default;
    template <class _Other>
    constexpr _Crt_allocator(const _Crt_allocator<_Other>&) noexcept {}

    [[nodiscard]] __declspec(allocator) _Ty* allocate( const size_t _Count) {
        const auto _Ptr = __std_calloc_crt(_Count, sizeof(_Ty));
        if (!_Ptr) {
            _Xbad_alloc();
        }
        return static_cast<_Ty*>(_Ptr);
    }

    void deallocate(_Ty* const _Ptr, size_t) noexcept {
        __std_free_crt(_Ptr);
    }
};

}


#pragma warning(pop)
#pragma pack(pop)
#line 154 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_tzdb.hpp"
#line 155 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_tzdb.hpp"
#line 20 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


extern "C" {


__declspec(noalias) void __cdecl __std_reverse_copy_trivially_copyable_1(
    const void* _First, const void* _Last, void* _Dest) noexcept;
__declspec(noalias) void __cdecl __std_reverse_copy_trivially_copyable_2(
    const void* _First, const void* _Last, void* _Dest) noexcept;
__declspec(noalias) void __cdecl __std_reverse_copy_trivially_copyable_4(
    const void* _First, const void* _Last, void* _Dest) noexcept;
__declspec(noalias) void __cdecl __std_reverse_copy_trivially_copyable_8(
    const void* _First, const void* _Last, void* _Dest) noexcept;
}
#line 39 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

namespace std {
inline constexpr int _ISORT_MAX = 32; 

template <class _It>
inline constexpr _Iter_diff_t<_It> _Isort_max{_ISORT_MAX};

template <class _Diff>
constexpr ptrdiff_t _Temporary_buffer_size(const _Diff _Value) noexcept {
    
    using _CT = common_type_t<ptrdiff_t, _Diff>;
    return static_cast<ptrdiff_t>((::std:: min)(static_cast<_CT>(2147483647i32), static_cast<_CT>(_Value)));
}

template <class _Ty>
struct _Optimistic_temporary_buffer { 
    static constexpr size_t _Optimistic_size  = 4096; 
    static constexpr size_t _Optimistic_count = (::std:: max)(static_cast<size_t>(1), _Optimistic_size / sizeof(_Ty));

    template <class _Diff>
    explicit _Optimistic_temporary_buffer(const _Diff _Requested_size) noexcept { 
        const auto _Attempt = _Temporary_buffer_size(_Requested_size);
        
        
        if (static_cast<size_t>(_Requested_size) <= _Optimistic_count) { 
            _Data     = reinterpret_cast<_Ty*>(&_Stack_space[0]);
            _Capacity = static_cast<ptrdiff_t>(_Requested_size); 
            return;
        }

        const pair<_Ty*, ptrdiff_t> _Raw = _Get_temporary_buffer<_Ty>(_Attempt);
        if (static_cast<size_t>(_Raw.second) > _Optimistic_count) { 
            _Data     = _Raw.first;
            _Capacity = _Raw.second;
            return;
        }

        
        _Return_temporary_buffer(_Raw.first);
        _Data     = reinterpret_cast<_Ty*>(&_Stack_space[0]);
        _Capacity = _Optimistic_count;
    }

    _Optimistic_temporary_buffer(const _Optimistic_temporary_buffer&) = delete;
    _Optimistic_temporary_buffer& operator=(const _Optimistic_temporary_buffer&) = delete;

    ~_Optimistic_temporary_buffer() noexcept {
        if (static_cast<size_t>(_Capacity) > _Optimistic_count) {
            _Return_temporary_buffer(_Data);
        }
    }

    _Ty* _Data; 
    ptrdiff_t _Capacity;
    aligned_union_t<0, _Ty> _Stack_space[_Optimistic_count];
};


namespace ranges {
    template <class _In, class _Fun>
    struct in_fun_result {
         _In in;
         _Fun fun;

        template <_Convertible_from<const _In&> _IIn, _Convertible_from<const _Fun&> _FFun>
        constexpr operator in_fun_result<_IIn, _FFun>() const& {
            return {in, fun};
        }

        template <_Convertible_from<_In> _IIn, _Convertible_from<_Fun> _FFun>
        constexpr operator in_fun_result<_IIn, _FFun>() && {
            return {::std:: move(in), ::std:: move(fun)};
        }
    };

    template <class _In1, class _In2, class _Out>
    struct in_in_out_result {
         _In1 in1;
         _In2 in2;
         _Out out;

        template <_Convertible_from<const _In1&> _IIn1, _Convertible_from<const _In2&> _IIn2,
            _Convertible_from<const _Out&> _OOut>
        constexpr operator in_in_out_result<_IIn1, _IIn2, _OOut>() const& {
            return {in1, in2, out};
        }

        template <_Convertible_from<_In1> _IIn1, _Convertible_from<_In2> _IIn2, _Convertible_from<_Out> _OOut>
        constexpr operator in_in_out_result<_IIn1, _IIn2, _OOut>() && {
            return {::std:: move(in1), ::std:: move(in2), ::std:: move(out)};
        }
    };

    template <class _In, class _Out1, class _Out2>
    struct in_out_out_result {
         _In in;
         _Out1 out1;
         _Out2 out2;

        template <_Convertible_from<const _In&> _IIn, _Convertible_from<const _Out1&> _OOut1,
            _Convertible_from<const _Out2&> _OOut2>
        constexpr operator in_out_out_result<_IIn, _OOut1, _OOut2>() const& {
            return {in, out1, out2};
        }

        template <_Convertible_from<_In> _IIn, _Convertible_from<_Out1> _OOut1, _Convertible_from<_Out2> _OOut2>
        constexpr operator in_out_out_result<_IIn, _OOut1, _OOut2>() && {
            return {::std:: move(in), ::std:: move(out1), ::std:: move(out2)};
        }
    };

    template <class _Ty>
    struct min_max_result {
         _Ty min;
         _Ty max;

        template <_Convertible_from<const _Ty&> _Ty2>
        constexpr operator min_max_result<_Ty2>() const& {
            return {min, max};
        }

        template <_Convertible_from<_Ty> _Ty2>
        constexpr operator min_max_result<_Ty2>() && {
            return {::std:: move(min), ::std:: move(max)};
        }
    };

    template <class _In>
    struct in_found_result {
         _In in;
        bool found;

        template <_Convertible_from<const _In&> _IIn>
        constexpr operator in_found_result<_IIn>() const& {
            return {in, found};
        }

        template <_Convertible_from<_In> _IIn>
        constexpr operator in_found_result<_IIn>() && {
            return {::std:: move(in), found};
        }
    };

    template <forward_iterator _Wrapped, sentinel_for<_Wrapped> _Se>
    [[nodiscard]] constexpr auto _Get_final_iterator_unwrapped(const _Unwrapped_t<_Wrapped>& _UFirst, _Se&& _Last) {
        
        auto _ULast = _Get_unwrapped(::std:: move(_Last));
        if constexpr (is_same_v<_Se, _Wrapped>) {
            return _ULast;
        } else if constexpr (sized_sentinel_for<_Se, _Wrapped>) {
            return ::std::ranges:: next(_UFirst, _ULast - _UFirst);
        } else {
            return ::std::ranges:: next(_UFirst, ::std:: move(_ULast));
        }
    }

    template <forward_range _Rng>
    [[nodiscard]] constexpr auto _Get_final_iterator_unwrapped(_Rng& _Range) {
        
        if constexpr (common_range<_Rng>) {
            return _Uend(_Range);
        } else if constexpr (sized_range<_Rng>) {
            return ::std::ranges:: next(_Ubegin(_Range), ::std::ranges:: distance(_Range));
        } else {
            return ::std::ranges:: next(_Ubegin(_Range), _Uend(_Range));
        }
    }

    template <forward_range _Rng>
    [[nodiscard]] constexpr auto _Get_final_iterator_unwrapped(_Rng& _Range, const _Unwrapped_t<iterator_t<_Rng>>& _Mid) {
        
        
        if constexpr (common_range<_Rng>) {
            return _Uend(_Range);
        } else if constexpr (sized_range<_Rng>) {
            const auto _Dist = ::std::ranges:: distance(_Range);
            if constexpr (sized_sentinel_for<_Unwrapped_t<iterator_t<_Rng>>, _Unwrapped_t<iterator_t<_Rng>>>) {
                return ::std::ranges:: next(_Mid, _Dist - (_Mid - _Ubegin(_Range)));
            } else {
                return ::std::ranges:: next(_Ubegin(_Range), _Dist);
            }
        } else {
            return ::std::ranges:: next(_Mid, _Uend(_Range));
        }
    }
} 
#line 226 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _InIt, class _Fn>
constexpr _Fn for_each(_InIt _First, _InIt _Last, _Fn _Func) { 
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    for (; _UFirst != _ULast; ++_UFirst) {
        _Func(*_UFirst);
    }

    return _Func;
}


template <class _ExPo, class _FwdIt, class _Fn, _Enable_if_execution_policy_t<_ExPo> = 0>
void for_each(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, _Fn _Func) noexcept; 

template <class _InIt, class _Diff, class _Fn>
constexpr _InIt for_each_n(_InIt _First, const _Diff _Count_raw, _Fn _Func) {
    
    _Algorithm_int_t<_Diff> _Count = _Count_raw;
    if (0 < _Count) {
        auto _UFirst = _Get_unwrapped_n(_First, _Count);
        do {
            _Func(*_UFirst);
            --_Count;
            ++_UFirst;
        } while (0 < _Count);

        _Seek_wrapped(_First, _UFirst);
    }

    return _First;
}

template <class _ExPo, class _FwdIt, class _Diff, class _Fn, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt for_each_n(_ExPo&& _Exec, _FwdIt _First, _Diff _Count_raw, _Fn _Func) noexcept; 
#line 264 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


namespace ranges {
    template <class _In, class _Fun>
    using for_each_result = in_fun_result<_In, _Fun>;

    class _For_each_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <input_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
            indirectly_unary_invocable<projected<_It, _Pj>> _Fn>
        constexpr for_each_result<_It, _Fn> operator()(_It _First, _Se _Last, _Fn _Func, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);

            auto _UResult = _For_each_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)), ::std:: move(_Func), _Pass_fn(_Proj));

            _Seek_wrapped(_First, ::std:: move(_UResult.in));
            return {::std:: move(_First), ::std:: move(_UResult.fun)};
        }

        template <input_range _Rng, class _Pj = identity,
            indirectly_unary_invocable<projected<iterator_t<_Rng>, _Pj>> _Fn>
        constexpr for_each_result<borrowed_iterator_t<_Rng>, _Fn> operator()(
            _Rng&& _Range, _Fn _Func, _Pj _Proj = {}) const {
            auto _First = ::std::ranges:: begin(_Range);

            auto _UResult = _For_each_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Uend(_Range), ::std:: move(_Func), _Pass_fn(_Proj));

            _Seek_wrapped(_First, ::std:: move(_UResult.in));
            return {::std:: move(_First), ::std:: move(_UResult.fun)};
        }

    private:
        template <class _It, class _Se, class _Pj, class _Fn>
        [[nodiscard]] static constexpr for_each_result<_It, _Fn> _For_each_unchecked(
            _It _First, const _Se _Last, _Fn _Func, _Pj _Proj) {
            ;
            ;
            ;

            for (; _First != _Last; ++_First) {
                ::std:: invoke(_Func, ::std:: invoke(_Proj, *_First));
            }

            return {::std:: move(_First), ::std:: move(_Func)};
        }
    };

    inline constexpr _For_each_fn for_each{_Not_quite_object::_Construct_tag{}};

    template <class _In, class _Fun>
    using for_each_n_result = in_fun_result<_In, _Fun>;

    class _For_each_n_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <input_iterator _It, class _Pj = identity, indirectly_unary_invocable<projected<_It, _Pj>> _Fn>
        constexpr for_each_n_result<_It, _Fn> operator()(
            _It _First, iter_difference_t<_It> _Count, _Fn _Func, _Pj _Proj = {}) const {
            if (0 < _Count) {
                auto _UFirst = _Get_unwrapped_n(::std:: move(_First), _Count);
                do {
                    ::std:: invoke(_Func, ::std:: invoke(_Proj, *_UFirst));
                    --_Count;
                    ++_UFirst;
                } while (0 < _Count);

                _Seek_wrapped(_First, ::std:: move(_UFirst));
            }

            return {::std:: move(_First), ::std:: move(_Func)};
        }
    };

    inline constexpr _For_each_n_fn for_each_n{_Not_quite_object::_Construct_tag{}};
} 
#line 345 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _FwdIt find_if(_ExPo&& _Exec, _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept; 
#line 350 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _InIt, class _Pr>
[[nodiscard]] constexpr _InIt find_if_not(_InIt _First, const _InIt _Last, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    for (; _UFirst != _ULast; ++_UFirst) {
        if (!_Pred(*_UFirst)) {
            break;
        }
    }

    _Seek_wrapped(_First, _UFirst);
    return _First;
}


template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _FwdIt find_if_not(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept; 
#line 371 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _FwdIt, class _Pr>
[[nodiscard]] constexpr _FwdIt adjacent_find(const _FwdIt _First, _FwdIt _Last, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst = _Get_unwrapped(_First);
    auto _ULast  = _Get_unwrapped(_Last);
    if (_UFirst != _ULast) {
        for (auto _UNext = _UFirst; ++_UNext != _ULast; _UFirst = _UNext) {
            if (_Pred(*_UFirst, *_UNext)) {
                _ULast = _UFirst;
                break;
            }
        }
    }

    _Seek_wrapped(_Last, _ULast);
    return _Last;
}

template <class _FwdIt>
[[nodiscard]] constexpr _FwdIt adjacent_find(const _FwdIt _First, const _FwdIt _Last) { 
    return ::std:: adjacent_find(_First, _Last, equal_to<>{});
}


template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _FwdIt adjacent_find(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept; 

template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _FwdIt adjacent_find(_ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last) noexcept  {
    
    return ::std:: adjacent_find(::std:: forward<_ExPo>(_Exec), _First, _Last, equal_to{});
}
#line 406 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


namespace ranges {
    class _Adjacent_find_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <forward_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
            indirect_binary_predicate<projected<_It, _Pj>, projected<_It, _Pj>> _Pr = ranges::equal_to>
        [[nodiscard]] constexpr _It operator()(_It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);

            auto _UResult = _Adjacent_find_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)), _Pass_fn(_Pred), _Pass_fn(_Proj));

            _Seek_wrapped(_First, ::std:: move(_UResult));
            return _First;
        }

        template <forward_range _Rng, class _Pj = identity,
            indirect_binary_predicate<projected<iterator_t<_Rng>, _Pj>, projected<iterator_t<_Rng>, _Pj>> _Pr =
                ranges::equal_to>
        [[nodiscard]] constexpr borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) const {
            auto _UResult = _Adjacent_find_unchecked(_Ubegin(_Range), _Uend(_Range), _Pass_fn(_Pred), _Pass_fn(_Proj));

            return _Rewrap_iterator(_Range, ::std:: move(_UResult));
        }

    private:
        template <class _It, class _Se, class _Pj, class _Pr>
        [[nodiscard]] static constexpr _It _Adjacent_find_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
            
            ;
            ;
            ;

            if (_First == _Last) {
                return _First;
            }

            for (auto _Next = _First;; ++_First) {
                if (++_Next == _Last) {
                    return _Next;
                }

                if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_First), ::std:: invoke(_Proj, *_Next))) {
                    return _First;
                }
            }
        }
    };

    inline constexpr _Adjacent_find_fn adjacent_find{_Not_quite_object::_Construct_tag{}};

    class _Count_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It, sentinel_for<_It> _Se, class _Ty, class _Pj = identity>
            requires indirect_binary_predicate<ranges::equal_to, projected<_It, _Pj>, const _Ty*>
        [[nodiscard]] constexpr iter_difference_t<_It> operator()(
            _It _First, _Se _Last, const _Ty& _Val, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            return _Count_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)), _Val, _Pass_fn(_Proj));
        }

        template <input_range _Rng, class _Ty, class _Pj = identity>
            requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Rng>, _Pj>, const _Ty*>
        [[nodiscard]] constexpr range_difference_t<_Rng> operator()(_Rng&& _Range, const _Ty& _Val, _Pj _Proj = {}) const {
            return _Count_unchecked(_Ubegin(_Range), _Uend(_Range), _Val, _Pass_fn(_Proj));
        }
        
    private:
        template <class _It, class _Se, class _Ty, class _Pj>
        [[nodiscard]] static constexpr iter_difference_t<_It> _Count_unchecked(
            _It _First, const _Se _Last, const _Ty& _Val, _Pj _Proj) {
            ;
            ;
            ;

            iter_difference_t<_It> _Count = 0;
            for (; _First != _Last; ++_First) {
                if (::std:: invoke(_Proj, *_First) == _Val) {
                    ++_Count;
                }
            }

            return _Count;
        }
    };

    inline constexpr _Count_fn count{_Not_quite_object::_Construct_tag{}};
} 
#line 502 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _InIt, class _Pr>
[[nodiscard]] constexpr _Iter_diff_t<_InIt> count_if(_InIt _First, _InIt _Last, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst               = _Get_unwrapped(_First);
    const auto _ULast          = _Get_unwrapped(_Last);
    _Iter_diff_t<_InIt> _Count = 0;
    for (; _UFirst != _ULast; ++_UFirst) {
        if (_Pred(*_UFirst)) {
            ++_Count;
        }
    }

    return _Count;
}


template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _Iter_diff_t<_FwdIt> count_if(
    _ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept; 
#line 524 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


namespace ranges {
    class _Count_if_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <input_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
        [[nodiscard]] constexpr iter_difference_t<_It> operator()(_It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            return _Count_if_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)), _Pass_fn(_Pred), _Pass_fn(_Proj));
        }

        template <input_range _Rng, class _Pj = identity,
            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
        [[nodiscard]] constexpr range_difference_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) const {
            return _Count_if_unchecked(_Ubegin(_Range), _Uend(_Range), _Pass_fn(_Pred), _Pass_fn(_Proj));
        }

    private:
        template <class _It, class _Se, class _Pj, class _Pr>
        [[nodiscard]] static constexpr iter_difference_t<_It> _Count_if_unchecked(
            _It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
            ;
            ;
            ;

            iter_difference_t<_It> _Count = 0;
            for (; _First != _Last; ++_First) {
                if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_First))) {
                    ++_Count;
                }
            }

            return _Count;
        }
    };

    inline constexpr _Count_if_fn count_if{_Not_quite_object::_Construct_tag{}};
} 
#line 567 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _InIt1, class _InIt2, class _Pr>
[[nodiscard]] constexpr pair<_InIt1, _InIt2> mismatch(_InIt1 _First1, const _InIt1 _Last1, _InIt2 _First2, _Pr _Pred) {
    
    _Adl_verify_range(_First1, _Last1);
    auto _UFirst1      = _Get_unwrapped(_First1);
    const auto _ULast1 = _Get_unwrapped(_Last1);
    auto _UFirst2      = _Get_unwrapped_n(_First2, _Idl_distance<_InIt1>(_UFirst1, _ULast1));
    while (_UFirst1 != _ULast1 && _Pred(*_UFirst1, *_UFirst2)) {
        ++_UFirst1;
        ++_UFirst2;
    }

    _Seek_wrapped(_First2, _UFirst2);
    _Seek_wrapped(_First1, _UFirst1);
    return {_First1, _First2};
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] pair<_FwdIt1, _FwdIt2> mismatch(
    _ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Pr _Pred) noexcept; 
#line 590 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _InIt1, class _InIt2>
[[nodiscard]] constexpr pair<_InIt1, _InIt2> mismatch(const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2) {
    
    return ::std:: mismatch(_First1, _Last1, _First2, equal_to<>{});
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] pair<_FwdIt1, _FwdIt2> mismatch(
    _ExPo&& _Exec, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2) noexcept  {
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: mismatch(::std:: forward<_ExPo>(_Exec), _First1, _Last1, _First2, equal_to{});
}
#line 607 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _InIt1, class _InIt2, class _Pr>
[[nodiscard]] constexpr pair<_InIt1, _InIt2> mismatch(
    _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr _Pred) {
    
    _Adl_verify_range(_First1, _Last1);
    _Adl_verify_range(_First2, _Last2);
    auto _UFirst1      = _Get_unwrapped(_First1);
    auto _ULast1       = _Get_unwrapped(_Last1);
    auto _UFirst2      = _Get_unwrapped(_First2);
    const auto _ULast2 = _Get_unwrapped(_Last2);
    if constexpr (_Is_random_iter_v<_InIt1> && _Is_random_iter_v<_InIt2>) {
        using _CT         = _Common_diff_t<_InIt1, _InIt2>;
        const _CT _Count1 = _ULast1 - _UFirst1;
        const _CT _Count2 = _ULast2 - _UFirst2;
        const auto _Count = static_cast<_Iter_diff_t<_InIt1>>((::std:: min)(_Count1, _Count2));
        _ULast1           = _UFirst1 + _Count;
        while (_UFirst1 != _ULast1 && _Pred(*_UFirst1, *_UFirst2)) {
            ++_UFirst1;
            ++_UFirst2;
        }
    } else {
        while (_UFirst1 != _ULast1 && _UFirst2 != _ULast2 && _Pred(*_UFirst1, *_UFirst2)) {
            ++_UFirst1;
            ++_UFirst2;
        }
    }

    _Seek_wrapped(_First2, _UFirst2);
    _Seek_wrapped(_First1, _UFirst1);
    return {_First1, _First2};
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] pair<_FwdIt1, _FwdIt2> mismatch(
    _ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred) noexcept; 
#line 645 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _InIt1, class _InIt2>
[[nodiscard]] constexpr pair<_InIt1, _InIt2> mismatch(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2) {
    
    return ::std:: mismatch(_First1, _Last1, _First2, _Last2, equal_to<>{});
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] pair<_FwdIt1, _FwdIt2> mismatch(
    _ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2) noexcept  {
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: mismatch(::std:: forward<_ExPo>(_Exec), _First1, _Last1, _First2, _Last2, equal_to{});
}
#line 662 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


namespace ranges {
    
    template <input_iterator _It1, input_iterator _It2, integral _Size, class _Pr, class _Pj1, class _Pj2>
        requires indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
    [[nodiscard]] constexpr bool _Equal_count(
        _It1 _First1, _It2 _First2, _Size _Count, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
        
        ;
        if constexpr (_Equal_memcmp_is_safe<_It1, _It2, _Pr> && same_as<_Pj1, identity> && same_as<_Pj2, identity>) {
            if (!::std:: is_constant_evaluated()) {
                return _Memcmp_count(_First1, _First2, static_cast<size_t>(_Count)) == 0;
            }
        }

        for (; _Count != 0; ++_First1, (void) ++_First2, --_Count) {
            if (!::std:: invoke(_Pred, ::std:: invoke(_Proj1, *_First1), ::std:: invoke(_Proj2, *_First2))) {
                return false;
            }
        }

        return true;
    }

    class _Equal_fn : private _Not_quite_object {
    private:
        template <class _It1, class _Se1, class _It2, class _Se2, class _Pr, class _Pj1, class _Pj2>
        [[nodiscard]] static constexpr bool _Equal_4(
            _It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
            ;
            ;
            ;

            for (;;) {
                if (_First1 == _Last1) {
                    return _First2 == _Last2;
                } else if (_First2 == _Last2) {
                    return false;
                }

                if (!::std:: invoke(_Pred, ::std:: invoke(_Proj1, *_First1), ::std:: invoke(_Proj2, *_First2))) {
                    return false;
                }

                ++_First1;
                ++_First2;
            }
        }

    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2,
            class _Pr = ranges::equal_to, class _Pj1 = identity, class _Pj2 = identity>
            requires indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
        [[nodiscard]] constexpr bool operator()(_It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2, _Pr _Pred = {},
            _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            _Adl_verify_range(_First1, _Last1);
            _Adl_verify_range(_First2, _Last2);
            auto _UFirst1 = _Get_unwrapped(::std:: move(_First1));
            auto _ULast1  = _Get_unwrapped(::std:: move(_Last1));
            auto _UFirst2 = _Get_unwrapped(::std:: move(_First2));
            auto _ULast2  = _Get_unwrapped(::std:: move(_Last2));

            if constexpr (sized_sentinel_for<_Se1, _It1> && sized_sentinel_for<_Se2, _It2>) {
                const auto _Count = _ULast1 - _UFirst1;
                if (_Count != _ULast2 - _UFirst2) {
                    return false;
                }

                return _Equal_count(::std:: move(_UFirst1), ::std:: move(_UFirst2), _Count,
                    _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
            } else {
                return _Equal_4(::std:: move(_UFirst1), ::std:: move(_ULast1), ::std:: move(_UFirst2), ::std:: move(_ULast2),
                    _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
            }
        }

        template <input_range _Rng1, input_range _Rng2, class _Pr = ranges::equal_to, class _Pj1 = identity,
            class _Pj2 = identity>
            requires indirectly_comparable<iterator_t<_Rng1>, iterator_t<_Rng2>, _Pr, _Pj1, _Pj2>
        [[nodiscard]] constexpr bool operator()(
            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            if constexpr (sized_range<_Rng1> && sized_range<_Rng2>) {
                using _Size1 = _Make_unsigned_like_t<range_size_t<_Rng1>>;
                const auto _Count = static_cast<_Size1>(::std::ranges:: size(_Range1));
                using _Size2 = _Make_unsigned_like_t<range_size_t<_Rng2>>;
                if (_Count != static_cast<_Size2>(::std::ranges:: size(_Range2))) {
                    return false;
                }
                return _Equal_count(_Ubegin(_Range1), _Ubegin(_Range2), _Count,
                    _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
            } else {
                return _Equal_4(_Ubegin(_Range1), _Uend(_Range1), _Ubegin(_Range2), _Uend(_Range2),
                    _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
            }
        }
        
    };

    inline constexpr _Equal_fn equal{_Not_quite_object::_Construct_tag{}};
} 
#line 767 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _FwdIt1, class _FwdIt2, class _Pr>
[[nodiscard]] constexpr bool is_permutation(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Pr _Pred) {
    
    _Adl_verify_range(_First1, _Last1);
    auto _UFirst1      = _Get_unwrapped(_First1);
    const auto _ULast1 = _Get_unwrapped(_Last1);
    auto _UFirst2      = _Get_unwrapped_n(_First2, _Idl_distance<_FwdIt1>(_UFirst1, _ULast1));

    for (;; ++_UFirst1, (void) ++_UFirst2) { 
        if (_UFirst1 == _ULast1) { 
            return true;
        }

        if (!_Pred(*_UFirst1, *_UFirst2)) { 
            break;
        }
    }

    
    const auto _Dist2 = static_cast<_Iter_diff_t<_FwdIt2>>(::std:: distance(_UFirst1, _ULast1));
    return _Check_match_counts(_UFirst1, _ULast1, _UFirst2, ::std:: next(_UFirst2, _Dist2), _Pass_fn(_Pred));
}

template <class _FwdIt1, class _FwdIt2>
[[nodiscard]] constexpr bool is_permutation(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2) {
    
    return ::std:: is_permutation(_First1, _Last1, _First2, equal_to<>{});
}

template <class _FwdIt1, class _FwdIt2, class _Pr>
constexpr bool _Is_permutation_unchecked(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred,
    forward_iterator_tag, forward_iterator_tag) {
    
    for (;; ++_First1, (void) ++_First2) { 
        if (_First1 == _Last1) {
            return _First2 == _Last2;
        }

        if (_First2 == _Last2) {
            return false;
        }

        if (!_Pred(*_First1, *_First2)) { 
            break;
        }
    }

    auto _Next1 = _First1;
    auto _Next2 = _First2;
    for (;; ++_Next1, (void) ++_Next2) { 
        if (_Next1 == _Last1) {
            if (_Next2 == _Last2) {
                return _Check_match_counts(_First1, _Last1, _First2, _Last2, _Pred);
            }

            return false; 
        }

        if (_Next2 == _Last2) {
            return false; 
        }
    }
}

template <class _FwdIt1, class _FwdIt2, class _Pr>
constexpr bool _Is_permutation_unchecked(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred,
    random_access_iterator_tag, random_access_iterator_tag) {
    
    if (_Last1 - _First1 != _Last2 - _First2) {
        return false;
    }

    for (; _First1 != _Last1; ++_First1, (void) ++_First2) { 
        if (!_Pred(*_First1, *_First2)) {
            
            return _Check_match_counts(_First1, _Last1, _First2, _Last2, _Pred);
        }
    }

    return true;
}

template <class _FwdIt1, class _FwdIt2, class _Pr>
[[nodiscard]] constexpr bool is_permutation(
    _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred) {
    
    _Adl_verify_range(_First1, _Last1);
    _Adl_verify_range(_First2, _Last2);
    return _Is_permutation_unchecked(_Get_unwrapped(_First1), _Get_unwrapped(_Last1), _Get_unwrapped(_First2),
        _Get_unwrapped(_Last2), _Pass_fn(_Pred), _Iter_cat_t<_FwdIt1>{}, _Iter_cat_t<_FwdIt2>{});
}

template <class _FwdIt1, class _FwdIt2>
[[nodiscard]] constexpr bool is_permutation(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2) {
    
    return ::std:: is_permutation(_First1, _Last1, _First2, _Last2, equal_to<>{});
}


namespace ranges {
    template <class _It, class _Se>
    concept _Bidi_common = is_same_v<_It, _Se> && bidirectional_iterator<_It>;
    template <class _Rng>
    concept _Bidi_common_range = common_range<_Rng> && bidirectional_iterator<iterator_t<_Rng>>;

    class _Is_permutation_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <forward_iterator _It1, sentinel_for<_It1> _Se1, forward_iterator _It2, sentinel_for<_It2> _Se2,
            class _Pj1 = identity, class _Pj2 = identity,
            indirect_equivalence_relation<projected<_It1, _Pj1>, projected<_It2, _Pj2>> _Pr = ranges::equal_to>
        [[nodiscard]] constexpr bool operator()(_It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2, _Pr _Pred = {},
            _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            _Adl_verify_range(_First1, _Last1);
            _Adl_verify_range(_First2, _Last2);
            auto _UFirst1 = _Get_unwrapped(::std:: move(_First1));
            auto _ULast1  = _Get_unwrapped(::std:: move(_Last1));
            auto _UFirst2 = _Get_unwrapped(::std:: move(_First2));
            auto _ULast2  = _Get_unwrapped(::std:: move(_Last2));

            if constexpr (sized_sentinel_for<_Se1, _It1> && sized_sentinel_for<_Se2, _It2>) {
                const auto _Count = _ULast1 - _UFirst1;
                if (_ULast2 - _UFirst2 != _Count) {
                    return false;
                }

                return _Is_permutation_sized(::std:: move(_UFirst1), ::std:: move(_ULast1), ::std:: move(_UFirst2),
                    ::std:: move(_ULast2), _Count, _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
            } else {
                return _Is_permutation_unsized(::std:: move(_UFirst1), ::std:: move(_ULast1), ::std:: move(_UFirst2),
                    ::std:: move(_ULast2), _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
            }
        }

        template <forward_range _Rng1, forward_range _Rng2, class _Pj1 = identity, class _Pj2 = identity,
            indirect_equivalence_relation<projected<iterator_t<_Rng1>, _Pj1>, projected<iterator_t<_Rng2>, _Pj2>> _Pr =
                ranges::equal_to>
        [[nodiscard]] constexpr bool operator()(
            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            if constexpr (sized_range<_Rng1> && sized_range<_Rng2>) {
                const auto _Count = ::std::ranges:: distance(_Range1);
                if (::std::ranges:: distance(_Range2) != _Count) {
                    return false;
                }

                return _Is_permutation_sized(_Ubegin(_Range1), _Uend(_Range1), _Ubegin(_Range2), _Uend(_Range2), _Count,
                    _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
            } else {
                return _Is_permutation_unsized(_Ubegin(_Range1), _Uend(_Range1), _Ubegin(_Range2), _Uend(_Range2),
                    _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
            }
        }

    private:
        template <class _It1, class _Se1, class _It2, class _Se2, class _Pr, class _Pj1, class _Pj2>
        [[nodiscard]] static constexpr bool _Is_permutation_sized(_It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2,
            iter_difference_t<_It1> _Count, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
            ;
            ;
            ;
            ;
            ;
#line 933 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
            ;
            ;

            for (;; ++_First1, (void) ++_First2, --_Count) { 
                if (_Count == 0) { 
                    return true;
                }

                if (!::std:: invoke(_Pred, ::std:: invoke(_Proj1, *_First1), ::std:: invoke(_Proj2, *_First2))) { 
                    break;
                }
            }

            if (_Count == 1) { 
                return false;
            }
            

            if constexpr (bidirectional_iterator<_It1> && bidirectional_iterator<_It2>) {
                
                auto _Final1 = _Find_last_iterator(_First1, _Last1, _Count);
                auto _Final2 = _Find_last_iterator(_First2, _Last2, _Count);

                for (;;) { 
                    --_Final1;
                    --_Final2;
                    if (!::std:: invoke(_Pred, ::std:: invoke(_Proj1, *_Final1), ::std:: invoke(_Proj2, *_Final2))) { 
                        break;
                    }

                    if (--_Count == 1) {
                        return false; 
                    }
                }
                

                const auto _ProjectedPred = [&]<class _Ty1, class _Ty2>(_Ty1&& _Left, _Ty2&& _Right) {
                    return ::std:: invoke(_Pred, ::std:: invoke(_Proj1, ::std:: forward<_Ty1>(_Left)),
                        ::std:: invoke(_Proj2, ::std:: forward<_Ty2>(_Right)));
                };

                const _TrimResult _Res = _Trim_completely(_First1, _Final1, _First2, _Final2, _ProjectedPred);

                if (_Res != _TrimResult::_HaveWorkAfterTrimming) {
                    return _Res == _TrimResult::_ReturnTrue;
                }

                ++_Final1;
                ++_Final2;
                
                
                return _Match_counts(::std:: move(_First1), ::std:: move(_Final1), ::std:: move(_First2), ::std:: move(_Final2),
                    _Pred, _Proj1, _Proj2);
            } else {
                return _Match_counts(::std:: move(_First1), ::std:: move(_Last1), ::std:: move(_First2), ::std:: move(_Last2),
                    _Pred, _Proj1, _Proj2);
            }
        }

        template <class _It1, class _Se1, class _It2, class _Se2, class _Pr, class _Pj1, class _Pj2>
        [[nodiscard]] static constexpr bool _Is_permutation_unsized(
            _It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
            ;
            ;
            ;
            ;
            ;
#line 1012 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

            for (;; ++_First1, (void) ++_First2) { 
                if (_First1 == _Last1) { 
                    return _First2 == _Last2;
                } else if (_First2 == _Last2) { 
                    return false;
                }

                if (!::std:: invoke(_Pred, ::std:: invoke(_Proj1, *_First1), ::std:: invoke(_Proj2, *_First2))) { 
                    break;
                }
            }
            

            auto _Final1 = _First1;
            auto _Final2 = _First2;
            for (;;) {
                ++_Final1;
                ++_Final2;
                if (_Final1 == _Last1) {
                    if (_Final2 == _Last2) {
                        break; 
                    }

                    return false; 
                } else if (_Final2 == _Last2) {
                    return false; 
                }
            }
            

            if constexpr (bidirectional_iterator<_It1> && bidirectional_iterator<_It2>) {
                for (;;) { 
                    if (--_Final1 == _First1) {
                        return false; 
                    }
                    --_Final2; 

                    if (!::std:: invoke(_Pred, ::std:: invoke(_Proj1, *_Final1), ::std:: invoke(_Proj2, *_Final2))) { 
                        break;
                    }
                }
                
                
                const auto _ProjectedPred = [&]<class _Ty1, class _Ty2>(_Ty1&& _Left, _Ty2&& _Right) {
                    return ::std:: invoke(_Pred, ::std:: invoke(_Proj1, ::std:: forward<_Ty1>(_Left)),
                        ::std:: invoke(_Proj2, ::std:: forward<_Ty2>(_Right)));
                };

                const _TrimResult _Res = _Trim_completely(_First1, _Final1, _First2, _Final2, _ProjectedPred);

                if (_Res != _TrimResult::_HaveWorkAfterTrimming) {
                    return _Res == _TrimResult::_ReturnTrue;
                }

                ++_Final1;
                ++_Final2;
                
                
            }

            return _Match_counts(
                ::std:: move(_First1), ::std:: move(_Final1), ::std:: move(_First2), ::std:: move(_Final2), _Pred, _Proj1, _Proj2);
        }

        template <class _It1, class _Se1, class _It2, class _Se2, class _Pr, class _Pj1, class _Pj2>
        [[nodiscard]] static constexpr bool _Match_counts(const _It1 _First1, const _Se1 _Last1, const _It2 _First2,
            const _Se2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
            ;
            ;
            ;
            ;
            ;
#line 1098 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

            for (auto _Current = _First1; _Current != _Last1; ++_Current) {
                bool _Found = false;
                auto _Mid1  = _First1;
                for (; _Mid1 != _Current; ++_Mid1) {
                    if (::std:: invoke(_Pred, ::std:: invoke(_Proj1, *_Current), ::std:: invoke(_Proj1, *_Mid1))) {
                        
                        _Found = true;
                        break;
                    }
                }

                if (_Found) {
                    continue;
                }

                
                iter_difference_t<_It1> _Occurrences = 1;
                while (++_Mid1 != _Last1) {
                    if (::std:: invoke(_Pred, ::std:: invoke(_Proj1, *_Current), ::std:: invoke(_Proj1, *_Mid1))) {
                        ++_Occurrences;
                    }
                }

                
                for (auto _Mid2 = _First2; _Mid2 != _Last2; ++_Mid2) {
                    if (::std:: invoke(_Pred, ::std:: invoke(_Proj1, *_Current), ::std:: invoke(_Proj2, *_Mid2))) {
                        if (--_Occurrences < 0) {
                            
                            return false;
                        }
                    }
                }

                if (_Occurrences != 0) {
                    
                    return false;
                }
            }

            return true;
        }
    };

    inline constexpr _Is_permutation_fn is_permutation{_Not_quite_object::_Construct_tag{}};
} 
#line 1145 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _InIt, class _Pr>
[[nodiscard]] constexpr bool all_of(_InIt _First, _InIt _Last, _Pr _Pred) { 
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    for (; _UFirst != _ULast; ++_UFirst) {
        if (!_Pred(*_UFirst)) {
            return false;
        }
    }

    return true;
}


template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] bool all_of(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept; 
#line 1164 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


namespace ranges {
    class _All_of_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <input_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
        [[nodiscard]] constexpr bool operator()(_It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);

            return _All_of_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)), _Pass_fn(_Pred), _Pass_fn(_Proj));
        }

        template <input_range _Rng, class _Pj = identity,
            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
        [[nodiscard]] constexpr bool operator()(_Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) const {
            return _All_of_unchecked(_Ubegin(_Range), _Uend(_Range), _Pass_fn(_Pred), _Pass_fn(_Proj));
        }

    private:
        template <class _It, class _Se, class _Pj, class _Pr>
        [[nodiscard]] static constexpr bool _All_of_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
            ;
            ;
            ;

            for (; _First != _Last; ++_First) {
                if (!::std:: invoke(_Pred, ::std:: invoke(_Proj, *_First))) {
                    return false;
                }
            }

            return true;
        }
    };

    inline constexpr _All_of_fn all_of{_Not_quite_object::_Construct_tag{}};
} 
#line 1206 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _InIt, class _Pr>
[[nodiscard]] constexpr bool any_of(const _InIt _First, const _InIt _Last, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    for (; _UFirst != _ULast; ++_UFirst) {
        if (_Pred(*_UFirst)) {
            return true;
        }
    }

    return false;
}


template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] bool any_of(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept; 
#line 1226 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


namespace ranges {
    class _Any_of_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <input_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
        [[nodiscard]] constexpr bool operator()(_It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);

            return _Any_of_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)), _Pass_fn(_Pred), _Pass_fn(_Proj));
        }

        template <input_range _Rng, class _Pj = identity,
            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
        [[nodiscard]] constexpr bool operator()(_Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) const {
            return _Any_of_unchecked(_Ubegin(_Range), _Uend(_Range), _Pass_fn(_Pred), _Pass_fn(_Proj));
        }

    private:
        template <class _It, class _Se, class _Pj, class _Pr>
        [[nodiscard]] static constexpr bool _Any_of_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
            ;
            ;
            ;

            for (; _First != _Last; ++_First) {
                if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_First))) {
                    return true;
                }
            }

            return false;
        }
    };

    inline constexpr _Any_of_fn any_of{_Not_quite_object::_Construct_tag{}};
} 
#line 1268 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _InIt, class _Pr>
[[nodiscard]] constexpr bool none_of(const _InIt _First, const _InIt _Last, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    for (; _UFirst != _ULast; ++_UFirst) {
        if (_Pred(*_UFirst)) {
            return false;
        }
    }

    return true;
}


template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] bool none_of(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept; 
#line 1288 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


namespace ranges {
    class _None_of_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <input_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
        [[nodiscard]] constexpr bool operator()(_It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);

            return _None_of_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)), _Pass_fn(_Pred), _Pass_fn(_Proj));
        }

        template <input_range _Rng, class _Pj = identity,
            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
        [[nodiscard]] constexpr bool operator()(_Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) const {
            return _None_of_unchecked(_Ubegin(_Range), _Uend(_Range), _Pass_fn(_Pred), _Pass_fn(_Proj));
        }

    private:
        template <class _It, class _Se, class _Pj, class _Pr>
        [[nodiscard]] static constexpr bool _None_of_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
            ;
            ;
            ;

            for (; _First != _Last; ++_First) {
                if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_First))) {
                    return false;
                }
            }

            return true;
        }
    };

    inline constexpr _None_of_fn none_of{_Not_quite_object::_Construct_tag{}};

    template <class _In, class _Out>
    using copy_n_result = in_out_result<_In, _Out>;

    class _Copy_n_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It, weakly_incrementable _Out>
            requires indirectly_copyable<_It, _Out>
        constexpr copy_n_result<_It, _Out> operator()(_It _First, iter_difference_t<_It> _Count, _Out _Result) const {
            auto _UFirst = _Get_unwrapped_n(::std:: move(_First), _Count);
            if constexpr (_Iter_copy_cat<decltype(_UFirst), _Out>::_Bitcopy_assignable) {
                if (!::std:: is_constant_evaluated()) {
                    auto _Final = _UFirst + _Count;
                    _Result = _Copy_memmove(::std:: move(_UFirst), _Final, ::std:: move(_Result));
                    _Seek_wrapped(_First, ::std:: move(_Final));
                    return {::std:: move(_First), ::std:: move(_Result)};
                }
            }

            for (; _Count > 0; ++_UFirst, (void) ++_Result, --_Count) {
                *_Result = *_UFirst;
            }

            _Seek_wrapped(_First, ::std:: move(_UFirst));
            return {::std:: move(_First), ::std:: move(_Result)};
        }
        
    };

    inline constexpr _Copy_n_fn copy_n{_Not_quite_object::_Construct_tag{}};

    template <class _In, class _Out>
    using copy_backward_result = in_out_result<_In, _Out>;

    class _Copy_backward_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <bidirectional_iterator _It1, sentinel_for<_It1> _Se1, bidirectional_iterator _It2>
            requires indirectly_copyable<_It1, _It2>
        constexpr copy_backward_result<_It1, _It2> operator()(_It1 _First, _Se1 _Last, _It2 _Result) const {
            _Adl_verify_range(_First, _Last);
            auto _UFirst = _Get_unwrapped(::std:: move(_First));
            auto _ULast  = _Get_final_iterator_unwrapped<_It1>(_UFirst, ::std:: move(_Last));
            _Seek_wrapped(_First, _ULast);
            _Result = _Copy_backward_unchecked(::std:: move(_UFirst), ::std:: move(_ULast), ::std:: move(_Result));
            return {::std:: move(_First), ::std:: move(_Result)};
        }

        template <bidirectional_range _Rng, bidirectional_iterator _It>
            requires indirectly_copyable<iterator_t<_Rng>, _It>
        constexpr copy_backward_result<borrowed_iterator_t<_Rng>, _It> operator()(_Rng&& _Range, _It _Result) const {
            auto _ULast = _Get_final_iterator_unwrapped(_Range);
            _Result     = _Copy_backward_unchecked(_Ubegin(_Range), _ULast, ::std:: move(_Result));
            return {_Rewrap_iterator(_Range, ::std:: move(_ULast)), ::std:: move(_Result)};
        }
        
    };

    inline constexpr _Copy_backward_fn copy_backward{_Not_quite_object::_Construct_tag{}};
} 
#line 1394 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _InIt, class _OutIt, class _Pr>
constexpr _OutIt copy_if(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred) { 
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    auto _UDest       = _Get_unwrapped_unverified(_Dest);
    for (; _UFirst != _ULast; ++_UFirst) {
        if (_Pred(*_UFirst)) {
            *_UDest = *_UFirst;
            ++_UDest;
        }
    }

    _Seek_wrapped(_Dest, _UDest);
    return _Dest;
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt2 copy_if(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _Pr _Pred) noexcept  {
    
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: copy_if(_First, _Last, _Dest, _Pass_fn(_Pred));
}
#line 1422 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


namespace ranges {
    template <class _In, class _Out>
    using copy_if_result = in_out_result<_In, _Out>;

    class _Copy_if_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out, class _Pj = identity,
            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
            requires indirectly_copyable<_It, _Out>
        constexpr copy_if_result<_It, _Out> operator()(
            _It _First, _Se _Last, _Out _Result, _Pr _Pred, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            auto _UResult = _Copy_if_unchecked(_Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)),
                ::std:: move(_Result), _Pass_fn(_Pred), _Pass_fn(_Proj));
            _Seek_wrapped(_First, ::std:: move(_UResult.in));
            return {::std:: move(_First), ::std:: move(_UResult.out)};
        }

        template <input_range _Rng, weakly_incrementable _Out, class _Pj = identity,
            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
            requires indirectly_copyable<iterator_t<_Rng>, _Out>
        constexpr copy_if_result<borrowed_iterator_t<_Rng>, _Out> operator()(
            _Rng&& _Range, _Out _Result, _Pr _Pred, _Pj _Proj = {}) const {
            auto _First   = ::std::ranges:: begin(_Range);
            auto _UResult = _Copy_if_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Uend(_Range), ::std:: move(_Result), _Pass_fn(_Pred), _Pass_fn(_Proj));
            _Seek_wrapped(_First, ::std:: move(_UResult.in));
            return {::std:: move(_First), ::std:: move(_UResult.out)};
        }
        

    private:
        template <class _It, class _Se, class _Out, class _Pj, class _Pr>
        [[nodiscard]] static constexpr copy_if_result<_It, _Out> _Copy_if_unchecked(
            _It _First, const _Se _Last, _Out _Result, _Pr _Pred, _Pj _Proj) {
            ;
            ;
            ;
            ;

            for (; _First != _Last; ++_First) {
                if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_First))) {
                    *_Result = *_First;
                    ++_Result;
                }
            }

            return {::std:: move(_First), ::std:: move(_Result)};
        }
    };

    inline constexpr _Copy_if_fn copy_if{_Not_quite_object::_Construct_tag{}};

    template <class _In, class _Out>
    using move_result = in_out_result<_In, _Out>;

    
    template <input_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out>
        requires indirectly_movable<_It, _Out>
    constexpr move_result<_It, _Out> _Move_unchecked(_It _First, _Se _Last, _Out _Result) {
        
        if constexpr (_Iter_move_cat<_It, _Out>::_Bitcopy_assignable) {
            if (!::std:: is_constant_evaluated()) {
                auto _Final = ::std::ranges:: next(_First, ::std:: move(_Last));
                _Result     = _Copy_memmove(::std:: move(_First), _Final, ::std:: move(_Result));
                return {::std:: move(_Final), ::std:: move(_Result)};
            }
        }

        for (; _First != _Last; ++_First, (void) ++_Result) {
            *_Result = ::std::ranges:: iter_move(_First);
        }

        return {::std:: move(_First), ::std:: move(_Result)};
    }

    class _Move_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out>
            requires indirectly_movable<_It, _Out>
        constexpr move_result<_It, _Out> operator()(_It _First, _Se _Last, _Out _Result) const {
            
            _Adl_verify_range(_First, _Last);
            auto _UResult = ::std::ranges:: _Move_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)), ::std:: move(_Result));

            _Seek_wrapped(_First, ::std:: move(_UResult.in));
            return {::std:: move(_First), ::std:: move(_UResult.out)};
        }

        
        template <input_range _Rng, weakly_incrementable _Out>
            requires indirectly_movable<iterator_t<_Rng>, _Out>
        constexpr move_result<borrowed_iterator_t<_Rng>, _Out> operator()(_Rng&& _Range, _Out _Result) const {
            
            auto _First = ::std::ranges:: begin(_Range);
            auto _UResult =
                ::std::ranges:: _Move_unchecked(_Get_unwrapped(::std:: move(_First)), _Uend(_Range), ::std:: move(_Result));

            _Seek_wrapped(_First, ::std:: move(_UResult.in));
            return {::std:: move(_First), ::std:: move(_UResult.out)};
        }
    };

    inline constexpr _Move_fn move{_Not_quite_object::_Construct_tag{}};

    template <class _In, class _Out>
    using move_backward_result = in_out_result<_In, _Out>;

    
    template <bidirectional_iterator _It1, bidirectional_iterator _It2>
        requires indirectly_movable<_It1, _It2>
    constexpr _It2 _Move_backward_common(const _It1 _First, _It1 _Last, _It2 _Result) {
        if constexpr (_Iter_move_cat<_It1, _It2>::_Bitcopy_assignable) {
            if (!::std:: is_constant_evaluated()) {
                return _Copy_backward_memmove(_First, _Last, _Result);
            }
        }

        while (_First != _Last) {
            *--_Result = ::std::ranges:: iter_move(--_Last);
        }

        return _Result;
    }
    

    class _Move_backward_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <bidirectional_iterator _It1, sentinel_for<_It1> _Se1, bidirectional_iterator _It2>
            requires indirectly_movable<_It1, _It2>
        constexpr move_backward_result<_It1, _It2> operator()(_It1 _First, _Se1 _Last, _It2 _Result) const {
            _Adl_verify_range(_First, _Last);
            auto _UFirst = _Get_unwrapped(::std:: move(_First));
            auto _ULast  = _Get_final_iterator_unwrapped<_It1>(_UFirst, ::std:: move(_Last));
            _Seek_wrapped(_First, _ULast);
            _Result = _Move_backward_common(::std:: move(_UFirst), ::std:: move(_ULast), ::std:: move(_Result));
            return {::std:: move(_First), ::std:: move(_Result)};
        }

        template <bidirectional_range _Rng, bidirectional_iterator _It>
            requires indirectly_movable<iterator_t<_Rng>, _It>
        constexpr move_backward_result<borrowed_iterator_t<_Rng>, _It> operator()(_Rng&& _Range, _It _Result) const {
            auto _ULast = _Get_final_iterator_unwrapped(_Range);
            _Result     = _Move_backward_common(_Ubegin(_Range), _ULast, ::std:: move(_Result));
            return {_Rewrap_iterator(_Range, ::std:: move(_ULast)), ::std:: move(_Result)};
        }
        
    };

    inline constexpr _Move_backward_fn move_backward{_Not_quite_object::_Construct_tag{}};
} 
#line 1587 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _InIt, class _OutIt1, class _OutIt2, class _Pr>
constexpr pair<_OutIt1, _OutIt2> partition_copy(
    _InIt _First, _InIt _Last, _OutIt1 _Dest_true, _OutIt2 _Dest_false, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    auto _UDest_true  = _Get_unwrapped_unverified(_Dest_true);
    auto _UDest_false = _Get_unwrapped_unverified(_Dest_false);
    for (; _UFirst != _ULast; ++_UFirst) {
        if (_Pred(*_UFirst)) {
            *_UDest_true = *_UFirst;
            ++_UDest_true;
        } else {
            *_UDest_false = *_UFirst;
            ++_UDest_false;
        }
    }

    _Seek_wrapped(_Dest_false, _UDest_false);
    _Seek_wrapped(_Dest_true, _UDest_true);
    return {_Dest_true, _Dest_false};
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
pair<_FwdIt2, _FwdIt3> partition_copy(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest_true, _FwdIt3 _Dest_false,
    _Pr _Pred) noexcept  {
    
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt3>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: partition_copy(_First, _Last, _Dest_true, _Dest_false, _Pass_fn(_Pred));
}


namespace ranges {
    template <class _In, class _Out1, class _Out2>
    using partition_copy_result = in_out_out_result<_In, _Out1, _Out2>;

    class _Partition_copy_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out1, weakly_incrementable _Out2,
            class _Pj = identity, indirect_unary_predicate<projected<_It, _Pj>> _Pr>
            requires indirectly_copyable<_It, _Out1> && indirectly_copyable<_It, _Out2>
        constexpr partition_copy_result<_It, _Out1, _Out2> operator()(
            _It _First, _Se _Last, _Out1 _Dest_true, _Out2 _Dest_false, _Pr _Pred, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            auto _UResult = _Partition_copy_unchecked(_Get_unwrapped(::std:: move(_First)),
                _Get_unwrapped(::std:: move(_Last)), _Get_unwrapped_unverified(::std:: move(_Dest_true)),
                _Get_unwrapped_unverified(::std:: move(_Dest_false)), _Pass_fn(_Pred), _Pass_fn(_Proj));
            _Seek_wrapped(_First, ::std:: move(_UResult.in));
            _Seek_wrapped(_Dest_true, ::std:: move(_UResult.out1));
            _Seek_wrapped(_Dest_false, ::std:: move(_UResult.out2));
            return {::std:: move(_First), ::std:: move(_Dest_true), ::std:: move(_Dest_false)};
        }

        template <input_range _Rng, weakly_incrementable _Out1, weakly_incrementable _Out2, class _Pj = identity,
            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
            requires indirectly_copyable<iterator_t<_Rng>, _Out1> && indirectly_copyable<iterator_t<_Rng>, _Out2>
        constexpr partition_copy_result<borrowed_iterator_t<_Rng>, _Out1, _Out2> operator()(
            _Rng&& _Range, _Out1 _Dest_true, _Out2 _Dest_false, _Pr _Pred, _Pj _Proj = {}) const {
            auto _First   = ::std::ranges:: begin(_Range);
            auto _UResult = _Partition_copy_unchecked(_Get_unwrapped(::std:: move(_First)), _Uend(_Range),
                _Get_unwrapped_unverified(::std:: move(_Dest_true)), _Get_unwrapped_unverified(::std:: move(_Dest_false)),
                _Pass_fn(_Pred), _Pass_fn(_Proj));
            _Seek_wrapped(_First, ::std:: move(_UResult.in));
            _Seek_wrapped(_Dest_true, ::std:: move(_UResult.out1));
            _Seek_wrapped(_Dest_false, ::std:: move(_UResult.out2));
            return {::std:: move(_First), ::std:: move(_Dest_true), ::std:: move(_Dest_false)};
        }
        
    private:
        template <class _It, class _Se, class _Out1, class _Out2, class _Pr, class _Pj>
        [[nodiscard]] static constexpr partition_copy_result<_It, _Out1, _Out2> _Partition_copy_unchecked(
            _It _First, const _Se _Last, _Out1 _Dest_true, _Out2 _Dest_false, _Pr _Pred, _Pj _Proj) {
            
            ;
            ;
            ;
            ;
            ;

            for (; _First != _Last; ++_First) {
                if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_First))) {
                    *_Dest_true = *_First;
                    ++_Dest_true;
                } else {
                    *_Dest_false = *_First;
                    ++_Dest_false;
                }
            }

            return {::std:: move(_First), ::std:: move(_Dest_true), ::std:: move(_Dest_false)};
        }
    };

    inline constexpr _Partition_copy_fn partition_copy{_Not_quite_object::_Construct_tag{}};
} 
#line 1692 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
#line 1693 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _InIt, class _Pr>
[[nodiscard]] constexpr bool is_partitioned(const _InIt _First, const _InIt _Last, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);

    for (;; ++_UFirst) { 
        if (_UFirst == _ULast) {
            return true;
        }

        if (!_Pred(*_UFirst)) {
            break;
        }
    }

    while (++_UFirst != _ULast) { 
        if (_Pred(*_UFirst)) {
            return false; 
        }
    }

    return true;
}


template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] bool is_partitioned(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept; 
#line 1724 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


namespace ranges {
    class _Is_partitioned_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <input_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
        [[nodiscard]] constexpr bool operator()(_It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            return _Is_partitioned_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)), _Pass_fn(_Pred), _Pass_fn(_Proj));
        }

        template <input_range _Rng, class _Pj = identity,
            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
        [[nodiscard]] constexpr bool operator()(_Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) const {
            return _Is_partitioned_unchecked(_Ubegin(_Range), _Uend(_Range), _Pass_fn(_Pred), _Pass_fn(_Proj));
        }

    private:
        template <class _It, class _Se, class _Pr, class _Pj>
        [[nodiscard]] static constexpr bool _Is_partitioned_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
            
            ;
            ;
            ;

            for (;; ++_First) { 
                if (_First == _Last) {
                    return true;
                }

                if (!::std:: invoke(_Pred, ::std:: invoke(_Proj, *_First))) {
                    break;
                }
            }

            while (++_First != _Last) { 
                if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_First))) {
                    return false; 
                }
            }

            return true;
        }
    };

    inline constexpr _Is_partitioned_fn is_partitioned{_Not_quite_object::_Construct_tag{}};
} 
#line 1776 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _FwdIt, class _Pr>
[[nodiscard]] constexpr _FwdIt partition_point(_FwdIt _First, _FwdIt _Last, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    auto _Count       = ::std:: distance(_UFirst, _ULast);
    while (0 < _Count) { 
        const auto _Count2 = static_cast<_Iter_diff_t<_FwdIt>>(_Count / 2);
        const auto _UMid   = ::std:: next(_UFirst, _Count2);

        if (_Pred(*_UMid)) { 
            _UFirst = _Next_iter(_UMid);
            _Count -= _Count2;
            --_Count;
        } else {
            _Count = _Count2;
        }
    }

    _Seek_wrapped(_First, _UFirst);
    return _First;
}


namespace ranges {
    class _Partition_point_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <forward_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
        [[nodiscard]] constexpr _It operator()(_It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            auto _UFirst = _Get_unwrapped(::std:: move(_First));
            if constexpr (sized_sentinel_for<_Se, _It>) {
                const auto _Length = _Get_unwrapped(::std:: move(_Last)) - _UFirst;
                _UFirst = _Partition_point_n_unchecked(::std:: move(_UFirst), _Length, _Pass_fn(_Pred), _Pass_fn(_Proj));
            } else {
                _UFirst = _Partition_point_unchecked(
                    ::std:: move(_UFirst), _Get_unwrapped(::std:: move(_Last)), _Pass_fn(_Pred), _Pass_fn(_Proj));
            }

            _Seek_wrapped(_First, ::std:: move(_UFirst));
            return _First;
        }

        template <forward_range _Rng, class _Pj = identity,
            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
        [[nodiscard]] constexpr borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) const {
            if constexpr (sized_range<_Rng>) {
                const auto _Length = ::std::ranges:: distance(_Range);
                auto _UFirst = _Partition_point_n_unchecked(_Ubegin(_Range), _Length, _Pass_fn(_Pred), _Pass_fn(_Proj));
                return _Rewrap_iterator(_Range, ::std:: move(_UFirst));
            } else {
                auto _UFirst =
                    _Partition_point_unchecked(_Ubegin(_Range), _Uend(_Range), _Pass_fn(_Pred), _Pass_fn(_Proj));
                return _Rewrap_iterator(_Range, ::std:: move(_UFirst));
            }
        }

    private:
        template <class _It, class _Pr, class _Pj>
        [[nodiscard]] static constexpr _It _Partition_point_n_unchecked(
            _It _First, iter_difference_t<_It> _Length, _Pr _Pred, _Pj _Proj) {
            ;
            ;
            ;

            while (_Length > 0) {
                const auto _Half = static_cast<iter_difference_t<_It>>(_Length / 2);
                auto _Mid        = ::std::ranges:: next(_First, _Half);
                if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Mid))) { 
                    _First = ::std:: move(_Mid);
                    ++_First;
                    _Length -= _Half;
                    --_Length;
                } else { 
                    _Length = _Half;
                }
            }

            return _First;
        }

        template <class _It, class _Se, class _Pr, class _Pj>
        [[nodiscard]] static constexpr _It _Partition_point_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
            ;
            ;
            ;

            
            iter_difference_t<_It> _Skip = 2;
            for (;;) {
                auto _Mid = _First;
                _Skip -= ::std::ranges:: advance(_Mid, _Skip, _Last);
                if (_Mid == _Last) { 
                    break;
                }

                if (!::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Mid))) { 
                    break;
                }

                _First = ::std:: move(_Mid);
                ++_First;

                using _Uty = _Make_unsigned_like_t<iter_difference_t<_It>>;
                if (static_cast<_Uty>(_Skip) <= (static_cast<_Uty>(-1) >> 1)) {
                    _Skip <<= 1;
                }
            }

            return _Partition_point_n_unchecked(::std:: move(_First), _Skip, _Pred, _Proj);
        }
    };

    inline constexpr _Partition_point_fn partition_point{_Not_quite_object::_Construct_tag{}};
} 
#line 1898 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _InIt1, class _InIt2, class _Pr>
[[nodiscard]] constexpr bool _Equal_rev_pred_unchecked(_InIt1 _First1, _InIt2 _First2, const _InIt2 _Last2, _Pr _Pred) {
    
    if constexpr (_Equal_memcmp_is_safe<_InIt1, _InIt2, _Pr>) {

        if (!::std:: is_constant_evaluated())
#line 1906 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
        {
            return _Memcmp_ranges(_First2, _Last2, _First1) == 0;
        }
    }

    for (; _First2 != _Last2; ++_First1, (void) ++_First2) {
        if (!_Pred(*_First1, *_First2)) {
            return false;
        }
    }

    return true;
}

template <class _FwdItHaystack, class _FwdItPat, class _Pr>
[[nodiscard]] constexpr _FwdItHaystack search(_FwdItHaystack _First1, _FwdItHaystack _Last1, const _FwdItPat _First2,
    const _FwdItPat _Last2, _Pr _Pred) { 
    _Adl_verify_range(_First1, _Last1);
    _Adl_verify_range(_First2, _Last2);
    auto _UFirst1       = _Get_unwrapped(_First1);
    const auto _ULast1  = _Get_unwrapped(_Last1);
    const auto _UFirst2 = _Get_unwrapped(_First2);
    const auto _ULast2  = _Get_unwrapped(_Last2);
    if constexpr (_Is_random_iter_v<_FwdItHaystack> && _Is_random_iter_v<_FwdItPat>) {
        const _Iter_diff_t<_FwdItPat> _Count2 = _ULast2 - _UFirst2;
        if (_ULast1 - _UFirst1 >= _Count2) {
            const auto _Last_possible = _ULast1 - static_cast<_Iter_diff_t<_FwdItHaystack>>(_Count2);
            for (;; ++_UFirst1) {
                if (_Equal_rev_pred_unchecked(_UFirst1, _UFirst2, _ULast2, _Pass_fn(_Pred))) {
                    _Seek_wrapped(_Last1, _UFirst1);
                    break;
                }

                if (_UFirst1 == _Last_possible) {
                    break;
                }
            }
        }
    } else {
        for (;; ++_UFirst1) { 
            auto _UMid1 = _UFirst1;
            for (auto _UMid2 = _UFirst2;; ++_UMid1, (void) ++_UMid2) {
                if (_UMid2 == _ULast2) {
                    _Seek_wrapped(_Last1, _UFirst1);
                    return _Last1;
                } else if (_UMid1 == _ULast1) {
                    return _Last1;
                } else if (!_Pred(*_UMid1, *_UMid2)) {
                    break;
                }
            }
        }
    }

    return _Last1;
}


template <class _ExPo, class _FwdItHaystack, class _FwdItPat, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _FwdItHaystack search(_ExPo&& _Exec, const _FwdItHaystack _First1, _FwdItHaystack _Last1,
    const _FwdItPat _First2, const _FwdItPat _Last2, _Pr _Pred) noexcept; 
#line 1968 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _FwdItHaystack, class _FwdItPat>
[[nodiscard]] constexpr _FwdItHaystack search(
    const _FwdItHaystack _First1, const _FwdItHaystack _Last1, const _FwdItPat _First2, const _FwdItPat _Last2) {
    
    return ::std:: search(_First1, _Last1, _First2, _Last2, equal_to<>{});
}


template <class _ExPo, class _FwdItHaystack, class _FwdItPat, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _FwdItHaystack search(_ExPo&& _Exec, const _FwdItHaystack _First1, const _FwdItHaystack _Last1,
    const _FwdItPat _First2, const _FwdItPat _Last2) noexcept  {
    
    return ::std:: search(::std:: forward<_ExPo>(_Exec), _First1, _Last1, _First2, _Last2, equal_to{});
}
#line 1984 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _FwdItHaystack, class _Searcher>
[[nodiscard]] constexpr _FwdItHaystack search(
    const _FwdItHaystack _First, const _FwdItHaystack _Last, const _Searcher& _Search) {
    
    return _Search(_First, _Last).first;
}

template <class _FwdIt, class _Diff, class _Ty, class _Pr>
[[nodiscard]] constexpr _FwdIt search_n(
    const _FwdIt _First, _FwdIt _Last, const _Diff _Count_raw, const _Ty& _Val, _Pr _Pred) {
    
    const _Algorithm_int_t<_Diff> _Count = _Count_raw;
    if (_Count <= 0) {
        return _First;
    }

    if (static_cast<uintmax_t>(_Count) > static_cast<uintmax_t>((numeric_limits<_Iter_diff_t<_FwdIt>>::max)())) {
        
        return _Last;
    }

    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    if constexpr (_Is_random_iter_v<_FwdIt>) {
        const auto _Count_diff = static_cast<_Iter_diff_t<_FwdIt>>(_Count);
        auto _UOld_first       = _UFirst;
        for (_Iter_diff_t<_FwdIt> _Inc = 0; _Count_diff <= _ULast - _UOld_first;) { 
            _UFirst = _UOld_first + _Inc;
            if (_Pred(*_UFirst, _Val)) { 
                _Iter_diff_t<_FwdIt> _Count1 = _Count_diff;
                auto _UMid                   = _UFirst;

                while (_UOld_first != _UFirst && _Pred(*_Prev_iter(_UFirst), _Val)) { 
                    --_Count1;
                    --_UFirst;
                }

                if (_Count1 <= _ULast - _UMid) {
                    for (;;) { 
                        if (--_Count1 == 0) {
                            _Seek_wrapped(_Last, _UFirst); 
                            return _Last;
                        } else if (!_Pred(*++_UMid, _Val)) { 
                            break;
                        }
                    }
                }
                _UOld_first = ++_UMid; 
                _Inc        = 0;
            } else { 
                _UOld_first = _Next_iter(_UFirst);
                _Inc        = _Count_diff - 1;
            }
        }
    } else {
        for (; _UFirst != _ULast; ++_UFirst) {
            if (_Pred(*_UFirst, _Val)) { 
                auto _UMid = _UFirst;

                for (_Algorithm_int_t<_Diff> _Count1 = _Count;;) {
                    if (--_Count1 == 0) {
                        _Seek_wrapped(_Last, _UFirst); 
                        return _Last;
                    } else if (++_UMid == _ULast) {
                        return _Last; 
                    } else if (!_Pred(*_UMid, _Val)) { 
                        break;
                    }
                }

                _UFirst = _UMid; 
            }
        }
    }

    return _Last;
}


template <class _ExPo, class _FwdIt, class _Diff, class _Ty, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _FwdIt search_n(_ExPo&& _Exec, const _FwdIt _First, _FwdIt _Last, const _Diff _Count_raw, const _Ty& _Val,
    _Pr _Pred) noexcept; 
#line 2069 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _FwdIt, class _Diff, class _Ty>
[[nodiscard]] constexpr _FwdIt search_n(const _FwdIt _First, const _FwdIt _Last, const _Diff _Count, const _Ty& _Val) {
    
    return ::std:: search_n(_First, _Last, _Count, _Val, equal_to<>{});
}


template <class _ExPo, class _FwdIt, class _Diff, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _FwdIt search_n(_ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last, const _Diff _Count,
    const _Ty& _Val) noexcept  { 
    return ::std:: search_n(::std:: forward<_ExPo>(_Exec), _First, _Last, _Count, _Val, equal_to{});
}
#line 2083 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


namespace ranges {
    class _Search_n_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <forward_iterator _It, sentinel_for<_It> _Se, class _Ty, class _Pr = ranges::equal_to,
            class _Pj = identity>
            requires indirectly_comparable<_It, const _Ty*, _Pr, _Pj>
        [[nodiscard]] constexpr subrange<_It> operator()(_It _First, _Se _Last, const iter_difference_t<_It> _Count,
            const _Ty& _Val, _Pr _Pred = {}, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);

            if (_Count <= 0) {
                return {_First, _First};
            }

            auto _UFirst = _Get_unwrapped(::std:: move(_First));
            auto _ULast  = _Get_unwrapped(::std:: move(_Last));

            if constexpr (sized_sentinel_for<_Se, _It>) {
                const auto _Dist = _ULast - _UFirst;
                auto _UResult =
                    _Search_n_sized(::std:: move(_UFirst), _Dist, _Val, _Count, _Pass_fn(_Pred), _Pass_fn(_Proj));
                return _Rewrap_subrange<subrange<_It>>(_First, ::std:: move(_UResult));
            } else {
                auto _UResult = _Search_n_unsized(
                    ::std:: move(_UFirst), ::std:: move(_ULast), _Val, _Count, _Pass_fn(_Pred), _Pass_fn(_Proj));
                return _Rewrap_subrange<subrange<_It>>(_First, ::std:: move(_UResult));
            }
        }

        template <forward_range _Rng, class _Ty, class _Pr = ranges::equal_to, class _Pj = identity>
            requires indirectly_comparable<iterator_t<_Rng>, const _Ty*, _Pr, _Pj>
        [[nodiscard]] constexpr borrowed_subrange_t<_Rng> operator()(_Rng&& _Range, const range_difference_t<_Rng> _Count,
            const _Ty& _Val, _Pr _Pred = {}, _Pj _Proj = {}) const {
            auto _First = ::std::ranges:: begin(_Range);

            if (_Count <= 0) {
                return {_First, _First};
            }

            if constexpr (sized_range<_Rng>) {
                const auto _Dist = ::std::ranges:: distance(_Range);

                auto _UResult =
                    _Search_n_sized(_Get_unwrapped(_First), _Dist, _Val, _Count, _Pass_fn(_Pred), _Pass_fn(_Proj));
                return _Rewrap_subrange<borrowed_subrange_t<_Rng>>(_First, ::std:: move(_UResult));
            } else {
                auto _UResult = _Search_n_unsized(
                    _Get_unwrapped(_First), _Uend(_Range), _Val, _Count, _Pass_fn(_Pred), _Pass_fn(_Proj));
                return _Rewrap_subrange<borrowed_subrange_t<_Rng>>(_First, ::std:: move(_UResult));
            }
        }
        

    private:
        template <class _It, class _Ty, class _Pr, class _Pj>
        [[nodiscard]] static constexpr subrange<_It> _Search_n_sized(_It _First, iter_difference_t<_It> _Dist,
            const _Ty& _Val, const iter_difference_t<_It> _Count, _Pr _Pred, _Pj _Proj) {
            ;
            ;
            ;
            

            if constexpr (bidirectional_iterator<_It>) {
                if (_Dist < _Count) {
                    ::std::ranges:: advance(_First, _Dist);
                    return {_First, _First};
                }

                auto _Last = ::std::ranges:: next(_First, _Count);
                auto _Mid1 = _First;
                auto _Mid2 = _Last;
                for (;;) {
                    
                    
                    --_Mid2;
                    if (!::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Mid2), _Val)) { 
                        ++_Mid2;
                        const auto _Delta = ::std::ranges:: distance(_First, _Mid2);

                        if (_Dist - _Delta < _Count) { 
                            _First = ::std:: move(_Last);
                            _Dist -= _Count;
                            break;
                        }

                        _First = ::std:: move(_Mid2);
                        _Dist -= _Delta;
                        _Mid1 = _Last;
                        ::std::ranges:: advance(_Last, _Delta);
                        _Mid2 = _Last;
                        continue;
                    }

                    if (_Mid2 == _Mid1) { 
                        return {::std:: move(_First), ::std:: move(_Last)};
                    }
                }
            } else {
                for (; _Dist >= _Count; ++_First, (void) --_Dist) {
                    if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_First), _Val)) {
                        auto _Saved = _First;
                        for (iter_difference_t<_It> _Len = 0;;) {
                            ++_First;
                            if (++_Len == _Count) { 
                                return {::std:: move(_Saved), ::std:: move(_First)};
                            }

                            if (!::std:: invoke(_Pred, ::std:: invoke(_Proj, *_First), _Val)) { 
                                _Dist -= _Len;
                                break;
                            }
                        }
                    }
                }
            }

            ::std::ranges:: advance(_First, _Dist);
            return {_First, _First};
        }

        template <class _It, class _Se, class _Ty, class _Pr, class _Pj>
        [[nodiscard]] static constexpr subrange<_It> _Search_n_unsized(
            _It _First, const _Se _Last, const _Ty& _Val, const iter_difference_t<_It> _Count, _Pr _Pred, _Pj _Proj) {
            ;
            ;
            ;
            ;

            for (; _First != _Last; ++_First) {
                if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_First), _Val)) {
                    auto _Saved = _First;
                    for (auto _Len = _Count;;) {
                        ++_First;
                        if (--_Len == 0) { 
                            return {::std:: move(_Saved), ::std:: move(_First)};
                        }

                        if (_First == _Last) { 
                            return {_First, _First};
                        }

                        if (!::std:: invoke(_Pred, ::std:: invoke(_Proj, *_First), _Val)) { 
                            break;
                        }
                    }
                }
            }

            return {_First, _First};
        }
    };

    inline constexpr _Search_n_fn search_n{_Not_quite_object::_Construct_tag{}};


    class _Starts_with_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2,
            class _Pr = ranges::equal_to, class _Pj1 = identity, class _Pj2 = identity>
            requires indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
        [[nodiscard]] constexpr bool operator()(_It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2, _Pr _Pred = {},
            _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            
            _Adl_verify_range(_First1, _Last1);
            _Adl_verify_range(_First2, _Last2);

            auto _UFirst1      = _Get_unwrapped(::std:: move(_First1));
            auto _ULast1       = _Get_unwrapped(::std:: move(_Last1));
            auto _UFirst2      = _Get_unwrapped(::std:: move(_First2));
            const auto _ULast2 = _Get_unwrapped(::std:: move(_Last2));
            if constexpr (_Sized_or_unreachable_sentinel_for<_Se1, _It1> && sized_sentinel_for<_Se2, _It2>) {
                const iter_difference_t<_It2> _Count2 = _ULast2 - _UFirst2;
                if constexpr (sized_sentinel_for<_Se1, _It1>) {
                    if (_Count2 > _ULast1 - _UFirst1) {
                        return false;
                    }
                }

                return ::std::ranges:: _Equal_count(::std:: move(_UFirst1), ::std:: move(_UFirst2),
                    static_cast<iter_difference_t<_It1>>(_Count2), _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
            } else {
                const auto _Result = ::std::ranges:: _Mismatch_4(::std:: move(_UFirst1), ::std:: move(_ULast1), ::std:: move(_UFirst2),
                    _ULast2, _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
                return _Result.in2 == _ULast2;
            }
        }

        
        template <input_range _Rng1, input_range _Rng2, class _Pr = ranges::equal_to, class _Pj1 = identity,
            class _Pj2 = identity>
            requires indirectly_comparable<iterator_t<_Rng1>, iterator_t<_Rng2>, _Pr, _Pj1, _Pj2>
        [[nodiscard]] constexpr bool operator()(
                _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            
            if constexpr (_Sized_or_infinite_range<_Rng1> && sized_range<_Rng2>) {
                const range_difference_t<_Rng2> _Count2 = ::std::ranges:: distance(_Range2);
                if constexpr (sized_range<_Rng1>) {
                    if (_Count2 > ::std::ranges:: distance(_Range1)) {
                        return false;
                    }
                }

                return ::std::ranges:: _Equal_count(_Ubegin(_Range1), _Ubegin(_Range2),
                    static_cast<range_difference_t<_Rng1>>(_Count2), _Pass_fn(_Pred), _Pass_fn(_Proj1),
                    _Pass_fn(_Proj2));
            } else {
                const auto _ULast2 = _Uend(_Range2);
                const auto _Result = ::std::ranges:: _Mismatch_4(_Ubegin(_Range1), _Uend(_Range1), _Ubegin(_Range2), _ULast2,
                    _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
                return _Result.in2 == _ULast2;
            }
        }
    };

    inline constexpr _Starts_with_fn starts_with{_Not_quite_object::_Construct_tag{}};

    class _Ends_with_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2,
            class _Pr = ranges::equal_to, class _Pj1 = identity, class _Pj2 = identity>
            requires (forward_iterator<_It1> || sized_sentinel_for<_Se1, _It1>)
                  && (forward_iterator<_It2> || sized_sentinel_for<_Se2, _It2>)
                  && indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
        [[nodiscard]] constexpr bool operator()(_It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2, _Pr _Pred = {},
            _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            
            _Adl_verify_range(_First1, _Last1);
            _Adl_verify_range(_First2, _Last2);
            auto _UFirst1 = _Get_unwrapped(::std:: move(_First1));
            auto _ULast1  = _Get_unwrapped(::std:: move(_Last1));
            auto _UFirst2 = _Get_unwrapped(::std:: move(_First2));
            auto _ULast2  = _Get_unwrapped(::std:: move(_Last2));

            const auto _Count1 = _Distance_helper(_UFirst1, _ULast1);
            const auto _Count2 = _Distance_helper(_UFirst2, _ULast2);

            return _Ends_with_impl(::std:: move(_UFirst1), ::std:: move(_ULast1), _Count1, ::std:: move(_UFirst2),
                ::std:: move(_ULast2), _Count2, _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
        }

        
        template <input_range _Rng1, input_range _Rng2, class _Pr = ranges::equal_to, class _Pj1 = identity,
            class _Pj2 = identity>
            requires (forward_range<_Rng1> || sized_range<_Rng1>)
                  && (forward_range<_Rng2> || sized_range<_Rng2>)
                  && indirectly_comparable<iterator_t<_Rng1>, iterator_t<_Rng2>, _Pr, _Pj1, _Pj2>
        [[nodiscard]] constexpr bool operator()(
                _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            
            const auto _Count1 = _Distance_helper(_Range1);
            const auto _Count2 = _Distance_helper(_Range2);

            return _Ends_with_impl(_Ubegin(_Range1), _Uend(_Range1), _Count1, _Ubegin(_Range2), _Uend(_Range2), _Count2,
                _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
        }

    private:
        struct _Not_a_difference {};

        template <class _It, class _Se>
        [[nodiscard]] static constexpr auto _Distance_helper(const _It& _First, const _Se& _Last) {
            ;
            if constexpr (sized_sentinel_for<_Se, _It>) {
                return _Last - _First;
            } else {
                return _Not_a_difference{};
            }
        }

        template <class _Rng>
        [[nodiscard]] static constexpr auto _Distance_helper(_Rng&& _Range) {
            ;
            if constexpr (sized_range<_Rng>) {
                return ::std::ranges:: distance(_Range);
            } else {
                return _Not_a_difference{};
            }
        }

        template <class _Ty, class _It1, class _It2, class _Pr, class _Pj1, class _Pj2>
        [[nodiscard]] static constexpr bool _Match_backwards(
            const _Ty _First1, _It1 _Last1, const _It2 _First2, _It2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
            ;
            ;
            ;
            ;

            for (;;) {
                if (_First2 == _Last2) { 
                    return true;
                }

                if (_First1 == _Last1) { 
                    return false;
                }

                --_Last1;
                --_Last2;
                if (!::std:: invoke(_Pred, ::std:: invoke(_Proj1, *_Last1), ::std:: invoke(_Proj2, *_Last2))) {
                    return false; 
                }
            }
        }

        template <class _It1, class _Se1, class _Diff1, class _It2, class _Pr, class _Pj1, class _Pj2>
        [[nodiscard]] static constexpr bool _Ends_with_sized_needle(_It1 _First1, _Se1 _Last1, _Diff1 _Count1,
            _It2 _First2, iter_difference_t<_It2> _Count2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
            ;
            ;
            ;
            ;

            constexpr bool _Sized1 = !same_as<_Diff1, _Not_a_difference>;

            if constexpr (random_access_iterator<_It1> && _Sized1) {
                _First1 += static_cast<iter_difference_t<_It1>>(_Count1 - _Count2);
            } else if constexpr (_Bidi_common<_It1, _Se1>) {
                if constexpr (_Sized1) {
                    if ((_Count1 >> 1) >= _Count2) { 
                        ::std::ranges:: advance(_Last1, static_cast<iter_difference_t<_It1>>(-_Count2));
                        _First1 = ::std:: move(_Last1);
                    } else { 
                        ::std::ranges:: advance(_First1, static_cast<iter_difference_t<_It1>>(_Count1 - _Count2));
                    }
                } else { 
                    if (::std::ranges:: advance(_Last1, static_cast<iter_difference_t<_It1>>(-_Count2), _First1) != 0) {
                        
                        return false;
                    }
                    _First1 = ::std:: move(_Last1);
                }
            } else if constexpr (forward_iterator<_It1>) {
                auto _Mid1  = _First1;
                auto _Count = _Count2;
                do {
                    if (_Mid1 == _Last1) { 
                        return false;
                    }

                    ++_Mid1;
                } while (--_Count != 0);

                
                while (_Mid1 != _Last1) {
                    ++_First1;
                    ++_Mid1;
                }
            } else {
                ::std::ranges:: advance(_First1, static_cast<iter_difference_t<_It1>>(_Count1 - _Count2));
            }

            return ::std::ranges:: _Equal_count(::std:: move(_First1), ::std:: move(_First2),
                static_cast<iter_difference_t<_It1>>(_Count2), _Pred, _Proj1, _Proj2);
        }

        template <class _It1, class _Se1, class _Diff1, class _It2, class _Se2, class _Pr, class _Pj1, class _Pj2>
        [[nodiscard]] static constexpr bool _Ends_with_unsized_needle(
            _It1 _First1, _Se1 _Last1, _Diff1 _Count1, _It2 _First2, _Se2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
            ;
            ;
            ;
            ;

            constexpr bool _Sized1 = !same_as<_Diff1, _Not_a_difference>;

            iter_difference_t<_It2> _Count2 = 0;

            if constexpr (_Sized1) {
                for (auto _Mid2 = _First2; _Mid2 != _Last2; ++_Mid2, (void) ++_Count2) {
                    if (_Count2 == _Count1) { 
                        return false;
                    }
                }

                ::std::ranges:: advance(_First1, static_cast<iter_difference_t<_It1>>(_Count1 - _Count2));
            } else { 
                auto _Mid1 = _First1;
                for (auto _Mid2 = _First2; _Mid2 != _Last2; ++_Mid1, (void) ++_Mid2, ++_Count2) {
                    if (_Mid1 == _Last1) { 
                        return false;
                    }
                }

                
                while (_Mid1 != _Last1) {
                    ++_First1;
                    ++_Mid1;
                }
            }

            return ::std::ranges:: _Equal_count(::std:: move(_First1), ::std:: move(_First2),
                static_cast<iter_difference_t<_It1>>(_Count2), _Pred, _Proj1, _Proj2);
        }

        template <class _It1, class _Se1, class _Diff1, class _It2, class _Se2, class _Diff2, class _Pr, class _Pj1,
            class _Pj2>
        [[nodiscard]] static constexpr bool _Ends_with_impl(_It1 _First1, _Se1 _Last1, _Diff1 _Count1, _It2 _First2,
            _Se2 _Last2, _Diff2 _Count2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
            ;
            ;
            ;
            ;
            ;

            constexpr bool _Sized1           = !same_as<_Diff1, _Not_a_difference>;
            constexpr bool _Sized2           = !same_as<_Diff2, _Not_a_difference>;
            constexpr bool _Both_sized       = _Sized1 && _Sized2;
            constexpr bool _Both_bidi_common = _Bidi_common<_It1, _Se1> && _Bidi_common<_It2, _Se2>;

            if constexpr (_Both_sized) {
                if (_Count2 > _Count1) {
                    return false;
                }
            }

            if constexpr (_Sized2) {
                if (_Count2 == 0) {
                    return true;
                }
            }

            if constexpr (_Both_bidi_common && !(random_access_iterator<_It1> && _Both_sized)) {
                if constexpr (_Both_sized) {
                    return _Match_backwards(unreachable_sentinel, ::std:: move(_Last1), ::std:: move(_First2),
                        ::std:: move(_Last2), _Pred, _Proj1, _Proj2);
                } else {
                    return _Match_backwards(::std:: move(_First1), ::std:: move(_Last1), ::std:: move(_First2),
                        ::std:: move(_Last2), _Pred, _Proj1, _Proj2);
                }
            } else if constexpr (_Sized2) {
                return _Ends_with_sized_needle(
                    ::std:: move(_First1), ::std:: move(_Last1), _Count1, ::std:: move(_First2), _Count2, _Pred, _Proj1, _Proj2);
            } else {
                return _Ends_with_unsized_needle(::std:: move(_First1), ::std:: move(_Last1), _Count1, ::std:: move(_First2),
                    ::std:: move(_Last2), _Pred, _Proj1, _Proj2);
            }
        }
    };

    inline constexpr _Ends_with_fn ends_with{_Not_quite_object::_Construct_tag{}};
#line 2538 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
} 
#line 2540 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _FwdIt1, class _FwdIt2, class _Pr>
[[nodiscard]] constexpr _FwdIt1 find_end(
    _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2, const _FwdIt2 _Last2, _Pr _Pred) {
    
    _Adl_verify_range(_First1, _Last1);
    _Adl_verify_range(_First2, _Last2);
    auto _UFirst1       = _Get_unwrapped(_First1);
    const auto _ULast1  = _Get_unwrapped(_Last1);
    const auto _UFirst2 = _Get_unwrapped(_First2);
    const auto _ULast2  = _Get_unwrapped(_Last2);
    if constexpr (_Is_random_iter_v<_FwdIt1> && _Is_random_iter_v<_FwdIt2>) {
        const _Iter_diff_t<_FwdIt2> _Count2 = _ULast2 - _UFirst2;
        if (_Count2 > 0 && _Count2 <= _ULast1 - _UFirst1) {
            for (auto _UCandidate = _ULast1 - static_cast<_Iter_diff_t<_FwdIt1>>(_Count2);; --_UCandidate) {
                if (_Equal_rev_pred_unchecked(_UCandidate, _UFirst2, _ULast2, _Pass_fn(_Pred))) {
                    _Seek_wrapped(_First1, _UCandidate);
                    return _First1;
                }

                if (_UCandidate == _UFirst1) {
                    break;
                }
            }
        }

        return _Last1;
    } else if constexpr (_Is_bidi_iter_v<_FwdIt1> && _Is_bidi_iter_v<_FwdIt2>) {
        for (auto _UCandidate = _ULast1;; --_UCandidate) { 
            auto _UNext1 = _UCandidate;
            auto _UNext2 = _ULast2;
            for (;;) { 
                if (_UFirst2 == _UNext2) { 
                    _Seek_wrapped(_First1, _UNext1);
                    return _First1;
                }

                if (_UFirst1 == _UNext1) {
                    
                    return _Last1;
                }

                --_UNext1;
                --_UNext2;
                if (!_Pred(*_UNext1, *_UNext2)) { 
                    break;
                }
            }
        }
    } else {
        auto _UResult = _ULast1;
        for (;;) { 
            auto _UNext1 = _UFirst1;
            auto _UNext2 = _UFirst2;
            for (;;) { 
                const bool _End_of_needle = static_cast<bool>(_UNext2 == _ULast2);
                if (_End_of_needle) { 
                    _UResult = _UFirst1;
                }

                if (_UNext1 == _ULast1) {
                    
                    _Seek_wrapped(_First1, _UResult);
                    return _First1;
                }

                if (_End_of_needle || !_Pred(*_UNext1, *_UNext2)) {
                    break; 
                }

                ++_UNext1;
                ++_UNext2;
            }

            ++_UFirst1;
        }

        _Seek_wrapped(_First1, _UResult);
        return _First1;
    }
}

template <class _FwdIt1, class _FwdIt2>
[[nodiscard]] constexpr _FwdIt1 find_end(
    _FwdIt1 const _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2, const _FwdIt2 _Last2) {
    
    return ::std:: find_end(_First1, _Last1, _First2, _Last2, equal_to<>{});
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _FwdIt1 find_end(
    _ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred) noexcept; 

template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _FwdIt1 find_end(_ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2) noexcept
 { 
    return ::std:: find_end(::std:: forward<_ExPo>(_Exec), _First1, _Last1, _First2, _Last2, equal_to{});
}
#line 2640 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


namespace ranges {
    class _Find_end_fn : private _Not_quite_object {
    private:
        template <class _It1, class _It2, class _Pr, class _Pj1, class _Pj2>
        [[nodiscard]] static constexpr subrange<_It1> _Random_access_sized_ranges(_It1 _First1,
            const iter_difference_t<_It1> _Count1, _It2 _First2, const iter_difference_t<_It2> _Count2, _Pr _Pred,
            _Pj1 _Proj1, _Pj2 _Proj2) {
            ;
            ;
            ;
            
            
            if (_Count2 > 0 && _Count2 <= _Count1) {
                const auto _Count2_as1 = static_cast<iter_difference_t<_It1>>(_Count2);

                for (auto _Candidate = _First1 + (_Count1 - _Count2_as1);; --_Candidate) {
                    auto [_Match, _Mid1] =
                        _Equal_rev_pred(_Candidate, _First2, _First2 + _Count2, _Pred, _Proj1, _Proj2);
                    if (_Match) {
                        return {::std:: move(_Candidate), ::std:: move(_Mid1)};
                    }

                    if (_Candidate == _First1) {
                        break;
                    }
                }
            }

            _First1 += _Count1;
            return {_First1, _First1};
        }

        template <class _It1, class _It2, class _Pr, class _Pj1, class _Pj2>
        [[nodiscard]] static constexpr subrange<_It1> _Bidi_common_ranges(
            _It1 _First1, _It1 _Last1, _It2 _First2, const _It2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
            ;
            ;
            ;

            for (auto _Candidate = _Last1;; --_Candidate) { 
                auto _Next1 = _Candidate;
                auto _Next2 = _Last2;
                for (;;) { 
                    if (_First2 == _Next2) { 
                        return {::std:: move(_Next1), ::std:: move(_Candidate)};
                    }

                    if (_First1 == _Next1) {
                        
                        return {_Last1, _Last1};
                    }

                    --_Next1;
                    --_Next2;
                    if (!::std:: invoke(_Pred, ::std:: invoke(_Proj1, *_Next1), ::std:: invoke(_Proj2, *_Next2))) {
                        break; 
                    }
                }
            }
        }

        template <class _It1, class _Se1, class _It2, class _Se2, class _Pr, class _Pj1, class _Pj2>
        [[nodiscard]] static constexpr subrange<_It1> _Forward_ranges(
            _It1 _First1, const _Se1 _Last1, _It2 _First2, const _Se2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
            ;
            ;
            ;
            ;
            ;

            subrange<_It1> _Match{};
            bool _Found = false;

            for (;; ++_First1) { 
                auto _Next1 = _First1;
                auto _Next2 = _First2;
                for (;; ++_Next1, (void) ++_Next2) { 
                    const bool _End_of_needle = _Next2 == _Last2;
                    if (_End_of_needle) { 
                        _Match = subrange{_First1, _Next1};
                        _Found = true;
                    }

                    if (_Next1 == _Last1) { 
                        if (!_Found) {
                            _Match = subrange{_Next1, _Next1};
                        }

                        return _Match;
                    }

                    if (_End_of_needle) {
                        break; 
                    }

                    if (!::std:: invoke(_Pred, ::std:: invoke(_Proj1, *_Next1), ::std:: invoke(_Proj2, *_Next2))) {
                        break; 
                    }
                }
            }
        }

    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <forward_iterator _It1, sentinel_for<_It1> _Se1, forward_iterator _It2, sentinel_for<_It2> _Se2,
            class _Pr = ranges::equal_to, class _Pj1 = identity, class _Pj2 = identity>
            requires indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
        [[nodiscard]] constexpr subrange<_It1> operator()(_It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2,
            _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            _Adl_verify_range(_First1, _Last1);
            _Adl_verify_range(_First2, _Last2);
            auto _UFirst1 = _Get_unwrapped(_First1);
            auto _ULast1  = _Get_unwrapped(_Last1);
            auto _UFirst2 = _Get_unwrapped(_First2);
            auto _ULast2  = _Get_unwrapped(_Last2);

            if constexpr (random_access_iterator<_It1> && sized_sentinel_for<_Se1, _It1>
                && random_access_iterator<_It2> && sized_sentinel_for<_Se2, _It2>) {
                const auto _Count1 = _ULast1 - _UFirst1;
                const auto _Count2 = _ULast2 - _UFirst2;
                auto _UResult = _Random_access_sized_ranges(::std:: move(_UFirst1), _Count1, ::std:: move(_UFirst2), _Count2,
                    _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
                return _Rewrap_subrange<subrange<_It1>>(_First1, ::std:: move(_UResult));
            } else if constexpr (_Bidi_common<_It1, _Se1> && _Bidi_common<_It2, _Se2>) {
                auto _UResult = _Bidi_common_ranges(::std:: move(_UFirst1), ::std:: move(_ULast1), ::std:: move(_UFirst2),
                    ::std:: move(_ULast2), _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
                return _Rewrap_subrange<subrange<_It1>>(_First1, ::std:: move(_UResult));
            } else {
                auto _UResult = _Forward_ranges(::std:: move(_UFirst1), ::std:: move(_ULast1), ::std:: move(_UFirst2),
                    ::std:: move(_ULast2), _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
                return _Rewrap_subrange<subrange<_It1>>(_First1, ::std:: move(_UResult));
            }
        }

        template <forward_range _Rng1, forward_range _Rng2, class _Pr = ranges::equal_to, class _Pj1 = identity,
            class _Pj2 = identity>
            requires indirectly_comparable<iterator_t<_Rng1>, iterator_t<_Rng2>, _Pr, _Pj1, _Pj2>
        [[nodiscard]] constexpr borrowed_subrange_t<_Rng1> operator()(
            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            if constexpr (random_access_range<_Rng1> && sized_range<_Rng1>
                && random_access_range<_Rng2> && sized_range<_Rng2>) {
                auto _UResult = _Random_access_sized_ranges(_Ubegin(_Range1), ::std::ranges:: distance(_Range1),
                    _Ubegin(_Range2), ::std::ranges:: distance(_Range2), _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
                return _Rewrap_subrange<borrowed_subrange_t<_Rng1>>(_Range1, ::std:: move(_UResult));
            } else if constexpr (_Bidi_common_range<_Rng1> && _Bidi_common_range<_Rng2>) {
                auto _UResult = _Bidi_common_ranges(_Ubegin(_Range1), _Uend(_Range1),
                    _Ubegin(_Range2), _Uend(_Range2), _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
                return _Rewrap_subrange<borrowed_subrange_t<_Rng1>>(_Range1, ::std:: move(_UResult));
            } else {
                auto _UResult = _Forward_ranges(_Ubegin(_Range1), _Uend(_Range1),
                    _Ubegin(_Range2), _Uend(_Range2), _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
                return _Rewrap_subrange<borrowed_subrange_t<_Rng1>>(_Range1, ::std:: move(_UResult));
            }
        }
        
    };

    inline constexpr _Find_end_fn find_end{_Not_quite_object::_Construct_tag{}};
} 
#line 2805 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _FwdIt1, class _FwdIt2, class _Pr>
[[nodiscard]] constexpr _FwdIt1 find_first_of(
    _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2, const _FwdIt2 _Last2, _Pr _Pred) {
    
    _Adl_verify_range(_First1, _Last1);
    _Adl_verify_range(_First2, _Last2);
    auto _UFirst1       = _Get_unwrapped(_First1);
    const auto _ULast1  = _Get_unwrapped(_Last1);
    const auto _UFirst2 = _Get_unwrapped(_First2);
    const auto _ULast2  = _Get_unwrapped(_Last2);
    for (; _UFirst1 != _ULast1; ++_UFirst1) {
        for (auto _UMid2 = _UFirst2; _UMid2 != _ULast2; ++_UMid2) {
            if (_Pred(*_UFirst1, *_UMid2)) {
                _Seek_wrapped(_First1, _UFirst1);
                return _First1;
            }
        }
    }

    _Seek_wrapped(_First1, _UFirst1);
    return _First1;
}

template <class _FwdIt1, class _FwdIt2>
[[nodiscard]] constexpr _FwdIt1 find_first_of(const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2,
    const _FwdIt2 _Last2) { 
    return ::std:: find_first_of(_First1, _Last1, _First2, _Last2, equal_to<>{});
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _FwdIt1 find_first_of(_ExPo&& _Exec, const _FwdIt1 _First1, _FwdIt1 _Last1, const _FwdIt2 _First2,
    const _FwdIt2 _Last2, _Pr _Pred) noexcept; 

template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _FwdIt1 find_first_of(_ExPo&& _Exec, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2,
    const _FwdIt2 _Last2) noexcept  { 
    return ::std:: find_first_of(::std:: forward<_ExPo>(_Exec), _First1, _Last1, _First2, _Last2, equal_to{});
}
#line 2846 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


namespace ranges {
    class _Find_first_of_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It1, sentinel_for<_It1> _Se1, forward_iterator _It2, sentinel_for<_It2> _Se2,
            class _Pr = ranges::equal_to, class _Pj1 = identity, class _Pj2 = identity>
            requires indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>
        [[nodiscard]] constexpr _It1 operator()(_It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2, _Pr _Pred = {},
            _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            _Adl_verify_range(_First1, _Last1);
            _Adl_verify_range(_First2, _Last2);

            auto _UResult = _Find_first_of_unchecked(_Get_unwrapped(::std:: move(_First1)),
                _Get_unwrapped(::std:: move(_Last1)), _Get_unwrapped(::std:: move(_First2)),
                _Get_unwrapped(::std:: move(_Last2)), _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));

            _Seek_wrapped(_First1, ::std:: move(_UResult));
            return _First1;
        }

        template <input_range _Rng1, forward_range _Rng2, class _Pr = ranges::equal_to, class _Pj1 = identity,
            class _Pj2 = identity>
            requires indirectly_comparable<iterator_t<_Rng1>, iterator_t<_Rng2>, _Pr, _Pj1, _Pj2>
        [[nodiscard]] constexpr borrowed_iterator_t<_Rng1> operator()(
            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            auto _First1 = ::std::ranges:: begin(_Range1);

            auto _UResult = _Find_first_of_unchecked(_Get_unwrapped(::std:: move(_First1)), _Uend(_Range1),
                _Ubegin(_Range2), _Uend(_Range2), _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));

            _Seek_wrapped(_First1, ::std:: move(_UResult));
            return _First1;
        }
        
    private:
        template <class _It1, class _Se1, class _It2, class _Se2, class _Pr, class _Pj1, class _Pj2>
        [[nodiscard]] static constexpr _It1 _Find_first_of_unchecked(_It1 _First1, const _Se1 _Last1, const _It2 _First2,
            const _Se2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
            ;
            ;
            ;
            ;
            ;

            for (; _First1 != _Last1; ++_First1) {
                for (auto _Mid2 = _First2; _Mid2 != _Last2; ++_Mid2) {
                    if (::std:: invoke(_Pred, ::std:: invoke(_Proj1, *_First1), ::std:: invoke(_Proj2, *_Mid2))) {
                        return _First1;
                    }
                }
            }

            return _First1;
        }
    };

    inline constexpr _Find_first_of_fn find_first_of{_Not_quite_object::_Construct_tag{}};

    template <class _In1, class _In2>
    using swap_ranges_result = in_in_result<_In1, _In2>;

    class _Swap_ranges_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2>
            requires indirectly_swappable<_It1, _It2>
        constexpr swap_ranges_result<_It1, _It2> operator()(
            _It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2) const {
            _Adl_verify_range(_First1, _Last1);
            _Adl_verify_range(_First2, _Last2);

            auto _UResult =
                _Swap_ranges_unchecked(_Get_unwrapped(::std:: move(_First1)), _Get_unwrapped(::std:: move(_Last1)),
                    _Get_unwrapped(::std:: move(_First2)), _Get_unwrapped(::std:: move(_Last2)));

            _Seek_wrapped(_First1, ::std:: move(_UResult.in1));
            _Seek_wrapped(_First2, ::std:: move(_UResult.in2));
            return {::std:: move(_First1), ::std:: move(_First2)};
        }

        template <input_range _Rng1, input_range _Rng2>
            requires indirectly_swappable<iterator_t<_Rng1>, iterator_t<_Rng2>>
        constexpr swap_ranges_result<borrowed_iterator_t<_Rng1>, borrowed_iterator_t<_Rng2>> operator()(
            _Rng1&& _Range1, _Rng2&& _Range2) const {
            auto _First1 = ::std::ranges:: begin(_Range1);
            auto _First2 = ::std::ranges:: begin(_Range2);

            auto _UResult = _Swap_ranges_unchecked(
                _Get_unwrapped(::std:: move(_First1)), _Uend(_Range1), _Get_unwrapped(::std:: move(_First2)), _Uend(_Range2));

            _Seek_wrapped(_First1, ::std:: move(_UResult.in1));
            _Seek_wrapped(_First2, ::std:: move(_UResult.in2));
            return {::std:: move(_First1), ::std:: move(_First2)};
        }
        
    private:
        template <class _It1, class _Se1, class _It2, class _Se2>
        [[nodiscard]] static constexpr swap_ranges_result<_It1, _It2> _Swap_ranges_unchecked(
            _It1 _First1, const _Se1 _Last1, _It2 _First2, const _Se2 _Last2) {
            ;
            ;
            ;
            ;
            ;


            using _Elem1 = remove_reference_t<iter_reference_t<_It1>>;
            using _Elem2 = remove_reference_t<iter_reference_t<_It2>>;
            if constexpr (same_as<_Elem1, _Elem2> && _Is_trivially_swappable_v<_Elem1> 
                          && contiguous_iterator<_It1> && _Sized_or_unreachable_sentinel_for<_Se1, _It1> 
                          && contiguous_iterator<_It2> && _Sized_or_unreachable_sentinel_for<_Se2, _It2>) {
                if (!::std:: is_constant_evaluated()) {
                    constexpr bool _Is_sized1 = sized_sentinel_for<_Se1, _It1>;
                    constexpr bool _Is_sized2 = sized_sentinel_for<_Se2, _It2>;
                    const auto _First1_addr   = ::std:: to_address(_First1);
                    const auto _First2_addr   = ::std:: to_address(_First2);
                    if constexpr (_Is_sized1 && _Is_sized2) {
                        const size_t _Count =
                            (::std:: min)(static_cast<size_t>(_Last1 - _First1), static_cast<size_t>(_Last2 - _First2));
                        const auto _Last1_addr = _First1_addr + _Count;
                        __std_swap_ranges_trivially_swappable_noalias(_First1_addr, _Last1_addr, _First2_addr);
                        return {_First1 + _Count, _First2 + _Count};
                    } else if constexpr (_Is_sized1) {
                        const auto _Final1     = ::std::ranges:: next(_First1, _Last1);
                        const auto _Last1_addr = ::std:: to_address(_Final1);
                        __std_swap_ranges_trivially_swappable_noalias(_First1_addr, _Last1_addr, _First2_addr);
                        return {_Final1, _First2 + (_Last1 - _First1)};
                    } else if constexpr (_Is_sized2) {
                        const auto _Final2     = ::std::ranges:: next(_First2, _Last2);
                        const auto _Last2_addr = ::std:: to_address(_Final2);
                        __std_swap_ranges_trivially_swappable_noalias(_First2_addr, _Last2_addr, _First1_addr);
                        return {_First1 + (_Last2 - _First2), _Final2};
                    } else {
                        ;
                    }
                }
            }
#line 2990 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

            for (; _First1 != _Last1 && _First2 != _Last2; ++_First1, (void) ++_First2) {
                ::std::ranges:: iter_swap(_First1, _First2);
            }

            return {::std:: move(_First1), ::std:: move(_First2)};
        }
    };

    inline constexpr _Swap_ranges_fn swap_ranges{_Not_quite_object::_Construct_tag{}};
} 
#line 3002 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _FwdIt1, class _FwdIt2>
constexpr _FwdIt2 swap_ranges(const _FwdIt1 _First1, const _FwdIt1 _Last1, _FwdIt2 _First2) {
    
    _Adl_verify_range(_First1, _Last1);
    const auto _UFirst1 = _Get_unwrapped(_First1);
    const auto _ULast1  = _Get_unwrapped(_Last1);
    const auto _UFirst2 = _Get_unwrapped_n(_First2, _Idl_distance<_FwdIt1>(_UFirst1, _ULast1));
    _Seek_wrapped(_First2, _Swap_ranges_unchecked(_UFirst1, _ULast1, _UFirst2));
    return _First2;
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt2 swap_ranges(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _Dest) noexcept  {
    
    
    return ::std:: swap_ranges(_First1, _Last1, _Dest);
}
#line 3022 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _InIt, class _OutIt, class _Fn>
constexpr _OutIt transform(const _InIt _First, const _InIt _Last, _OutIt _Dest, _Fn _Func) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    auto _UDest       = _Get_unwrapped_n(_Dest, _Idl_distance<_InIt>(_UFirst, _ULast));
    for (; _UFirst != _ULast; ++_UFirst, (void) ++_UDest) {
        *_UDest = _Func(*_UFirst);
    }

    _Seek_wrapped(_Dest, _UDest);
    return _Dest;
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Fn, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt2 transform(
    _ExPo&& _Exec, const _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _Fn _Func) noexcept; 
#line 3043 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _InIt1, class _InIt2, class _OutIt, class _Fn>
constexpr _OutIt transform(
    const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, _OutIt _Dest, _Fn _Func) {
    
    _Adl_verify_range(_First1, _Last1);
    auto _UFirst1      = _Get_unwrapped(_First1);
    const auto _ULast1 = _Get_unwrapped(_Last1);
    const auto _Count  = _Idl_distance<_InIt1>(_UFirst1, _ULast1);
    auto _UFirst2      = _Get_unwrapped_n(_First2, _Count);
    auto _UDest        = _Get_unwrapped_n(_Dest, _Count);
    for (; _UFirst1 != _ULast1; ++_UFirst1, (void) ++_UFirst2, ++_UDest) {
        *_UDest = _Func(*_UFirst1, *_UFirst2);
    }

    _Seek_wrapped(_Dest, _UDest);
    return _Dest;
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Fn, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt3 transform(_ExPo&& _Exec, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2, _FwdIt3 _Dest,
    _Fn _Func) noexcept; 
#line 3067 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


namespace ranges {
    template <class _In, class _Out>
    using unary_transform_result = in_out_result<_In, _Out>;

    template <class _In1, class _In2, class _Out>
    using binary_transform_result = in_in_out_result<_In1, _In2, _Out>;

    class _Transform_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out, copy_constructible _Fn,
            class _Pj = identity>
            requires indirectly_writable<_Out, indirect_result_t<_Fn&, projected<_It, _Pj>>>
        constexpr unary_transform_result<_It, _Out> operator()(
            _It _First, _Se _Last, _Out _Result, _Fn _Func, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            auto _UResult = _Transform_unary_unchecked(_Get_unwrapped(::std:: move(_First)),
                _Get_unwrapped(::std:: move(_Last)), ::std:: move(_Result), _Pass_fn(_Func), _Pass_fn(_Proj));

            _Seek_wrapped(_First, ::std:: move(_UResult.in));
            return {::std:: move(_First), ::std:: move(_UResult.out)};
        }

        template <input_range _Rng, weakly_incrementable _Out, copy_constructible _Fn, class _Pj = identity>
            requires indirectly_writable<_Out, indirect_result_t<_Fn&, projected<iterator_t<_Rng>, _Pj>>>
        constexpr unary_transform_result<borrowed_iterator_t<_Rng>, _Out> operator()(
            _Rng&& _Range, _Out _Result, _Fn _Func, _Pj _Proj = {}) const {
            auto _First   = ::std::ranges:: begin(_Range);
            auto _UResult = _Transform_unary_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Uend(_Range), ::std:: move(_Result), _Pass_fn(_Func), _Pass_fn(_Proj));

            _Seek_wrapped(_First, ::std:: move(_UResult.in));
            return {::std:: move(_First), ::std:: move(_UResult.out)};
        }

        template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2,
            weakly_incrementable _Out, copy_constructible _Fn, class _Pj1 = identity, class _Pj2 = identity>
            requires indirectly_writable<_Out, indirect_result_t<_Fn&, projected<_It1, _Pj1>, projected<_It2, _Pj2>>>
        constexpr binary_transform_result<_It1, _It2, _Out> operator()(_It1 _First1, _Se1 _Last1, _It2 _First2,
            _Se2 _Last2, _Out _Result, _Fn _Func, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            _Adl_verify_range(_First1, _Last1);
            _Adl_verify_range(_First2, _Last2);
            auto _UResult =
                _Transform_binary_unchecked(_Get_unwrapped(::std:: move(_First1)), _Get_unwrapped(::std:: move(_Last1)),
                    _Get_unwrapped(::std:: move(_First2)), _Get_unwrapped(::std:: move(_Last2)), ::std:: move(_Result),
                    _Pass_fn(_Func), _Pass_fn(_Proj1), _Pass_fn(_Proj2));

            _Seek_wrapped(_First1, ::std:: move(_UResult.in1));
            _Seek_wrapped(_First2, ::std:: move(_UResult.in2));
            return {::std:: move(_First1), ::std:: move(_First2), ::std:: move(_UResult.out)};
        }

        template <input_range _Rng1, input_range _Rng2, weakly_incrementable _Out, copy_constructible _Fn,
            class _Pj1 = identity, class _Pj2 = identity>
            requires indirectly_writable<_Out, indirect_result_t<_Fn&, projected<iterator_t<_Rng1>, _Pj1>,
                                                                       projected<iterator_t<_Rng2>, _Pj2>>>
        constexpr binary_transform_result<borrowed_iterator_t<_Rng1>, borrowed_iterator_t<_Rng2>, _Out> operator()(
            _Rng1&& _Range1, _Rng2&& _Range2, _Out _Result, _Fn _Func, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            auto _First1  = ::std::ranges:: begin(_Range1);
            auto _First2  = ::std::ranges:: begin(_Range2);
            auto _UResult = _Transform_binary_unchecked(_Get_unwrapped(::std:: move(_First1)), _Uend(_Range1),
                _Get_unwrapped(::std:: move(_First2)), _Uend(_Range2), ::std:: move(_Result), _Pass_fn(_Func),
                _Pass_fn(_Proj1), _Pass_fn(_Proj2));

            _Seek_wrapped(_First1, ::std:: move(_UResult.in1));
            _Seek_wrapped(_First2, ::std:: move(_UResult.in2));
            return {::std:: move(_First1), ::std:: move(_First2), ::std:: move(_UResult.out)};
        }
        

    private:
        template <class _It, class _Se, class _Out, class _Fn, class _Pj>
        [[nodiscard]] static constexpr unary_transform_result<_It, _Out> _Transform_unary_unchecked(
            _It _First, const _Se _Last, _Out _Result, _Fn _Func, _Pj _Proj) {
            
            ;
            ;
            ;

            for (; _First != _Last; ++_First, (void) ++_Result) {
                *_Result = ::std:: invoke(_Func, ::std:: invoke(_Proj, *_First));
            }

            return {::std:: move(_First), ::std:: move(_Result)};
        }

        template <class _It1, class _Se1, class _It2, class _Se2, class _Out, class _Fn, class _Pj1, class _Pj2>
        [[nodiscard]] static constexpr binary_transform_result<_It1, _It2, _Out> _Transform_binary_unchecked(_It1 _First1,
            const _Se1 _Last1, _It2 _First2, const _Se2 _Last2, _Out _Result, _Fn _Func, _Pj1 _Proj1, _Pj2 _Proj2) {
            
            ;
            ;
            ;
            ;
#line 3166 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

            for (; _First1 != _Last1 && _First2 != _Last2; ++_First1, (void) ++_First2, ++_Result) {
                *_Result = ::std:: invoke(_Func, ::std:: invoke(_Proj1, *_First1), ::std:: invoke(_Proj2, *_First2));
            }

            return {::std:: move(_First1), ::std:: move(_First2), ::std:: move(_Result)};
        }
    };

    inline constexpr _Transform_fn transform{_Not_quite_object::_Construct_tag{}};
} 
#line 3178 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _FwdIt, class _Ty>
constexpr void replace(const _FwdIt _First, const _FwdIt _Last, const _Ty& _Oldval, const _Ty& _Newval) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    for (; _UFirst != _ULast; ++_UFirst) {
        if (*_UFirst == _Oldval) {
            *_UFirst = _Newval;
        }
    }
}


template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
void replace(_ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last, const _Ty& _Oldval,
    const _Ty& _Newval) noexcept; 
#line 3197 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


namespace ranges {
    class _Replace_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It, sentinel_for<_It> _Se, class _Ty1, class _Ty2, class _Pj = identity>
            requires indirectly_writable<_It, const _Ty2&>
                  && indirect_binary_predicate<ranges::equal_to, projected<_It, _Pj>, const _Ty1*>
        constexpr _It operator()(
            _It _First, _Se _Last, const _Ty1& _Oldval, const _Ty2& _Newval, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            auto _UResult = _Replace_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)), _Oldval, _Newval, _Pass_fn(_Proj));

            _Seek_wrapped(_First, ::std:: move(_UResult));
            return _First;
        }

        template <input_range _Rng, class _Ty1, class _Ty2, class _Pj = identity>
            requires indirectly_writable<iterator_t<_Rng>, const _Ty2&>
                  && indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Rng>, _Pj>, const _Ty1*>
        constexpr borrowed_iterator_t<_Rng> operator()(
            _Rng&& _Range, const _Ty1& _Oldval, const _Ty2& _Newval, _Pj _Proj = {}) const {
            auto _First = ::std::ranges:: begin(_Range);
            auto _UResult = _Replace_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Uend(_Range), _Oldval, _Newval, _Pass_fn(_Proj));

            _Seek_wrapped(_First, ::std:: move(_UResult));
            return _First;
        }
        
    private:
        template <class _It, class _Se, class _Ty1, class _Ty2, class _Pj>
        [[nodiscard]] static constexpr _It _Replace_unchecked(
            _It _First, const _Se _Last, const _Ty1& _Oldval, const _Ty2& _Newval, _Pj _Proj) {
            
            ;
            ;
            ;
            ;

            for (; _First != _Last; ++_First) {
                if (::std:: invoke(_Proj, *_First) == _Oldval) {
                    *_First = _Newval;
                }
            }

            return _First;
        }
    };

    inline constexpr _Replace_fn replace{_Not_quite_object::_Construct_tag{}};
} 
#line 3254 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _FwdIt, class _Pr, class _Ty>
constexpr void replace_if(const _FwdIt _First, const _FwdIt _Last, _Pr _Pred, const _Ty& _Val) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    for (; _UFirst != _ULast; ++_UFirst) {
        if (_Pred(*_UFirst)) {
            *_UFirst = _Val;
        }
    }
}


template <class _ExPo, class _FwdIt, class _Pr, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
void replace_if(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, _Pr _Pred, const _Ty& _Val) noexcept; 
#line 3272 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


namespace ranges {
    class _Replace_if_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It, sentinel_for<_It> _Se, class _Ty, class _Pj = identity,
            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
            requires indirectly_writable<_It, const _Ty&>
        constexpr _It operator()(_It _First, _Se _Last, _Pr _Pred, const _Ty& _Newval, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            auto _UResult = _Replace_if_unchecked(_Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)),
                _Pass_fn(_Pred), _Newval, _Pass_fn(_Proj));

            _Seek_wrapped(_First, ::std:: move(_UResult));
            return _First;
        }

        template <input_range _Rng, class _Ty, class _Pj = identity,
            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
            requires indirectly_writable<iterator_t<_Rng>, const _Ty&>
        constexpr borrowed_iterator_t<_Rng> operator()(
            _Rng&& _Range, _Pr _Pred, const _Ty& _Newval, _Pj _Proj = {}) const {
            auto _First   = ::std::ranges:: begin(_Range);
            auto _UResult = _Replace_if_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Uend(_Range), _Pass_fn(_Pred), _Newval, _Pass_fn(_Proj));

            _Seek_wrapped(_First, ::std:: move(_UResult));
            return _First;
        }
        
    private:
        template <class _It, class _Se, class _Ty, class _Pj, class _Pr>
        [[nodiscard]] static constexpr _It _Replace_if_unchecked(
            _It _First, const _Se _Last, _Pr _Pred, const _Ty& _Newval, _Pj _Proj) {
            
            ;
            ;
            ;
            ;

            for (; _First != _Last; ++_First) {
                if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_First))) {
                    *_First = _Newval;
                }
            }

            return _First;
        }
    };

    inline constexpr _Replace_if_fn replace_if{_Not_quite_object::_Construct_tag{}};
} 
#line 3328 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _InIt, class _OutIt, class _Ty>
constexpr _OutIt replace_copy(_InIt _First, _InIt _Last, _OutIt _Dest, const _Ty& _Oldval, const _Ty& _Newval) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    auto _UDest       = _Get_unwrapped_n(_Dest, _Idl_distance<_InIt>(_UFirst, _ULast));
    for (; _UFirst != _ULast; ++_UFirst, (void) ++_UDest) {
        if (*_UFirst == _Oldval) {
            *_UDest = _Newval;
        } else {
            *_UDest = *_UFirst;
        }
    }

    _Seek_wrapped(_Dest, _UDest);
    return _Dest;
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt2 replace_copy(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, const _Ty& _Oldval,
    const _Ty& _Newval) noexcept  {
    
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: replace_copy(_First, _Last, _Dest, _Oldval, _Newval);
}
#line 3359 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


namespace ranges {
    template <class _In, class _Out>
    using replace_copy_result = in_out_result<_In, _Out>;

    class _Replace_copy_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It, sentinel_for<_It> _Se, class _Ty1, class _Ty2, output_iterator<const _Ty2&> _Out,
            class _Pj = identity>
            requires indirectly_copyable<_It, _Out>
                  && indirect_binary_predicate<ranges::equal_to, projected<_It, _Pj>, const _Ty1*>
        constexpr replace_copy_result<_It, _Out> operator()(
            _It _First, _Se _Last, _Out _Result, const _Ty1& _Oldval, const _Ty2& _Newval, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            auto _UResult = _Replace_copy_unchecked(_Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)),
                ::std:: move(_Result), _Oldval, _Newval, _Pass_fn(_Proj));

            _Seek_wrapped(_First, ::std:: move(_UResult.in));
            return {::std:: move(_First), ::std:: move(_UResult.out)};
        }

        template <input_range _Rng, class _Ty1, class _Ty2, output_iterator<const _Ty2&> _Out, class _Pj = identity>
            requires indirectly_copyable<iterator_t<_Rng>, _Out>
                  && indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Rng>, _Pj>, const _Ty1*>
        constexpr replace_copy_result<borrowed_iterator_t<_Rng>, _Out> operator()(
            _Rng&& _Range, _Out _Result, const _Ty1& _Oldval, const _Ty2& _Newval, _Pj _Proj = {}) const {
            auto _First   = ::std::ranges:: begin(_Range);
            auto _UResult = _Replace_copy_unchecked(_Get_unwrapped(::std:: move(_First)), _Uend(_Range),
                ::std:: move(_Result), _Oldval, _Newval, _Pass_fn(_Proj));

            _Seek_wrapped(_First, ::std:: move(_UResult.in));
            return {::std:: move(_First), ::std:: move(_UResult.out)};
        }
        
    private:
        template <class _It, class _Se, class _Ty1, class _Ty2, class _Out, class _Pj>
        [[nodiscard]] static constexpr replace_copy_result<_It, _Out> _Replace_copy_unchecked(
            _It _First, const _Se _Last, _Out _Result, const _Ty1& _Oldval, const _Ty2& _Newval, _Pj _Proj) {
            
            ;
            ;
            ;
            ;
            ;

            for (; _First != _Last; ++_First, (void) ++_Result) {
                if (::std:: invoke(_Proj, *_First) == _Oldval) {
                    *_Result = _Newval;
                } else {
                    *_Result = *_First;
                }
            }

            return {::std:: move(_First), ::std:: move(_Result)};
        }
    };

    inline constexpr _Replace_copy_fn replace_copy{_Not_quite_object::_Construct_tag{}};
} 
#line 3423 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _InIt, class _OutIt, class _Pr, class _Ty>
constexpr _OutIt replace_copy_if(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred, const _Ty& _Val) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    auto _UDest       = _Get_unwrapped_n(_Dest, _Idl_distance<_InIt>(_UFirst, _ULast));
    for (; _UFirst != _ULast; ++_UFirst, (void) ++_UDest) {
        if (_Pred(*_UFirst)) {
            *_UDest = _Val;
        } else {
            *_UDest = *_UFirst;
        }
    }

    _Seek_wrapped(_Dest, _UDest);
    return _Dest;
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt2 replace_copy_if(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _Pr _Pred, const _Ty& _Val) noexcept
 {
    
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: replace_copy_if(_First, _Last, _Dest, _Pass_fn(_Pred), _Val);
}
#line 3454 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


namespace ranges {
    template <class _In, class _Out>
    using replace_copy_if_result = in_out_result<_In, _Out>;

    class _Replace_copy_if_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It, sentinel_for<_It> _Se, class _Ty, output_iterator<const _Ty&> _Out,
            class _Pj = identity, indirect_unary_predicate<projected<_It, _Pj>> _Pr>
            requires indirectly_copyable<_It, _Out>
        constexpr replace_copy_if_result<_It, _Out> operator()(
            _It _First, _Se _Last, _Out _Result, _Pr _Pred, const _Ty& _Newval, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            auto _UResult = _Replace_copy_if_unchecked(_Get_unwrapped(::std:: move(_First)),
                _Get_unwrapped(::std:: move(_Last)), ::std:: move(_Result), _Pass_fn(_Pred), _Newval, _Pass_fn(_Proj));

            _Seek_wrapped(_First, ::std:: move(_UResult.in));
            return {::std:: move(_First), ::std:: move(_UResult.out)};
        }

        template <input_range _Rng, class _Ty, output_iterator<const _Ty&> _Out, class _Pj = identity,
            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
            requires indirectly_copyable<iterator_t<_Rng>, _Out>
        constexpr replace_copy_if_result<borrowed_iterator_t<_Rng>, _Out> operator()(
            _Rng&& _Range, _Out _Result, _Pr _Pred, const _Ty& _Newval, _Pj _Proj = {}) const {
            auto _First   = ::std::ranges:: begin(_Range);
            auto _UResult = _Replace_copy_if_unchecked(_Get_unwrapped(::std:: move(_First)), _Uend(_Range),
                ::std:: move(_Result), _Pass_fn(_Pred), _Newval, _Pass_fn(_Proj));

            _Seek_wrapped(_First, ::std:: move(_UResult.in));
            return {::std:: move(_First), ::std:: move(_UResult.out)};
        }
        
    private:
        template <class _It, class _Se, class _Ty, class _Out, class _Pj, class _Pr>
        [[nodiscard]] static constexpr replace_copy_if_result<_It, _Out> _Replace_copy_if_unchecked(
            _It _First, const _Se _Last, _Out _Result, _Pr _Pred, const _Ty& _Newval, _Pj _Proj) {
            
            ;
            ;
            ;
            ;
            ;

            for (; _First != _Last; ++_First, (void) ++_Result) {
                if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_First))) {
                    *_Result = _Newval;
                } else {
                    *_Result = *_First;
                }
            }

            return {::std:: move(_First), ::std:: move(_Result)};
        }
    };

    inline constexpr _Replace_copy_if_fn replace_copy_if{_Not_quite_object::_Construct_tag{}};

    class _Fill_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <class _Ty, output_iterator<const _Ty&> _It, sentinel_for<_It> _Se>
        constexpr _It operator()(_It _First, _Se _Last, const _Ty& _Value) const {
            _Adl_verify_range(_First, _Last);
            auto _UFirst      = _Get_unwrapped(::std:: move(_First));
            const auto _ULast = _Get_unwrapped(::std:: move(_Last));
            if (!::std:: is_constant_evaluated()) {
                if constexpr (sized_sentinel_for<decltype(_ULast), decltype(_UFirst)>) {
                    if constexpr (_Fill_memset_is_safe<decltype(_UFirst), _Ty>) {
                        const auto _Distance = static_cast<size_t>(_ULast - _UFirst);
                        _Fill_memset(_UFirst, _Value, _Distance);
                        _Seek_wrapped(_First, _UFirst + _Distance);
                        return _First;
                    } else if constexpr (_Fill_zero_memset_is_safe<decltype(_UFirst), _Ty>) {
                        if (_Is_all_bits_zero(_Value)) {
                            const auto _Distance = static_cast<size_t>(_ULast - _UFirst);
                            _Fill_zero_memset(_UFirst, _Distance);
                            _Seek_wrapped(_First, _UFirst + _Distance);
                            return _First;
                        }
                    }
                }
            }

            for (; _UFirst != _ULast; ++_UFirst) {
                *_UFirst = _Value;
            }

            _Seek_wrapped(_First, ::std:: move(_UFirst));
            return _First;
        }

        template <class _Ty, output_range<const _Ty&> _Rng>
        constexpr borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, const _Ty& _Value) const {
            auto _First = ::std::ranges:: begin(_Range);
            _Seek_wrapped(_First, (*this)(_Get_unwrapped(::std:: move(_First)), _Uend(_Range), _Value));
            return _First;
        }
    };

    inline constexpr _Fill_fn fill{_Not_quite_object::_Construct_tag{}};

    class _Generate_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_or_output_iterator _Out, sentinel_for<_Out> _Se, copy_constructible _Fn>
            requires invocable<_Fn&> && indirectly_writable<_Out, invoke_result_t<_Fn&>>
        constexpr _Out operator()(_Out _First, _Se _Last, _Fn _Gen) const {
            _Adl_verify_range(_First, _Last);
            _Seek_wrapped(_First, _Generate_unchecked(_Get_unwrapped(::std:: move(_First)),
                                      _Get_unwrapped(::std:: move(_Last)), _Pass_fn(_Gen)));
            return _First;
        }

        template <class _Rng, copy_constructible _Fn>
            requires invocable<_Fn&> && output_range<_Rng, invoke_result_t<_Fn&>>
        constexpr borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, _Fn _Gen) const {
            auto _First = ::std::ranges:: begin(_Range);
            _Seek_wrapped(
                _First, _Generate_unchecked(_Get_unwrapped(::std:: move(_First)), _Uend(_Range), _Pass_fn(_Gen)));
            return _First;
        }
        
    private:
        template <class _Out, class _Se, class _Fn>
        [[nodiscard]] static constexpr _Out _Generate_unchecked(_Out _First, const _Se _Last, _Fn _Gen) {
            ;
            ;
            ;
            ;
            ;

            for (; _First != _Last; ++_First) {
                *_First = _Gen();
            }

            return _First;
        }
    };

    inline constexpr _Generate_fn generate{_Not_quite_object::_Construct_tag{}};

    class _Generate_n_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_or_output_iterator _Out, copy_constructible _Fn>
            requires invocable<_Fn&> && indirectly_writable<_Out, invoke_result_t<_Fn&>>
        constexpr _Out operator()(_Out _First, iter_difference_t<_Out> _Count, _Fn _Gen) const {
            if (_Count > 0) {
                auto _UFirst = _Get_unwrapped_n(::std:: move(_First), _Count);
                do {
                    *_UFirst = _Gen();
                    ++_UFirst;
                } while (--_Count > 0);

                _Seek_wrapped(_First, ::std:: move(_UFirst));
            }

            return _First;
        }
    };

    inline constexpr _Generate_n_fn generate_n{_Not_quite_object::_Construct_tag{}};
} 
#line 3628 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _FwdIt, class _Fn>
constexpr void generate(_FwdIt _First, _FwdIt _Last, _Fn _Func) { 
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    for (; _UFirst != _ULast; ++_UFirst) {
        *_UFirst = _Func();
    }
}


template <class _ExPo, class _FwdIt, class _Fn, _Enable_if_execution_policy_t<_ExPo> = 0>
void generate(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Fn _Func) noexcept  {
    
    
    return ::std:: generate(_First, _Last, _Pass_fn(_Func));
}
#line 3647 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _OutIt, class _Diff, class _Fn>
constexpr _OutIt generate_n(_OutIt _Dest, const _Diff _Count_raw, _Fn _Func) {
    
    _Algorithm_int_t<_Diff> _Count = _Count_raw;
    if (0 < _Count) {
        auto _UDest = _Get_unwrapped_n(_Dest, _Count);
        do {
            *_UDest = _Func();
            --_Count;
            ++_UDest;
        } while (0 < _Count);

        _Seek_wrapped(_Dest, _UDest);
    }

    return _Dest;
}


template <class _ExPo, class _FwdIt, class _Diff, class _Fn, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt generate_n(_ExPo&&, const _FwdIt _Dest, const _Diff _Count_raw, _Fn _Func) noexcept  {
    
    
    static_assert(_Is_fwd_iter_v<_FwdIt>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: generate_n(_Dest, _Count_raw, _Pass_fn(_Func));
}
#line 3675 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _InIt, class _OutIt, class _Ty>
constexpr _OutIt remove_copy(_InIt _First, _InIt _Last, _OutIt _Dest, const _Ty& _Val) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    auto _UDest       = _Get_unwrapped_unverified(_Dest);
    for (; _UFirst != _ULast; ++_UFirst) {
        if (!(*_UFirst == _Val)) {
            *_UDest = *_UFirst;
            ++_UDest;
        }
    }

    _Seek_wrapped(_Dest, _UDest);
    return _Dest;
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt2 remove_copy(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, const _Ty& _Val) noexcept  {
    
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: remove_copy(_First, _Last, _Dest, _Val);
}
#line 3704 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _InIt, class _OutIt, class _Pr>
constexpr _OutIt remove_copy_if(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    auto _UDest       = _Get_unwrapped_unverified(_Dest);
    for (; _UFirst != _ULast; ++_UFirst) {
        if (!_Pred(*_UFirst)) {
            *_UDest = *_UFirst;
            ++_UDest;
        }
    }

    _Seek_wrapped(_Dest, _UDest);
    return _Dest;
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt2 remove_copy_if(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _Pr _Pred) noexcept  {
    
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: remove_copy_if(_First, _Last, _Dest, _Pass_fn(_Pred));
}
#line 3733 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _FwdIt remove(
    _ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last, const _Ty& _Val) noexcept; 

template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _FwdIt remove_if(_ExPo&& _Exec, _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept; 
#line 3742 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


namespace ranges {
    class _Remove_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <permutable _It, sentinel_for<_It> _Se, class _Ty, class _Pj = identity>
            requires indirect_binary_predicate<ranges::equal_to, projected<_It, _Pj>, const _Ty*>
        [[nodiscard]] constexpr subrange<_It> operator()(_It _First, _Se _Last, const _Ty& _Val, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            auto _UResult = _Remove_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)), _Val, _Pass_fn(_Proj));

            return _Rewrap_subrange<subrange<_It>>(_First, ::std:: move(_UResult));
        }

        template <forward_range _Rng, class _Ty, class _Pj = identity>
            requires permutable<iterator_t<_Rng>>
                  && indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Rng>, _Pj>, const _Ty*>
        [[nodiscard]] constexpr borrowed_subrange_t<_Rng> operator()(
            _Rng&& _Range, const _Ty& _Val, _Pj _Proj = {}) const {
            auto _UResult = _Remove_unchecked(_Ubegin(_Range), _Uend(_Range), _Val, _Pass_fn(_Proj));

            return _Rewrap_subrange<borrowed_subrange_t<_Rng>>(_Range, ::std:: move(_UResult));
        }
        
    private:
        template <class _It, class _Se, class _Ty, class _Pj>
        [[nodiscard]] static constexpr subrange<_It> _Remove_unchecked(
            _It _First, const _Se _Last, const _Ty& _Val, _Pj _Proj) {
            
            ;
            ;
            ;

            _First     = ::std::ranges:: _Find_unchecked(::std:: move(_First), _Last, _Val, _Proj);
            auto _Next = _First;
            if (_First == _Last) {
                return {::std:: move(_Next), ::std:: move(_First)};
            }

            while (++_First != _Last) {
                if (::std:: invoke(_Proj, *_First) != _Val) {
                    *_Next = ::std::ranges:: iter_move(_First);
                    ++_Next;
                }
            }

            return {::std:: move(_Next), ::std:: move(_First)};
        }
    };

    inline constexpr _Remove_fn remove{_Not_quite_object::_Construct_tag{}};

    class _Remove_if_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <permutable _It, sentinel_for<_It> _Se, class _Pj = identity,
            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
        [[nodiscard]] constexpr subrange<_It> operator()(_It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            auto _UResult = _Remove_if_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)), _Pass_fn(_Pred), _Pass_fn(_Proj));

            return _Rewrap_subrange<subrange<_It>>(_First, ::std:: move(_UResult));
        }

        
        template <forward_range _Rng, class _Pj = identity,
            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
            requires permutable<iterator_t<_Rng>>
        [[nodiscard]] constexpr borrowed_subrange_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) const {
            auto _UResult = _Remove_if_unchecked(_Ubegin(_Range), _Uend(_Range), _Pass_fn(_Pred), _Pass_fn(_Proj));

            return _Rewrap_subrange<borrowed_subrange_t<_Rng>>(_Range, ::std:: move(_UResult));
        }
        
    private:
        template <class _It, class _Se, class _Pr, class _Pj>
        [[nodiscard]] static constexpr subrange<_It> _Remove_if_unchecked(
            _It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
            
            ;
            ;
            ;

            _First     = ::std::ranges:: _Find_if_unchecked(::std:: move(_First), _Last, _Pred, _Proj);
            auto _Next = _First;
            if (_First == _Last) {
                return {::std:: move(_Next), ::std:: move(_First)};
            }

            while (++_First != _Last) {
                if (!::std:: invoke(_Pred, ::std:: invoke(_Proj, *_First))) {
                    *_Next = ::std::ranges:: iter_move(_First);
                    ++_Next;
                }
            }

            return {::std:: move(_Next), ::std:: move(_First)};
        }
    };

    inline constexpr _Remove_if_fn remove_if{_Not_quite_object::_Construct_tag{}};

    template <class _In, class _Out>
    using remove_copy_result = in_out_result<_In, _Out>;

    class _Remove_copy_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out, class _Ty, class _Pj = identity>
            requires indirectly_copyable<_It, _Out>
                  && indirect_binary_predicate<ranges::equal_to, projected<_It, _Pj>, const _Ty*>
        constexpr remove_copy_result<_It, _Out> operator()(
            _It _First, _Se _Last, _Out _Result, const _Ty& _Val, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            auto _UResult = _Remove_copy_unchecked(_Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)),
                _Get_unwrapped_unverified(::std:: move(_Result)), _Val, _Pass_fn(_Proj));

            _Seek_wrapped(_First, ::std:: move(_UResult.in));
            _Seek_wrapped(_Result, ::std:: move(_UResult.out));
            return {::std:: move(_First), ::std:: move(_Result)};
        }

        template <input_range _Rng, weakly_incrementable _Out, class _Ty, class _Pj = identity>
            requires indirectly_copyable<iterator_t<_Rng>, _Out>
                  && indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Rng>, _Pj>, const _Ty*>
        constexpr remove_copy_result<borrowed_iterator_t<_Rng>, _Out> operator()(
            _Rng&& _Range, _Out _Result, const _Ty& _Val, _Pj _Proj = {}) const {
            auto _First   = ::std::ranges:: begin(_Range);
            auto _UResult = _Remove_copy_unchecked(_Get_unwrapped(::std:: move(_First)), _Uend(_Range),
                _Get_unwrapped_unverified(::std:: move(_Result)), _Val, _Pass_fn(_Proj));

            _Seek_wrapped(_First, ::std:: move(_UResult.in));
            _Seek_wrapped(_Result, ::std:: move(_UResult.out));
            return {::std:: move(_First), ::std:: move(_Result)};
        }
        
    private:
        template <class _It, class _Se, class _Out, class _Ty, class _Pj>
        [[nodiscard]] static constexpr remove_copy_result<_It, _Out> _Remove_copy_unchecked(
            _It _First, const _Se _Last, _Out _Result, const _Ty& _Val, _Pj _Proj) {
            
            ;
            ;
            ;
            ;
            ;

            for (; _First != _Last; ++_First) {
                if (::std:: invoke(_Proj, *_First) != _Val) {
                    *_Result = *_First;
                    ++_Result;
                }
            }

            return {::std:: move(_First), ::std:: move(_Result)};
        }
    };

    inline constexpr _Remove_copy_fn remove_copy{_Not_quite_object::_Construct_tag{}};

    template <class _In, class _Out>
    using remove_copy_if_result = in_out_result<_In, _Out>;

    class _Remove_copy_if_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out, class _Pj = identity,
            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
            requires indirectly_copyable<_It, _Out>
        constexpr remove_copy_if_result<_It, _Out> operator()(
            _It _First, _Se _Last, _Out _Result, _Pr _Pred, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            auto _UResult =
                _Remove_copy_if_unchecked(_Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)),
                    _Get_unwrapped_unverified(::std:: move(_Result)), _Pass_fn(_Pred), _Pass_fn(_Proj));

            _Seek_wrapped(_First, ::std:: move(_UResult.in));
            _Seek_wrapped(_Result, ::std:: move(_UResult.out));
            return {::std:: move(_First), ::std:: move(_Result)};
        }

        template <input_range _Rng, weakly_incrementable _Out, class _Pj = identity,
            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
            requires indirectly_copyable<iterator_t<_Rng>, _Out>
        constexpr remove_copy_if_result<borrowed_iterator_t<_Rng>, _Out> operator()(
            _Rng&& _Range, _Out _Result, _Pr _Pred, _Pj _Proj = {}) const {
            auto _First   = ::std::ranges:: begin(_Range);
            auto _UResult = _Remove_copy_if_unchecked(_Get_unwrapped(::std:: move(_First)), _Uend(_Range),
                _Get_unwrapped_unverified(::std:: move(_Result)), _Pass_fn(_Pred), _Pass_fn(_Proj));

            _Seek_wrapped(_First, ::std:: move(_UResult.in));
            _Seek_wrapped(_Result, ::std:: move(_UResult.out));
            return {::std:: move(_First), ::std:: move(_Result)};
        }
        
    private:
        template <class _It, class _Se, class _Out, class _Pr, class _Pj>
        [[nodiscard]] static constexpr remove_copy_if_result<_It, _Out> _Remove_copy_if_unchecked(
            _It _First, const _Se _Last, _Out _Result, _Pr _Pred, _Pj _Proj) {
            
            ;
            ;
            ;
            ;
            ;

            for (; _First != _Last; ++_First) {
                if (!::std:: invoke(_Pred, ::std:: invoke(_Proj, *_First))) {
                    *_Result = *_First;
                    ++_Result;
                }
            }

            return {::std:: move(_First), ::std:: move(_Result)};
        }
    };

    inline constexpr _Remove_copy_if_fn remove_copy_if{_Not_quite_object::_Construct_tag{}};
} 
#line 3972 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _FwdIt, class _Pr>
[[nodiscard]] constexpr _FwdIt unique(_FwdIt _First, _FwdIt _Last, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    if (_UFirst != _ULast) {
        for (auto _UFirstb = _UFirst; ++_UFirst != _ULast; _UFirstb = _UFirst) {
            if (_Pred(*_UFirstb, *_UFirst)) { 
                while (++_UFirst != _ULast) {
                    if (!_Pred(*_UFirstb, *_UFirst)) {
                        *++_UFirstb = ::std:: move(*_UFirst);
                    }
                }

                _Seek_wrapped(_Last, ++_UFirstb);
                return _Last;
            }
        }
    }

    _Seek_wrapped(_Last, _ULast);
    return _Last;
}

template <class _FwdIt>
[[nodiscard]] constexpr _FwdIt unique(_FwdIt _First, _FwdIt _Last) { 
    return ::std:: unique(_First, _Last, equal_to<>{});
}


template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _FwdIt unique(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept  {
    
    
    return ::std:: unique(_First, _Last, _Pass_fn(_Pred));
}

template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _FwdIt unique(_ExPo&&, _FwdIt _First, _FwdIt _Last) noexcept  {
    
    
    return ::std:: unique(_First, _Last);
}
#line 4018 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


namespace ranges {
    class _Unique_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <permutable _It, sentinel_for<_It> _Se, class _Pj = identity,
            indirect_equivalence_relation<projected<_It, _Pj>> _Pr = ranges::equal_to>
        [[nodiscard]] constexpr subrange<_It> operator()(_It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            auto _UResult = _Unique_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)), _Pass_fn(_Pred), _Pass_fn(_Proj));

            return _Rewrap_subrange<subrange<_It>>(_First, ::std:: move(_UResult));
        }

        
        template <forward_range _Rng, class _Pj = identity,
            indirect_equivalence_relation<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::equal_to>
            requires permutable<iterator_t<_Rng>>
        [[nodiscard]] constexpr borrowed_subrange_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) const {
            auto _UResult = _Unique_unchecked(_Ubegin(_Range), _Uend(_Range), _Pass_fn(_Pred), _Pass_fn(_Proj));

            return _Rewrap_subrange<borrowed_subrange_t<_Rng>>(_Range, ::std:: move(_UResult));
        }
        
    private:
        template <class _It, class _Se, class _Pj, class _Pr>
        [[nodiscard]] static constexpr subrange<_It> _Unique_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
            
            ;
            ;
            ;

            auto _Current = _First;
            if (_First == _Last) {
                return {::std:: move(_Current), ::std:: move(_First)};
            }

            for (;; ++_Current) {
                if (++_First == _Last) {
                    ++_Current;
                    return {::std:: move(_Current), ::std:: move(_First)};
                }

                if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Current), ::std:: invoke(_Proj, *_First))) {
                    break;
                }
            }

            while (++_First != _Last) {
                if (!::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Current), ::std:: invoke(_Proj, *_First))) {
                    ++_Current;
                    *_Current = ::std::ranges:: iter_move(_First);
                }
            }
            ++_Current;

            return {::std:: move(_Current), ::std:: move(_First)};
        }
    };

    inline constexpr _Unique_fn unique{_Not_quite_object::_Construct_tag{}};
} 
#line 4084 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


template <class _InIt, class _OutIt>
concept _Can_reread_dest = forward_iterator<_OutIt> && same_as<iter_value_t<_InIt>, iter_value_t<_OutIt>>;


#line 4093 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _InIt, class _OutIt, class _Pr>
constexpr _OutIt unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Last);

    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);

    if (_UFirst == _ULast) {
        return _Dest;
    }

    auto _UDest = _Get_unwrapped_unverified(_Dest);

    if constexpr (_Is_fwd_iter_v<_InIt>) { 
        auto _Firstb = _UFirst;

        *_UDest = *_Firstb;
        ++_UDest;

        while (++_UFirst != _ULast) {
            if (!static_cast<bool>(_Pred(*_Firstb, *_UFirst))) { 
                _Firstb = _UFirst;
                *_UDest = *_Firstb;
                ++_UDest;
            }
        }
    } else if constexpr (_Can_reread_dest<_InIt, _OutIt>) { 
        *_UDest = *_UFirst;

        while (++_UFirst != _ULast) {
            if (!static_cast<bool>(_Pred(*_UDest, *_UFirst))) {
                *++_UDest = *_UFirst;
            }
        }

        ++_UDest;
    } else { 
        _Iter_value_t<_InIt> _Val = *_UFirst;

        *_UDest = _Val;
        ++_UDest;

        while (++_UFirst != _ULast) {
            if (!static_cast<bool>(_Pred(_Val, *_UFirst))) { 
                _Val    = *_UFirst;
                *_UDest = _Val;
                ++_UDest;
            }
        }
    }

    _Seek_wrapped(_Dest, _UDest);
    return _Dest;
}

template <class _InIt, class _OutIt>
constexpr _OutIt unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest) { 
    return ::std:: unique_copy(_First, _Last, _Dest, equal_to<>{});
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt2 unique_copy(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _Pr _Pred) noexcept  {
    
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: unique_copy(_First, _Last, _Dest, _Pass_fn(_Pred));
}

template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt2 unique_copy(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest) noexcept  {
    
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: unique_copy(_First, _Last, _Dest);
}
#line 4174 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


namespace ranges {
    template <class _In, class _Out>
    using unique_copy_result = in_out_result<_In, _Out>;

    template <class _It, class _Ty>
    concept _Is_input_with_value_type = input_iterator<_It> && same_as<iter_value_t<_It>, _Ty>;

    template <class _It, class _Out>
    concept _Can_reread_or_store = forward_iterator<_It> 
        || _Is_input_with_value_type<_Out, iter_value_t<_It>> 
        || indirectly_copyable_storable<_It, _Out>;

    class _Unique_copy_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out, class _Pj = identity,
            indirect_equivalence_relation<projected<_It, _Pj>> _Pr = ranges::equal_to>
            requires indirectly_copyable<_It, _Out> && _Can_reread_or_store<_It, _Out>
        constexpr unique_copy_result<_It, _Out> operator()(
            _It _First, _Se _Last, _Out _Result, _Pr _Pred = {}, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            auto _UResult = _Unique_copy_unchecked(_Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)),
                _Get_unwrapped_unverified(::std:: move(_Result)), _Pass_fn(_Pred), _Pass_fn(_Proj));

            _Seek_wrapped(_First, ::std:: move(_UResult.in));
            _Seek_wrapped(_Result, ::std:: move(_UResult.out));
            return {::std:: move(_First), ::std:: move(_Result)};
        }

        template <input_range _Rng, weakly_incrementable _Out, class _Pj = identity,
            indirect_equivalence_relation<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::equal_to>
            requires indirectly_copyable<iterator_t<_Rng>, _Out> && _Can_reread_or_store<iterator_t<_Rng>, _Out>
        constexpr unique_copy_result<borrowed_iterator_t<_Rng>, _Out> operator()(
            _Rng&& _Range, _Out _Result, _Pr _Pred = {}, _Pj _Proj = {}) const {
            auto _First   = ::std::ranges:: begin(_Range);
            auto _UResult = _Unique_copy_unchecked(_Get_unwrapped(::std:: move(_First)), _Uend(_Range),
                _Get_unwrapped_unverified(::std:: move(_Result)), _Pass_fn(_Pred), _Pass_fn(_Proj));

            _Seek_wrapped(_First, ::std:: move(_UResult.in));
            _Seek_wrapped(_Result, ::std:: move(_UResult.out));
            return {::std:: move(_First), ::std:: move(_Result)};
        }
        
    private:
        template <class _It, class _Se, class _Out, class _Pj, class _Pr>
        [[nodiscard]] static constexpr unique_copy_result<_It, _Out> _Unique_copy_unchecked(
            _It _First, const _Se _Last, _Out _Result, _Pr _Pred, _Pj _Proj) {
            
            
            ;
            ;
            ;
            ;
            ;
            ;

            if (_First == _Last) {
                return {::std:: move(_First), ::std:: move(_Result)};
            }

            if constexpr (_Is_input_with_value_type<_Out, iter_value_t<_It>>) {
                
                *_Result = *_First;

                while (++_First != _Last) {
                    if (!::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Result), ::std:: invoke(_Proj, *_First))) {
                        ++_Result;
                        *_Result = *_First;
                    }
                }
            } else if constexpr (forward_iterator<_It>) {
                
                auto _Current = _First;
                *_Result      = *_First;

                while (++_First != _Last) {
                    if (!::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Current), ::std:: invoke(_Proj, *_First))) {
                        _Current = _First;
                        ++_Result;
                        *_Result = *_First;
                    }
                }
            } else {
                
                iter_value_t<_It> _Val = *_First;

                while (++_First != _Last) {
                    if (!::std:: invoke(_Pred, ::std:: invoke(_Proj, _Val), ::std:: invoke(_Proj, *_First))) {
                        *_Result = ::std:: move(_Val);
                        ++_Result;
                        _Val = *_First;
                    }
                }
                *_Result = ::std:: move(_Val);
            }
            ++_Result;

            return {::std:: move(_First), ::std:: move(_Result)};
        }
    };

    inline constexpr _Unique_copy_fn unique_copy{_Not_quite_object::_Construct_tag{}};

    
    template <bidirectional_iterator _It>
        requires permutable<_It>
    constexpr void _Reverse_common(_It _First, _It _Last) {

        if constexpr (contiguous_iterator<_It>) {
            using _Elem          = remove_reference_t<iter_reference_t<_It>>;
            constexpr size_t _Nx = sizeof(_Elem);
            constexpr bool _Allow_vectorization =
                conjunction_v<_Is_trivially_swappable<_Elem>, negation<is_volatile<_Elem>>>;

#pragma warning(suppress : 6326) 
            if constexpr (_Allow_vectorization && _Nx <= 8 && (_Nx & (_Nx - 1)) == 0) {
                if (!::std:: is_constant_evaluated()) {
                    _Elem* const _First_addr = ::std:: to_address(_First);
                    _Elem* const _Last_addr  = ::std:: to_address(_Last);
                    if constexpr (_Nx == 1) {
                        __std_reverse_trivially_swappable_1(_First_addr, _Last_addr);
                    } else if constexpr (_Nx == 2) {
                        __std_reverse_trivially_swappable_2(_First_addr, _Last_addr);
                    } else if constexpr (_Nx == 4) {
                        __std_reverse_trivially_swappable_4(_First_addr, _Last_addr);
                    } else {
                        __std_reverse_trivially_swappable_8(_First_addr, _Last_addr);
                    }

                    return;
                }
            }
        }
#line 4313 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

        for (; _First != _Last && _First != --_Last; ++_First) {
            ::std::ranges:: iter_swap(_First, _Last);
        }
    }
    

    class _Reverse_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <bidirectional_iterator _It, sentinel_for<_It> _Se>
            requires permutable<_It>
        constexpr _It operator()(_It _First, _Se _Last) const {
            _Adl_verify_range(_First, _Last);
            auto _UFirst = _Get_unwrapped(::std:: move(_First));
            auto _ULast  = _Get_final_iterator_unwrapped<_It>(_UFirst, ::std:: move(_Last));
            _Seek_wrapped(_First, _ULast);
            _Reverse_common(::std:: move(_UFirst), ::std:: move(_ULast));
            return _First;
        }

        template <bidirectional_range _Rng>
            requires permutable<iterator_t<_Rng>>
        constexpr borrowed_iterator_t<_Rng> operator()(_Rng&& _Range) const {
            auto _ULast = _Get_final_iterator_unwrapped(_Range);
            _Reverse_common(_Ubegin(_Range), _ULast);
            return _Rewrap_iterator(_Range, ::std:: move(_ULast));
        }
        
    };

    inline constexpr _Reverse_fn reverse{_Not_quite_object::_Construct_tag{}};
} 
#line 4349 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _BidIt, class _OutIt>
constexpr _OutIt reverse_copy(_BidIt _First, _BidIt _Last, _OutIt _Dest) {
    
    _Adl_verify_range(_First, _Last);
    const auto _UFirst = _Get_unwrapped(_First);
    auto _ULast        = _Get_unwrapped(_Last);
    auto _UDest        = _Get_unwrapped_n(_Dest, _Idl_distance<_BidIt>(_UFirst, _ULast));


    using _Elem                         = remove_reference_t<_Iter_ref_t<remove_const_t<decltype(_UFirst)>>>;
    using _DestElem                     = remove_reference_t<_Iter_ref_t<decltype(_UDest)>>;
    constexpr bool _Allow_vectorization = conjunction_v<is_same<remove_const_t<_Elem>, _DestElem>,
        bool_constant<_Iterators_are_contiguous<decltype(_ULast), decltype(_UDest)>>, is_trivially_copyable<_Elem>,
        negation<is_volatile<_Elem>>>;
    constexpr size_t _Nx                = sizeof(_Elem);

#pragma warning(suppress : 6326) 
    if constexpr (_Allow_vectorization && _Nx <= 8 && (_Nx & (_Nx - 1)) == 0) {

        if (!::std:: is_constant_evaluated())
#line 4371 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
        {
            if constexpr (_Nx == 1) {
                __std_reverse_copy_trivially_copyable_1(_To_address(_UFirst), _To_address(_ULast), _To_address(_UDest));
            } else if constexpr (_Nx == 2) {
                __std_reverse_copy_trivially_copyable_2(_To_address(_UFirst), _To_address(_ULast), _To_address(_UDest));
            } else if constexpr (_Nx == 4) {
                __std_reverse_copy_trivially_copyable_4(_To_address(_UFirst), _To_address(_ULast), _To_address(_UDest));
            } else {
                __std_reverse_copy_trivially_copyable_8(_To_address(_UFirst), _To_address(_ULast), _To_address(_UDest));
            }

            _UDest += _ULast - _UFirst;
            _Seek_wrapped(_Dest, _UDest);
            return _Dest;
        }
    }
#line 4388 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

    for (; _UFirst != _ULast; ++_UDest) {
        *_UDest = *--_ULast;
    }

    _Seek_wrapped(_Dest, _UDest);
    return _Dest;
}


template <class _ExPo, class _BidIt, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt reverse_copy(_ExPo&&, _BidIt _First, _BidIt _Last, _FwdIt _Dest) noexcept  {
    
    
    static_assert(_Is_fwd_iter_v<_FwdIt>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: reverse_copy(_First, _Last, _Dest);
}


namespace ranges {
    template <class _In, class _Out>
    using reverse_copy_result = in_out_result<_In, _Out>;

    class _Reverse_copy_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <bidirectional_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out>
            requires indirectly_copyable<_It, _Out>
        constexpr reverse_copy_result<_It, _Out> operator()(_It _First, _Se _Last, _Out _Result) const {
            
            _Adl_verify_range(_First, _Last);
            auto _UFirst = _Get_unwrapped(::std:: move(_First));
            auto _ULast  = _Get_final_iterator_unwrapped<_It>(_UFirst, ::std:: move(_Last));
            _Seek_wrapped(_First, _ULast);
            _Result = _Reverse_copy_common(::std:: move(_UFirst), ::std:: move(_ULast), ::std:: move(_Result));
            return {::std:: move(_First), ::std:: move(_Result)};
        }

        
        template <bidirectional_range _Rng, weakly_incrementable _Out>
            requires indirectly_copyable<iterator_t<_Rng>, _Out>
        constexpr reverse_copy_result<borrowed_iterator_t<_Rng>, _Out> operator()(_Rng&& _Range, _Out _Result) const {
            
            if constexpr (common_range<_Rng>) {
                _Result = _Reverse_copy_common(_Ubegin(_Range), _Uend(_Range), ::std:: move(_Result));
                return {::std::ranges:: end(_Range), ::std:: move(_Result)};
            } else {
                auto _ULast = _Get_final_iterator_unwrapped(_Range);
                _Result     = _Reverse_copy_common(_Ubegin(_Range), _ULast, ::std:: move(_Result));
                return {_Rewrap_iterator(_Range, ::std:: move(_ULast)), ::std:: move(_Result)};
            }
        }

    private:
        template <class _It, class _Out>
        [[nodiscard]] static constexpr _Out _Reverse_copy_common(const _It _First, _It _Last, _Out _Result) {
            ;
            ;
            ;


            if constexpr (contiguous_iterator<_It> && contiguous_iterator<_Out>) {
                using _Elem                         = remove_reference_t<iter_reference_t<_It>>;
                using _DestElem                     = remove_reference_t<iter_reference_t<_Out>>;
                constexpr bool _Allow_vectorization = conjunction_v<is_same<remove_const_t<_Elem>, _DestElem>,
                    is_trivially_copyable<_Elem>, negation<is_volatile<_Elem>>>;
                constexpr size_t _Nx                = sizeof(_Elem);

#pragma warning(suppress : 6326) 
                if constexpr (_Allow_vectorization && _Nx <= 8 && (_Nx & (_Nx - 1)) == 0) {
                    if (!::std:: is_constant_evaluated()) {
                        _Elem* const _First_addr      = ::std:: to_address(_First);
                        _Elem* const _Last_addr       = ::std:: to_address(_Last);
                        _DestElem* const _Result_addr = ::std:: to_address(_Result);
                        if constexpr (_Nx == 1) {
                            __std_reverse_copy_trivially_copyable_1(_First_addr, _Last_addr, _Result_addr);
                        } else if constexpr (_Nx == 2) {
                            __std_reverse_copy_trivially_copyable_2(_First_addr, _Last_addr, _Result_addr);
                        } else if constexpr (_Nx == 4) {
                            __std_reverse_copy_trivially_copyable_4(_First_addr, _Last_addr, _Result_addr);
                        } else {
                            __std_reverse_copy_trivially_copyable_8(_First_addr, _Last_addr, _Result_addr);
                        }

                        _Result += _Last - _First;
                        return _Result;
                    }
                }
            }
#line 4480 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

            for (; _First != _Last; ++_Result) {
                *_Result = *--_Last;
            }

            return _Result;
        }
    };

    inline constexpr _Reverse_copy_fn reverse_copy{_Not_quite_object::_Construct_tag{}};
} 
#line 4492 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
#line 4493 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


namespace ranges {
    template <permutable _It>
    [[nodiscard]] constexpr subrange<_It> _Reverse_until_mid_unchecked(_It _First, const _It _Mid, _It _Last) {
        
        ;
        ;

        do {
            ::std::ranges:: iter_swap(_First, --_Last);
        } while (++_First != _Mid && _Last != _Mid);

        return {::std:: move(_First), ::std:: move(_Last)};
    }

    template <permutable _It, sentinel_for<_It> _Se>
    [[nodiscard]] constexpr subrange<_It> _Rotate_unchecked(_It _First, _It _Mid, _Se _Last) {
        
        
        if (_First == _Mid) {
            auto _Final = _Get_final_iterator_unwrapped<_It>(_Mid, ::std:: move(_Last));
            return {_Final, _Final};
        }

        if (_Mid == _Last) {
            return {::std:: move(_First), ::std:: move(_Mid)};
        }

        if constexpr (bidirectional_iterator<_It>) {
            _Reverse_common(_First, _Mid);
            auto _Final = _Get_final_iterator_unwrapped<_It>(_Mid, ::std:: move(_Last));
            _Reverse_common(_Mid, _Final);

            if constexpr (random_access_iterator<_It>) {
                _Reverse_common(_First, _Final);
                _First += _Final - _Mid;

                return {::std:: move(_First), ::std:: move(_Final)};
            } else {
                const auto _Result = ::std::ranges:: _Reverse_until_mid_unchecked(::std:: move(_First), _Mid, _Final);
                auto _Mid_first    = _Result.begin();
                auto _Mid_last     = _Result.end();
                _Reverse_common(_Mid_first, _Mid_last);

                if (_Mid_first == _Mid) {
                    return {::std:: move(_Mid_last), ::std:: move(_Final)};
                } else {
                    return {::std:: move(_Mid_first), ::std:: move(_Final)};
                }
            }
        } else {
            auto _Next = _Mid;
            do { 
                ::std::ranges:: iter_swap(_First, _Next);
                ++_First;
                ++_Next;
                if (_First == _Mid) {
                    _Mid = _Next;
                }
            } while (_Next != _Last);

            auto _Begin = _First;

            while (_Mid != _Last) { 
                _Next = _Mid;
                do {
                    ::std::ranges:: iter_swap(_First, _Next);
                    ++_First;
                    ++_Next;
                    if (_First == _Mid) {
                        _Mid = _Next;
                    }
                } while (_Next != _Last);
            }
            return {::std:: move(_Begin), ::std:: move(_Mid)};
        }
    }

    class _Rotate_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <permutable _It, sentinel_for<_It> _Se>
        constexpr subrange<_It> operator()(_It _First, _It _Mid, _Se _Last) const {
            _Adl_verify_range(_First, _Mid);
            _Adl_verify_range(_Mid, _Last);
            auto _UResult = ::std::ranges:: _Rotate_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Mid)), _Get_unwrapped(::std:: move(_Last)));

            return _Rewrap_subrange<subrange<_It>>(_First, ::std:: move(_UResult));
        }

        
        template <forward_range _Rng>
            requires permutable<iterator_t<_Rng>>
        constexpr borrowed_subrange_t<_Rng> operator()(_Rng&& _Range, iterator_t<_Rng> _Mid) const {
            
            _Adl_verify_range(::std::ranges:: begin(_Range), _Mid);
            _Adl_verify_range(_Mid, ::std::ranges:: end(_Range));
            auto _UResult = ::std::ranges:: _Rotate_unchecked(_Ubegin(_Range), _Get_unwrapped(::std:: move(_Mid)), _Uend(_Range));

            return _Rewrap_subrange<borrowed_subrange_t<_Rng>>(_Mid, ::std:: move(_UResult));
        }
    };

    inline constexpr _Rotate_fn rotate{_Not_quite_object::_Construct_tag{}};
} 
#line 4603 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _FwdIt, class _OutIt>
constexpr _OutIt rotate_copy(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last, _OutIt _Dest) {
    
    _Adl_verify_range(_First, _Mid);
    _Adl_verify_range(_Mid, _Last);
    const auto _UFirst = _Get_unwrapped(_First);
    const auto _UMid   = _Get_unwrapped(_Mid);
    const auto _ULast  = _Get_unwrapped(_Last);
    auto _UDest        = _Get_unwrapped_n(_Dest, _Idl_distance<_FwdIt>(_UFirst, _ULast));
    _UDest             = _Copy_unchecked(_UMid, _ULast, _UDest);
    _Seek_wrapped(_Dest, _Copy_unchecked(_UFirst, _UMid, _UDest));
    return _Dest;
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt2 rotate_copy(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Mid, _FwdIt1 _Last, _FwdIt2 _Dest) noexcept  {
    
    
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: rotate_copy(_First, _Mid, _Last, _Dest);
}


namespace ranges {
    template <class _In, class _Out>
    using rotate_copy_result = in_out_result<_In, _Out>;

    class _Rotate_copy_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <forward_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out>
            requires indirectly_copyable<_It, _Out>
        constexpr rotate_copy_result<_It, _Out> operator()(_It _First, _It _Mid, _Se _Last, _Out _Result) const {
            
            _Adl_verify_range(_First, _Mid);
            _Adl_verify_range(_Mid, _Last);
            auto _UResult = _Rotate_copy_unchecked(_Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Mid)),
                _Get_unwrapped(::std:: move(_Last)), ::std:: move(_Result));

            _Seek_wrapped(_First, ::std:: move(_UResult.in));
            return {::std:: move(_First), ::std:: move(_UResult.out)};
        }

        
        template <forward_range _Rng, weakly_incrementable _Out>
            requires indirectly_copyable<iterator_t<_Rng>, _Out>
        constexpr rotate_copy_result<borrowed_iterator_t<_Rng>, _Out> operator()(
            _Rng&& _Range, iterator_t<_Rng> _Mid, _Out _Result) const {
            
            _Adl_verify_range(::std::ranges:: begin(_Range), _Mid);
            _Adl_verify_range(_Mid, ::std::ranges:: end(_Range));
            auto _UResult = _Rotate_copy_unchecked(
                _Ubegin(_Range), _Get_unwrapped(::std:: move(_Mid)), _Uend(_Range), ::std:: move(_Result));

            return {_Rewrap_iterator(_Range, ::std:: move(_UResult.in)), ::std:: move(_UResult.out)};
        }

    private:
        template <class _It, class _Se, class _Out>
        [[nodiscard]] static constexpr rotate_copy_result<_It, _Out> _Rotate_copy_unchecked(
            _It _First, _It _Mid, _Se _Last, _Out _Result) {
            
            ;
            ;
            ;
            ;

            auto _UResult1 = ::std::ranges:: _Copy_unchecked(_Mid, ::std:: move(_Last), ::std:: move(_Result));
            auto _UResult2 = ::std::ranges:: _Copy_unchecked(::std:: move(_First), ::std:: move(_Mid), ::std:: move(_UResult1.out));
            return {::std:: move(_UResult1.in), ::std:: move(_UResult2.out)};
        }
    };

    inline constexpr _Rotate_copy_fn rotate_copy{_Not_quite_object::_Construct_tag{}};
} 
#line 4683 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _PopIt, class _SampleIt, class _Diff, class _RngFn>
_SampleIt _Sample_reservoir_unchecked(
    _PopIt _First, const _PopIt _Last, const _SampleIt _Dest, const _Diff _Count, _RngFn& _RngFunc) {
    
    
    using _Diff_sample = _Iter_diff_t<_SampleIt>;
    const auto _SCount = static_cast<_Diff_sample>(_Count);
    _Iter_diff_t<_PopIt> _Pop_size{};
    for (; _Pop_size < _SCount; ++_Pop_size, (void) ++_First) {
        
        
        const auto _Sample_pop = static_cast<_Diff_sample>(_Pop_size);
        if (_First == _Last) {
            return _Dest + _Sample_pop;
        }

        *(_Dest + _Sample_pop) = *_First;
    }
    for (; _First != _Last; ++_First) {
        const auto _Idx = _RngFunc(++_Pop_size);
        if (_Idx < _SCount) {
            *(_Dest + static_cast<_Diff_sample>(_Idx)) = *_First; 
        }
    }
    return _Dest + _SCount;
}

template <class _PopIt, class _SampleIt, class _Diff, class _RngFn>
_SampleIt _Sample_selection_unchecked(
    _PopIt _First, _Iter_diff_t<_PopIt> _Pop_size, _SampleIt _Dest, _Diff _Count, _RngFn& _RngFunc) {
    
    
    using _CT = common_type_t<_Iter_diff_t<_PopIt>, _Diff>;
    for (; _Pop_size > 0; ++_First, (void) --_Pop_size) {
        if (static_cast<_CT>(_RngFunc(_Pop_size)) < static_cast<_CT>(_Count)) {
            --_Count;
            *_Dest = *_First;
            ++_Dest;
        }
    }
    return _Dest;
}

template <class _PopIt, class _SampleIt, class _Diff, class _RngFn>
_SampleIt _Sample1(_PopIt _First, _PopIt _Last, _SampleIt _Dest, _Diff _Count, _RngFn& _RngFunc, input_iterator_tag) {
    
    
    _Seek_wrapped(
        _Dest, _Sample_reservoir_unchecked(_First, _Last, _Get_unwrapped_unverified(_Dest), _Count, _RngFunc));
    return _Dest;
}

template <class _PopIt, class _SampleIt, class _Diff, class _RngFn>
_SampleIt _Sample1(_PopIt _First, _PopIt _Last, _SampleIt _Dest, _Diff _Count, _RngFn& _RngFunc, forward_iterator_tag) {
    
    
    using _PopDiff       = _Iter_diff_t<_PopIt>;
    using _CT            = common_type_t<_Diff, _PopDiff>;
    const auto _Pop_size = ::std:: distance(_First, _Last);
    if (static_cast<_CT>(_Count) > static_cast<_CT>(_Pop_size)) {
        _Count = static_cast<_Diff>(_Pop_size); 
    }

    _Seek_wrapped(
        _Dest, _Sample_selection_unchecked(_First, _Pop_size, _Get_unwrapped_n(_Dest, _Count), _Count, _RngFunc));
    return _Dest;
}

template <class _PopIt, class _SampleIt, class _Diff, class _Urng>
_SampleIt sample(_PopIt _First, _PopIt _Last, _SampleIt _Dest, _Diff _Count,
    _Urng&& _Func) { 
    static_assert(_Is_fwd_iter_v<_PopIt> || _Is_random_iter_v<_SampleIt>,
        "If the source range is not forward, the destination range must be random-access.");
    static_assert(is_integral_v<_Diff>, "The sample size must have an integer type.");
    _Adl_verify_range(_First, _Last);
    if (0 < _Count) {
        _Rng_from_urng<_Iter_diff_t<_PopIt>, remove_reference_t<_Urng>> _RngFunc(_Func);
        _Dest = _Sample1(_Get_unwrapped(_First), _Get_unwrapped(_Last), _Dest, _Count, _RngFunc, _Iter_cat_t<_PopIt>{});
    }

    return _Dest;
}


template <class _Ty>
concept uniform_random_bit_generator = invocable<_Ty&>
    && unsigned_integral<invoke_result_t<_Ty&>>
    && requires {
        { (_Ty::min)() } -> same_as<invoke_result_t<_Ty&>>;
        { (_Ty::max)() } -> same_as<invoke_result_t<_Ty&>>;
        requires bool_constant<(_Ty::min)() < (_Ty::max)()>::value;
    };


namespace ranges {
    class _Sample_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out, class _Urng>
            requires (forward_iterator<_It> || random_access_iterator<_Out>)
                  && indirectly_copyable<_It, _Out> && uniform_random_bit_generator<remove_reference_t<_Urng>>
        _Out operator()(_It _First, _Se _Last, _Out _Result, iter_difference_t<_It> _Count, _Urng&& _Func) const {
            _Adl_verify_range(_First, _Last);
            if (_Count <= 0) {
                return _Result;
            }

            _Rng_from_urng<iter_difference_t<_It>, remove_reference_t<_Urng>> _RngFunc(_Func);
            if constexpr (forward_iterator<_It>) {
                auto _UFirst   = _Get_unwrapped(::std:: move(_First));
                auto _Pop_size = ::std::ranges:: distance(_UFirst, _Get_unwrapped(::std:: move(_Last)));
                return _Sample_selection_unchecked(::std:: move(_UFirst), _Pop_size, ::std:: move(_Result), _Count, _RngFunc);
            } else {
                return _Sample_reservoir_unchecked(_Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)),
                    ::std:: move(_Result), _Count, _RngFunc);
            }
        }

        template <input_range _Rng, weakly_incrementable _Out, class _Urng>
           requires (forward_range<_Rng> || random_access_iterator<_Out>)
                  && indirectly_copyable<iterator_t<_Rng>, _Out>
                  && uniform_random_bit_generator<remove_reference_t<_Urng>>
        _Out operator()(_Rng&& _Range, _Out _Result, range_difference_t<_Rng> _Count, _Urng&& _Func) const {
            if (_Count <= 0) {
                return _Result;
            }

            _Rng_from_urng<range_difference_t<_Rng>, remove_reference_t<_Urng>> _RngFunc(_Func);
            if constexpr (forward_range<_Rng>) {
                auto _UFirst   = _Ubegin(_Range);
                auto _Pop_size = ::std::ranges:: distance(_UFirst, _Uend(_Range));
                return _Sample_selection_unchecked(::std:: move(_UFirst), _Pop_size, ::std:: move(_Result), _Count, _RngFunc);
            } else {
                return _Sample_reservoir_unchecked(
                    _Ubegin(_Range), _Uend(_Range), ::std:: move(_Result), _Count, _RngFunc);
            }
        }
        
    private:
        template <class _It, class _Out, class _Rng>
        [[nodiscard]] static _Out _Sample_selection_unchecked(
            _It _First, iter_difference_t<_It> _Pop_size, _Out _Result, iter_difference_t<_It> _Count, _Rng& _RngFunc) {
            
            ;
            ;
            ;

            if (_Count > _Pop_size) {
                _Count = _Pop_size;
            }

            for (; _Pop_size > 0; ++_First, (void) --_Pop_size) {
                if (_RngFunc(_Pop_size) < _Count) {
                    *_Result = *_First;
                    ++_Result;
                    if (--_Count == 0) {
                        break;
                    }
                }
            }

            return _Result;
        }

        template <class _It, class _Se, class _Out, class _Rng>
        [[nodiscard]] static _Out _Sample_reservoir_unchecked(
            _It _First, const _Se _Last, _Out _Result, const iter_difference_t<_It> _Count, _Rng& _RngFunc) {
            
            ;
            ;
            ;
            ;

            iter_difference_t<_It> _Pop_size{};
            for (; _Pop_size < _Count; ++_Pop_size, (void) ++_First) {
                if (_First == _Last) {
                    return _Result + _Pop_size;
                }

                *(_Result + _Pop_size) = *_First;
            }
            for (; _First != _Last; ++_First) {
                const auto _Idx = _RngFunc(++_Pop_size);
                if (_Idx < _Count) {
                    *(_Result + _Idx) = *_First;
                }
            }

            return _Result + _Count;
        }
    };

    inline constexpr _Sample_fn sample{_Not_quite_object::_Construct_tag{}};
} 
#line 4883 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
#line 4884 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _RanIt, class _RngFn>
void _Random_shuffle1(_RanIt _First, _RanIt _Last, _RngFn& _RngFunc) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    if (_UFirst == _ULast) {
        return;
    }

    using _Diff         = _Iter_diff_t<_RanIt>;
    auto _UTarget       = _UFirst;
    _Diff _Target_index = 1;
    for (; ++_UTarget != _ULast; ++_Target_index) { 
        _Diff _Off = _RngFunc(static_cast<_Diff>(_Target_index + 1));
        ;
        if (_Off != _Target_index) { 
            ::std:: iter_swap(_UTarget, _UFirst + _Off);
        }
    }
}

template <class _RanIt, class _Urng>
void shuffle(_RanIt _First, _RanIt _Last, _Urng&& _Func) { 
    using _Urng0 = remove_reference_t<_Urng>;
    _Rng_from_urng<_Iter_diff_t<_RanIt>, _Urng0> _RngFunc(_Func);
    _Random_shuffle1(_First, _Last, _RngFunc);
}


namespace ranges {
    class _Shuffle_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <random_access_iterator _It, sentinel_for<_It> _Se, class _Urng>
            requires permutable<_It> && uniform_random_bit_generator<remove_reference_t<_Urng>>
        _It operator()(_It _First, _Se _Last, _Urng&& _Func) const {
            _Adl_verify_range(_First, _Last);

            _Rng_from_urng<iter_difference_t<_It>, remove_reference_t<_Urng>> _RngFunc(_Func);
            auto _UResult =
                _Shuffle_unchecked(_Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)), _RngFunc);

            _Seek_wrapped(_First, ::std:: move(_UResult));
            return _First;
        }

        template <random_access_range _Rng, class _Urng>
            requires permutable<iterator_t<_Rng>> && uniform_random_bit_generator<remove_reference_t<_Urng>>
        borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, _Urng&& _Func) const {
            _Rng_from_urng<range_difference_t<_Rng>, remove_reference_t<_Urng>> _RngFunc(_Func);

            return _Rewrap_iterator(_Range, _Shuffle_unchecked(_Ubegin(_Range), _Uend(_Range), _RngFunc));
        }
        
    private:
        template <class _It, class _Se, class _Rng>
        [[nodiscard]] static _It _Shuffle_unchecked(_It _First, const _Se _Last, _Rng& _Func) {
            
            ;
            ;
            ;

            if (_First == _Last) {
                return _First;
            }
            using _Diff = iter_difference_t<_It>;

            auto _Target        = _First;
            _Diff _Target_index = 1;
            for (; ++_Target != _Last; ++_Target_index) {
                
                const _Diff _Off = _Func(_Target_index + 1);
                ;
                if (_Off != _Target_index) { 
                    ::std::ranges:: iter_swap(_Target, _First + _Off);
                }
            }
            return _Target;
        }
    };

    inline constexpr _Shuffle_fn shuffle{_Not_quite_object::_Construct_tag{}};
} 
#line 4972 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


#line 5002 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


template <class _FwdIt>
constexpr _FwdIt shift_left(_FwdIt _First, const _FwdIt _Last, _Iter_diff_t<_FwdIt> _Pos_to_shift) {
    
    
    _Adl_verify_range(_First, _Last);

    if (_Pos_to_shift <= 0) {
        return _Last;
    }

    const auto _UFirst = _Get_unwrapped(_First);
    const auto _ULast  = _Get_unwrapped(_Last);
    auto _Start_at     = _UFirst;

    if constexpr (_Is_random_iter_v<_FwdIt>) {
        if (_Pos_to_shift >= _ULast - _UFirst) {
            return _First;
        }
        _Start_at += _Pos_to_shift;
    } else {
        for (; 0 < _Pos_to_shift; --_Pos_to_shift) {
            if (_Start_at == _ULast) {
                return _First;
            }
            ++_Start_at;
        }
    }

    _Seek_wrapped(_First, _Move_unchecked(_Start_at, _ULast, _UFirst));
    return _First;
}

template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt shift_left(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Iter_diff_t<_FwdIt> _Pos_to_shift) noexcept  {
    
    
    return ::std:: shift_left(_First, _Last, _Pos_to_shift);
}

template <class _FwdIt>
constexpr _FwdIt shift_right(_FwdIt _First, const _FwdIt _Last, _Iter_diff_t<_FwdIt> _Pos_to_shift) {
    
    
    _Adl_verify_range(_First, _Last);

    if (_Pos_to_shift <= 0) {
        return _First;
    }

    const auto _UFirst = _Get_unwrapped(_First);
    const auto _ULast  = _Get_unwrapped(_Last);

    if constexpr (_Is_bidi_iter_v<_FwdIt>) {
        auto _UEnd_at = _ULast;
        if constexpr (_Is_random_iter_v<_FwdIt>) {
            if (_Pos_to_shift >= _ULast - _UFirst) {
                return _Last;
            }
            _UEnd_at -= _Pos_to_shift;
        } else {
            for (; 0 < _Pos_to_shift; --_Pos_to_shift) {
                if (_UEnd_at == _UFirst) {
                    return _Last;
                }
                --_UEnd_at;
            }
        }

        _Seek_wrapped(_First, _Move_backward_unchecked(_UFirst, _UEnd_at, _ULast));
        return _First;
    } else {
        auto _UResult = _UFirst;

        for (; 0 < _Pos_to_shift; --_Pos_to_shift) {
            if (_UResult == _ULast) {
                return _Last;
            }
            ++_UResult;
        }
        _Seek_wrapped(_First, _UResult);

        auto _Trail = _UFirst;
        auto _Lead  = _UResult;

        for (; _Trail != _UResult; ++_Trail, (void) ++_Lead) {
            if (_Lead == _ULast) {
                _Move_unchecked(_UFirst, _Trail, _UResult);

                return _First;
            }
        }

        
        for (;;) {
            
            
            for (auto _Mid = _UFirst; _Mid != _UResult; ++_Mid, (void) ++_Trail, ++_Lead) {
                if (_Lead == _ULast) {
                    _Trail = _Move_unchecked(_Mid, _UResult, _Trail);
                    _Move_unchecked(_UFirst, _Mid, _Trail);

                    return _First;
                }
                _Swap_adl(*_Mid, *_Trail);
            }
        }
    }
}

template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt shift_right(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Iter_diff_t<_FwdIt> _Pos_to_shift) noexcept  {
    
    
    return ::std:: shift_right(_First, _Last, _Pos_to_shift);
}
#line 5122 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _FwdIt, class _Pr>
constexpr _FwdIt partition(_FwdIt _First, const _FwdIt _Last, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst = _Get_unwrapped(_First);
    auto _ULast  = _Get_unwrapped(_Last);
    if constexpr (_Is_bidi_iter_v<_FwdIt>) {
        for (;;) { 
            for (;;) { 
                if (_UFirst == _ULast) {
                    _Seek_wrapped(_First, _UFirst);
                    return _First;
                }

                if (!_Pred(*_UFirst)) {
                    break;
                }

                ++_UFirst;
            }

            do { 
                --_ULast;
                if (_UFirst == _ULast) {
                    _Seek_wrapped(_First, _UFirst);
                    return _First;
                }
            } while (!_Pred(*_ULast));

            ::std:: iter_swap(_UFirst, _ULast); 
            ++_UFirst;
        }
    } else {
        for (;;) { 
            if (_UFirst == _ULast) {
                _Seek_wrapped(_First, _UFirst);
                return _First;
            }

            if (!_Pred(*_UFirst)) {
                break;
            }

            ++_UFirst;
        }

        for (auto _UNext = _UFirst; ++_UNext != _ULast;) {
            if (_Pred(*_UNext)) {
                ::std:: iter_swap(_UFirst, _UNext); 
                ++_UFirst;
            }
        }
    }

    _Seek_wrapped(_First, _UFirst);
    return _First;
}


template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt partition(_ExPo&& _Exec, _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept; 


namespace ranges {
    class _Partition_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <permutable _It, sentinel_for<_It> _Se, class _Pj = identity,
            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
        constexpr subrange<_It> operator()(_It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            auto _UResult = _Partition_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)), _Pass_fn(_Pred), _Pass_fn(_Proj));
            return _Rewrap_subrange<subrange<_It>>(_First, ::std:: move(_UResult));
        }

        
        template <forward_range _Rng, class _Pj = identity,
            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
            requires permutable<iterator_t<_Rng>>
        constexpr borrowed_subrange_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) const {
            auto _UResult = _Partition_unchecked(_Ubegin(_Range), _Uend(_Range), _Pass_fn(_Pred), _Pass_fn(_Proj));
            return _Rewrap_subrange<borrowed_subrange_t<_Rng>>(_Range, ::std:: move(_UResult));
        }
        
    private:
        template <class _It, class _Se, class _Pr, class _Pj>
        [[nodiscard]] static constexpr subrange<_It> _Partition_unchecked(_It _First, _Se _Last, _Pr _Pred, _Pj _Proj) {
            ;
            ;
            ;

            if constexpr (_Bidi_common<_It, _Se>) {
                auto _Saved_last = _Last;
                for (;; ++_First) { 
                    for (;; ++_First) { 
                        if (_First == _Last) {
                            return {::std:: move(_First), ::std:: move(_Saved_last)};
                        }

                        if (!::std:: invoke(_Pred, ::std:: invoke(_Proj, *_First))) {
                            break;
                        }
                    }

                    do { 
                        --_Last;
                        if (_First == _Last) {
                            return {::std:: move(_First), ::std:: move(_Saved_last)};
                        }
                    } while (!::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Last)));

                    ::std::ranges:: iter_swap(_First, _Last); 
                }

                return {::std:: move(_First), ::std:: move(_Saved_last)};
            } else {
                for (;; ++_First) { 
                    if (_First == _Last) {
                        return {_First, _First};
                    }

                    if (!::std:: invoke(_Pred, ::std:: invoke(_Proj, *_First))) {
                        break;
                    }
                }

                auto _Next = _First;
                while (++_Next != _Last) {
                    if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Next))) {
                        ::std::ranges:: iter_swap(_First, _Next); 
                        ++_First;
                    }
                }

                return {::std:: move(_First), ::std:: move(_Next)};
            }
        }
    };

    inline constexpr _Partition_fn partition{_Not_quite_object::_Construct_tag{}};
} 
#line 5267 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
#line 5268 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _BidIt>
_BidIt _Buffered_rotate_unchecked(const _BidIt _First, const _BidIt _Mid, const _BidIt _Last,
    const _Iter_diff_t<_BidIt> _Count1, const _Iter_diff_t<_BidIt> _Count2, _Iter_value_t<_BidIt>* const _Temp_ptr,
    const ptrdiff_t _Capacity) { 
                                 
                                 
    if (_Count1 == 0) {
        return _Last;
    }

    if (_Count2 == 0) {
        return _First;
    }

    if (_Count1 <= _Count2 && _Count1 <= _Capacity) { 
        _Uninitialized_backout<_Iter_value_t<_BidIt>*> _Backout{
            _Temp_ptr, _Uninitialized_move_unchecked(_First, _Mid, _Temp_ptr)};
        const _BidIt _New_mid = _Move_unchecked(_Mid, _Last, _First);
        _Move_unchecked(_Backout._First, _Backout._Last, _New_mid);
        return _New_mid; 
    }

    if (_Count2 <= _Capacity) { 
        _Uninitialized_backout<_Iter_value_t<_BidIt>*> _Backout{
            _Temp_ptr, _Uninitialized_move_unchecked(_Mid, _Last, _Temp_ptr)};
        _Move_backward_unchecked(_First, _Mid, _Last);
        return _Move_unchecked(_Backout._First, _Backout._Last, _First); 
    }

    
    return ::std:: rotate(_First, _Mid, _Last);
}

template <class _BidIt, class _Pr>
pair<_BidIt, _Iter_diff_t<_BidIt>> _Stable_partition_unchecked1(_BidIt _First, _BidIt _Last, _Pr _Pred,
    const _Iter_diff_t<_BidIt> _Count, _Iter_value_t<_BidIt>* const _Temp_ptr, const ptrdiff_t _Capacity) {
    
    
    using _Diff = _Iter_diff_t<_BidIt>;
    if (_Count - static_cast<_Diff>(1) <= _Capacity) { 
        _Uninitialized_backout<_Iter_value_t<_BidIt>*> _Backout{_Temp_ptr};
        _BidIt _Next = _First;
        _Backout._Emplace_back(::std:: move(*_First));
        while (++_First != _Last) { 
                                    
            if (_Pred(*_First)) {
                *_Next = ::std:: move(*_First);
                ++_Next;
            } else {
                _Backout._Emplace_back(::std:: move(*_First));
            }
        }

        
        *_Next = ::std:: move(*_Last);
        ++_Next;
        _Move_unchecked(_Backout._First, _Backout._Last, _Next); 
        _Diff _True_distance = static_cast<_Diff>(_Count - static_cast<_Diff>(_Backout._Last - _Backout._First));
        return pair<_BidIt, _Diff>(_Next, _True_distance); 
    }

    const _Diff _Mid_offset = _Count / static_cast<_Diff>(2); 
    const _BidIt _Mid       = ::std:: next(_First, _Mid_offset);

    
    _BidIt _Left           = _Mid;
    _Diff _Left_true_count = _Mid_offset;
    for (;;) { 
        --_Left;
        if (_First == _Left) { 
            --_Left_true_count; 
            break;
        }

        if (_Pred(*_Left)) { 
            const pair<_BidIt, _Diff> _Low =
                _Stable_partition_unchecked1(_First, _Left, _Pred, _Left_true_count, _Temp_ptr, _Capacity);
            _Left            = _Low.first;
            _Left_true_count = _Low.second;
            break;
        }

        --_Left_true_count;
    }

    
    _BidIt _Right           = _Mid;
    _Diff _Right_true_count = 0;
    for (;;) { 
        if (_Right == _Last) { 
            ++_Right; 
            ++_Right_true_count;
            break;
        }

        if (!_Pred(*_Right)) { 
            const _Diff _Right_count = _Count - _Mid_offset;
            const _Diff _Remaining   = _Right_count - _Right_true_count;
            const pair<_BidIt, _Diff> _High =
                _Stable_partition_unchecked1(_Right, _Last, _Pred, _Remaining, _Temp_ptr, _Capacity);
            _Right = _High.first;
            _Right_true_count += _High.second;
            break;
        }

        ++_Right;
        ++_Right_true_count;
    }

    
    const _BidIt _Partition_point = _Buffered_rotate_unchecked(_Left, _Mid, _Right,
        static_cast<_Diff>(_Mid_offset - _Left_true_count), _Right_true_count, _Temp_ptr, _Capacity);
    return pair<_BidIt, _Diff>(_Partition_point, static_cast<_Diff>(_Left_true_count + _Right_true_count));
}

template <class _BidIt, class _Pr>
_BidIt _Stable_partition_unchecked(_BidIt _First, _BidIt _Last, _Pr _Pred) {
    
    for (;;) {
        if (_First == _Last) { 
            return _First;
        }

        if (!_Pred(*_First)) { 
            break;
        }

        ++_First;
    }

    for (;;) {
        --_Last;
        if (_First == _Last) { 
            return _First;
        }

        if (_Pred(*_Last)) { 
            break;
        }
    }

    using _Diff              = _Iter_diff_t<_BidIt>;
    const _Diff _Temp_count  = ::std:: distance(_First, _Last); 
    const _Diff _Total_count = _Temp_count + static_cast<_Diff>(1);
    _Optimistic_temporary_buffer<_Iter_value_t<_BidIt>> _Temp_buf{_Temp_count};
    return _Stable_partition_unchecked1(_First, _Last, _Pred, _Total_count, _Temp_buf._Data, _Temp_buf._Capacity).first;
}

template <class _BidIt, class _Pr>
_BidIt stable_partition(_BidIt _First, _BidIt _Last, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Last);
    _Seek_wrapped(_First, _Stable_partition_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last), _Pass_fn(_Pred)));
    return _First;
}


template <class _ExPo, class _BidIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
_BidIt stable_partition(_ExPo&&, _BidIt _First, _BidIt _Last, _Pr _Pred) noexcept  {
    
    
    return ::std:: stable_partition(_First, _Last, _Pass_fn(_Pred));
}
#line 5437 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


namespace ranges {
    template <bidirectional_iterator _It>
    _It _Buffered_rotate_common(const _It _First, const _It _Mid, const _It _Last, const iter_difference_t<_It> _Count1,
        const iter_difference_t<_It> _Count2, iter_value_t<_It>* const _Temp_ptr, const ptrdiff_t _Capacity) {
        
        ;
        ;

        if (_Count1 == 0) {
            return _Last;
        }

        if (_Count2 == 0) {
            return _First;
        }

        if (_Count1 <= _Count2 && _Count1 <= _Capacity) { 
            _Uninitialized_backout<iter_value_t<_It>*> _Backout{
                _Temp_ptr, ::std::ranges:: _Uninitialized_move_unchecked(_First, _Mid, _Temp_ptr, _Temp_ptr + _Count1).out};
            const _It _New_mid = ::std::ranges:: _Move_unchecked(::std:: move(_Mid), ::std:: move(_Last), ::std:: move(_First)).out;
            ::std::ranges:: _Move_unchecked(_Backout._First, _Backout._Last, _New_mid);
            return _New_mid;
        }

        if (_Count2 <= _Capacity) { 
            _Uninitialized_backout<iter_value_t<_It>*> _Backout{
                _Temp_ptr, ::std::ranges:: _Uninitialized_move_unchecked(_Mid, _Last, _Temp_ptr, _Temp_ptr + _Count2).out};
            ::std::ranges:: _Move_backward_common(_First, ::std:: move(_Mid), ::std:: move(_Last));
            return ::std::ranges:: _Move_unchecked(_Backout._First, _Backout._Last, ::std:: move(_First)).out;
        }

        
        return ::std::ranges:: _Rotate_unchecked(::std:: move(_First), ::std:: move(_Mid), ::std:: move(_Last)).begin();
    }

    class _Stable_partition_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <bidirectional_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
            indirect_unary_predicate<projected<_It, _Pj>> _Pr>
            requires permutable<_It>
        subrange<_It> operator()(_It _First, _Se _Last, _Pr _Pred, _Pj _Proj = {}) const {
            
            _Adl_verify_range(_First, _Last);
            auto _UFirst = _Get_unwrapped(::std:: move(_First));
            auto _ULast  = _Get_final_iterator_unwrapped<_It>(_UFirst, ::std:: move(_Last));

            auto _UResult =
                _Stable_partition_common(::std:: move(_UFirst), ::std:: move(_ULast), _Pass_fn(_Pred), _Pass_fn(_Proj));
            return _Rewrap_subrange<subrange<_It>>(_First, ::std:: move(_UResult));
        }

        
        template <bidirectional_range _Rng, class _Pj = identity,
            indirect_unary_predicate<projected<iterator_t<_Rng>, _Pj>> _Pr>
            requires permutable<iterator_t<_Rng>>
        borrowed_subrange_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred, _Pj _Proj = {}) const {
            
            auto _ULast = _Get_final_iterator_unwrapped(_Range);
            auto _UResult =
                _Stable_partition_common(_Ubegin(_Range), ::std:: move(_ULast), _Pass_fn(_Pred), _Pass_fn(_Proj));
            return _Rewrap_subrange<borrowed_subrange_t<_Rng>>(_Range, ::std:: move(_UResult));
        }

    private:
        template <class _It, class _Pr, class _Pj>
        [[nodiscard]] static subrange<_It> _Stable_partition_common(_It _First, _It _Last, _Pr _Pred, _Pj _Proj) {
            ;
            ;
            ;

            
            for (;;) { 
                if (_First == _Last) { 
                    return {::std:: move(_First), ::std:: move(_Last)};
                }

                if (!::std:: invoke(_Pred, ::std:: invoke(_Proj, *_First))) {
                    break;
                }
                ++_First;
            }

            auto _Saved_last = _Last;
            do { 
                --_Last;
                if (_First == _Last) {
                    return {::std:: move(_First), ::std:: move(_Saved_last)};
                }
            } while (!::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Last)));

            const iter_difference_t<_It> _Temp_count = ::std::ranges:: distance(_First, _Last);
            _Optimistic_temporary_buffer<iter_value_t<_It>> _Temp_buf{_Temp_count};

            
            const auto _Total_count = static_cast<iter_difference_t<_It>>(_Temp_count + 1);

            auto _Result = _Stable_partition_common_buffered(
                ::std:: move(_First), ::std:: move(_Last), _Pred, _Proj, _Total_count, _Temp_buf._Data, _Temp_buf._Capacity);
            return {::std:: move(_Result.first), ::std:: move(_Saved_last)};
        }

        template <class _It, class _Pr, class _Pj>
        [[nodiscard]] static pair<_It, iter_difference_t<_It>> _Stable_partition_common_buffered(_It _First, _It _Last,
            _Pr _Pred, _Pj _Proj, const iter_difference_t<_It> _Count, iter_value_t<_It>* const _Temp_ptr,
            const ptrdiff_t _Capacity) {
            
            
            ;
            ;
            ;
            ;
            ;
            ;

            using _Diff = iter_difference_t<_It>;
            if (_Count - 1 <= _Capacity) { 
                _Uninitialized_backout<iter_value_t<_It>*> _Backout{_Temp_ptr};
                _It _Next = _First;
                _Backout._Emplace_back(::std::ranges:: iter_move(_First));
                while (++_First != _Last) {
                    
                    
                    if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_First))) {
                        *_Next = ::std::ranges:: iter_move(_First);
                        ++_Next;
                    } else {
                        _Backout._Emplace_back(::std::ranges:: iter_move(_First));
                    }
                }

                
                *_Next = ::std::ranges:: iter_move(_Last);
                ++_Next;
                
                ::std::ranges:: _Move_unchecked(_Backout._First, _Backout._Last, _Next);
                const auto _True_distance = static_cast<_Diff>(_Count - (_Backout._Last - _Backout._First));
                return {::std:: move(_Next), _True_distance};
            }

            const _Diff _Mid_offset = _Count >> 1; 
            const _It _Mid          = ::std::ranges:: next(_First, _Mid_offset);
            
            _It _Left              = _Mid;
            _Diff _Left_true_count = _Mid_offset;
            for (;;) { 
                --_Left;
                --_Left_true_count;
                if (_First == _Left) { 
                    break;
                }

                if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Left))) {
                    
                    ++_Left_true_count; 
                    const auto _Low = _Stable_partition_common_buffered(
                        _First, ::std:: move(_Left), _Pred, _Proj, _Left_true_count, _Temp_ptr, _Capacity);
                    _Left            = ::std:: move(_Low.first);
                    _Left_true_count = _Low.second;
                    break;
                }
            }

            
            _It _Right              = _Mid;
            _Diff _Right_true_count = 0;
            for (;;) { 
                if (_Right == _Last) { 
                    ++_Right; 
                    ++_Right_true_count;
                    break;
                }

                if (!::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Right))) {
                    
                    const auto _Right_count = static_cast<_Diff>(_Count - _Mid_offset);
                    const auto _Remaining   = static_cast<_Diff>(_Right_count - _Right_true_count);
                    const auto _High        = _Stable_partition_common_buffered(
                               ::std:: move(_Right), _Last, _Pred, _Proj, _Remaining, _Temp_ptr, _Capacity);
                    _Right = ::std:: move(_High.first);
                    _Right_true_count += _High.second;
                    break;
                }

                ++_Right;
                ++_Right_true_count;
            }

            
            auto _Partition_point =
                ::std::ranges:: _Buffered_rotate_common(::std:: move(_Left), ::std:: move(_Mid), ::std:: move(_Right),
                    static_cast<_Diff>(_Mid_offset - _Left_true_count), _Right_true_count, _Temp_ptr, _Capacity);
            return {::std:: move(_Partition_point), static_cast<_Diff>(_Left_true_count + _Right_true_count)};
        }
    };

    inline constexpr _Stable_partition_fn stable_partition{_Not_quite_object::_Construct_tag{}};
} 
#line 5640 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _RanIt, class _Ty, class _Pr>
constexpr void _Push_heap_by_index(
    _RanIt _First, _Iter_diff_t<_RanIt> _Hole, _Iter_diff_t<_RanIt> _Top, _Ty&& _Val, _Pr _Pred) {
    
    using _Diff = _Iter_diff_t<_RanIt>;
    for (_Diff _Idx = (_Hole - 1) >> 1; 
         _Top < _Hole && static_cast<bool>(_Pred(*(_First + _Idx), _Val)); 
         _Idx = (_Hole - 1) >> 1) { 
        
        *(_First + _Hole) = ::std:: move(*(_First + _Idx));
        _Hole             = _Idx;
    }

    *(_First + _Hole) = ::std:: forward<_Ty>(_Val); 
}

template <class _RanIt, class _Pr>
constexpr void push_heap(_RanIt _First, _RanIt _Last, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Last);
    const auto _UFirst = _Get_unwrapped(_First);
    auto _ULast        = _Get_unwrapped(_Last);
    using _Diff        = _Iter_diff_t<_RanIt>;
    _Diff _Count       = _ULast - _UFirst;
    if (2 <= _Count) {
        _Iter_value_t<_RanIt> _Val = ::std:: move(*--_ULast);
        _Push_heap_by_index(_UFirst, --_Count, _Diff(0), ::std:: move(_Val), _Pass_fn(_Pred));
    }
}

template <class _RanIt>
constexpr void push_heap(_RanIt _First, _RanIt _Last) {
    
    ::std:: push_heap(_First, _Last, less<>{});
}


namespace ranges {
    
    template <random_access_iterator _It, class _Ty, class _Pr, class _Pj1, class _Pj2>
        requires sortable<_It, _Pr, _Pj1> && indirectly_writable<_It, _Ty>
            && indirect_strict_weak_order<_Pr, projected<_It, _Pj1>, projected<remove_reference_t<_Ty>*, _Pj2>>
    constexpr void _Push_heap_by_index(const _It _First, iter_difference_t<_It> _Hole,
        const iter_difference_t<_It> _Top, _Ty&& _Val, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
        
        
        while (_Top < _Hole) {
            const auto _Idx = static_cast<iter_difference_t<_It>>((_Hole - 1) >> 1); 
            if (!::std:: invoke(_Pred, ::std:: invoke(_Proj1, *(_First + _Idx)), ::std:: invoke(_Proj2, _Val))) {
                break;
            }

            
            *(_First + _Hole) = ::std::ranges:: iter_move(_First + _Idx);
            _Hole             = _Idx;
        }

        *(_First + _Hole) = ::std:: forward<_Ty>(_Val); 
    }

    class _Push_heap_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <random_access_iterator _It, sentinel_for<_It> _Se, class _Pr = ranges::less, class _Pj = identity>
            requires sortable<_It, _Pr, _Pj>
        constexpr _It operator()(_It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            auto _UFirst = _Get_unwrapped(::std:: move(_First));
            auto _ULast = _Get_final_iterator_unwrapped<_It>(_UFirst, ::std:: move(_Last));
            _Seek_wrapped(_First, _ULast);
            _Push_heap_unchecked(::std:: move(_UFirst), ::std:: move(_ULast), _Pass_fn(_Pred), _Pass_fn(_Proj));
            return _First;
        }

        template <random_access_range _Rng, class _Pr = ranges::less, class _Pj = identity>
            requires sortable<iterator_t<_Rng>, _Pr, _Pj>
        constexpr borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) const {
            if constexpr (common_range<_Rng>) {
                _Push_heap_unchecked(_Ubegin(_Range), _Uend(_Range), _Pass_fn(_Pred), _Pass_fn(_Proj));
                return ::std::ranges:: end(_Range);
            } else {
                auto _ULast = _Get_final_iterator_unwrapped(_Range);
                _Push_heap_unchecked(_Ubegin(_Range), _ULast, _Pass_fn(_Pred), _Pass_fn(_Proj));
                return _Rewrap_iterator(_Range, ::std:: move(_ULast));
            }
        }
        
    private:
        template <class _It, class _Pr, class _Pj>
        static constexpr void _Push_heap_unchecked(_It _First, _It _Last, _Pr _Pred, _Pj _Proj) {
            ;
            ;

            const auto _Count = _Last - _First;
            if (_Count < 2) {
                return;
            }

            --_Last;
            iter_value_t<_It> _Val = ::std::ranges:: iter_move(_Last);
            
            ::std::ranges:: _Push_heap_by_index(::std:: move(_First), _Count - 1, 0, ::std:: move(_Val), _Pred, _Proj, _Proj);
        }
    };

    inline constexpr _Push_heap_fn push_heap{_Not_quite_object::_Construct_tag{}};
} 
#line 5751 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _RanIt, class _Ty, class _Pr>
constexpr void _Pop_heap_hole_by_index(
    _RanIt _First, _Iter_diff_t<_RanIt> _Hole, _Iter_diff_t<_RanIt> _Bottom, _Ty&& _Val, _Pr _Pred) {
    
    ;

    using _Diff      = _Iter_diff_t<_RanIt>;
    const _Diff _Top = _Hole;
    _Diff _Idx       = _Hole;

    
    const _Diff _Max_sequence_non_leaf = (_Bottom - 1) >> 1; 
    while (_Idx < _Max_sequence_non_leaf) { 
        _Idx = 2 * _Idx + 2;
        if (static_cast<bool>(_Pred(*(_First + _Idx), *(_First + (_Idx - 1))))) {
            --_Idx;
        }
        *(_First + _Hole) = ::std:: move(*(_First + _Idx));
        _Hole             = _Idx;
    }

    if (_Idx == _Max_sequence_non_leaf && _Bottom % 2 == 0) { 
        *(_First + _Hole) = ::std:: move(*(_First + (_Bottom - 1)));
        _Hole             = _Bottom - 1;
    }

    _Push_heap_by_index(_First, _Hole, _Top, ::std:: forward<_Ty>(_Val), _Pred);
}

template <class _RanIt, class _Ty, class _Pr>
constexpr void _Pop_heap_hole_unchecked(_RanIt _First, _RanIt _Last, _RanIt _Dest, _Ty&& _Val, _Pr _Pred) {
    
    
    *_Dest      = ::std:: move(*_First);
    using _Diff = _Iter_diff_t<_RanIt>;
    _Pop_heap_hole_by_index(
        _First, static_cast<_Diff>(0), static_cast<_Diff>(_Last - _First), ::std:: forward<_Ty>(_Val), _Pred);
}

template <class _RanIt, class _Pr>
constexpr void _Pop_heap_unchecked(_RanIt _First, _RanIt _Last, _Pr _Pred) {
    
    if (2 <= _Last - _First) {
        --_Last;
        _Iter_value_t<_RanIt> _Val = ::std:: move(*_Last);
        _Pop_heap_hole_unchecked(_First, _Last, _Last, ::std:: move(_Val), _Pred);
    }
}

template <class _RanIt, class _Pr>
constexpr void pop_heap(_RanIt _First, _RanIt _Last, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Last);
    _Pop_heap_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last), _Pass_fn(_Pred));
}

template <class _RanIt>
constexpr void pop_heap(_RanIt _First, _RanIt _Last) {
    
    ::std:: pop_heap(_First, _Last, less<>{});
}


namespace ranges {
    
    template <random_access_iterator _It, class _Ty, class _Pr, class _Pj1, class _Pj2>
        requires sortable<_It, _Pr, _Pj1> && indirectly_writable<_It, _Ty>
            && indirect_strict_weak_order<_Pr, projected<_It, _Pj1>, projected<remove_reference_t<_Ty>*, _Pj2>>
    constexpr void _Pop_heap_hole_by_index(_It _First, iter_difference_t<_It> _Hole,
        const iter_difference_t<_It> _Bottom, _Ty&& _Val, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
        
        
        ;
        ;

        using _Diff      = iter_difference_t<_It>;
        const _Diff _Top = _Hole;
        _Diff _Idx       = _Hole;

        
        const _Diff _Max_sequence_non_leaf = (_Bottom - 1) >> 1; 
        while (_Idx < _Max_sequence_non_leaf) { 
            _Idx      = 2 * _Idx + 2;
            auto _Mid = _First + _Idx;
            if (::std:: invoke(_Pred, ::std:: invoke(_Proj1, *_Mid), ::std:: invoke(_Proj1, *::std::ranges:: prev(_Mid)))) {
                --_Idx;
                --_Mid;
            }
            *(_First + _Hole) = ::std::ranges:: iter_move(_Mid);
            _Hole             = _Idx;
        }

        if (_Idx == _Max_sequence_non_leaf && _Bottom % 2 == 0) { 
            *(_First + _Hole) = ::std::ranges:: iter_move(_First + (_Bottom - 1));
            _Hole             = _Bottom - 1;
        }

        ::std::ranges:: _Push_heap_by_index(::std:: move(_First), _Hole, _Top, ::std:: forward<_Ty>(_Val), _Pred, _Proj1, _Proj2);
    }

    
    template <random_access_iterator _It, class _Ty, class _Pr, class _Pj1, class _Pj2>
        requires sortable<_It, _Pr, _Pj1> && indirectly_writable<_It, _Ty>
            && indirect_strict_weak_order<_Pr, projected<_It, _Pj1>, projected<remove_reference_t<_Ty>*, _Pj2>>
    constexpr void _Pop_heap_hole_unchecked(
        _It _First, const _It _Last, const _It _Dest, _Ty&& _Val, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
        
        
        ;
        ;

        *_Dest            = ::std::ranges:: iter_move(_First);
        const auto _Count = _Last - _First;
        ::std::ranges:: _Pop_heap_hole_by_index(::std:: move(_First), 0, _Count, ::std:: forward<_Ty>(_Val), _Pred, _Proj1, _Proj2);
    }

    
    template <random_access_iterator _It, class _Pr, class _Pj>
        requires sortable<_It, _Pr, _Pj>
    constexpr void _Pop_heap_unchecked(_It _First, _It _Last, _Pr _Pred, _Pj _Proj) {
        
        
        if (_Last - _First < 2) {
            return;
        }

        --_Last;
        iter_value_t<_It> _Val = ::std::ranges:: iter_move(_Last);
        
        ::std::ranges:: _Pop_heap_hole_unchecked(::std:: move(_First), _Last, _Last, ::std:: move(_Val), _Pred, _Proj, _Proj);
    }

    class _Pop_heap_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <random_access_iterator _It, sentinel_for<_It> _Se, class _Pr = ranges::less, class _Pj = identity>
            requires sortable<_It, _Pr, _Pj>
        constexpr _It operator()(_It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            auto _UFirst = _Get_unwrapped(::std:: move(_First));
            auto _ULast  = _Get_final_iterator_unwrapped<_It>(_UFirst, ::std:: move(_Last));
            _Seek_wrapped(_First, _ULast);
            ::std::ranges:: _Pop_heap_unchecked(::std:: move(_UFirst), ::std:: move(_ULast), _Pass_fn(_Pred), _Pass_fn(_Proj));
            return _First;
        }

        template <random_access_range _Rng, class _Pr = ranges::less, class _Pj = identity>
            requires sortable<iterator_t<_Rng>, _Pr, _Pj>
        constexpr borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) const {
            if constexpr (common_range<_Rng>) {
                ::std::ranges:: _Pop_heap_unchecked(_Ubegin(_Range), _Uend(_Range), _Pass_fn(_Pred), _Pass_fn(_Proj));
                return ::std::ranges:: end(_Range);
            } else {
                auto _ULast = _Get_final_iterator_unwrapped(_Range);
                ::std::ranges:: _Pop_heap_unchecked(_Ubegin(_Range), _ULast, _Pass_fn(_Pred), _Pass_fn(_Proj));
                return _Rewrap_iterator(_Range, ::std:: move(_ULast));
            }
        }
        
    };

    inline constexpr _Pop_heap_fn pop_heap{_Not_quite_object::_Construct_tag{}};
} 
#line 5921 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _RanIt, class _Pr>
constexpr void _Make_heap_unchecked(_RanIt _First, _RanIt _Last, _Pr _Pred) {
    
    using _Diff   = _Iter_diff_t<_RanIt>;
    _Diff _Bottom = _Last - _First;
    for (_Diff _Hole = _Bottom >> 1; _Hole > 0;) { 
        
        --_Hole;
        _Iter_value_t<_RanIt> _Val = ::std:: move(*(_First + _Hole));
        _Pop_heap_hole_by_index(_First, _Hole, _Bottom, ::std:: move(_Val), _Pred);
    }
}

template <class _RanIt, class _Pr>
constexpr void make_heap(_RanIt _First, _RanIt _Last, _Pr _Pred) { 
    _Adl_verify_range(_First, _Last);
    _Make_heap_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last), _Pass_fn(_Pred));
}

template <class _RanIt>
constexpr void make_heap(_RanIt _First, _RanIt _Last) { 
    ::std:: make_heap(_First, _Last, less<>{});
}


namespace ranges {
    
    template <random_access_iterator _It, class _Pr, class _Pj>
        requires sortable<_It, _Pr, _Pj>
    constexpr void _Make_heap_common(_It _First, _It _Last, _Pr _Pred, _Pj _Proj) {
        
        
        using _Diff         = iter_difference_t<_It>;
        const _Diff _Bottom = _Last - _First;
        for (_Diff _Hole = _Bottom >> 1; _Hole > 0;) { 
            
            --_Hole;
            iter_value_t<_It> _Val = ::std::ranges:: iter_move(_First + _Hole);
            
            ::std::ranges:: _Pop_heap_hole_by_index(_First, _Hole, _Bottom, ::std:: move(_Val), _Pred, _Proj, _Proj);
        }
    }

    class _Make_heap_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <random_access_iterator _It, sentinel_for<_It> _Se, class _Pr = ranges::less, class _Pj = identity>
            requires sortable<_It, _Pr, _Pj>
        constexpr _It operator()(_It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) const {
            
            _Adl_verify_range(_First, _Last);
            auto _UFirst = _Get_unwrapped(::std:: move(_First));
            auto _ULast  = _Get_final_iterator_unwrapped<_It>(_UFirst, ::std:: move(_Last));
            _Seek_wrapped(_First, _ULast);
            _Make_heap_common(::std:: move(_UFirst), ::std:: move(_ULast), _Pass_fn(_Pred), _Pass_fn(_Proj));
            return _First;
        }

        
        template <random_access_range _Rng, class _Pr = ranges::less, class _Pj = identity>
            requires sortable<iterator_t<_Rng>, _Pr, _Pj>
        constexpr borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) const {
            
            if constexpr (common_range<_Rng>) {
                _Make_heap_common(_Ubegin(_Range), _Uend(_Range), _Pass_fn(_Pred), _Pass_fn(_Proj));
                return ::std::ranges:: end(_Range);
            } else {
                auto _ULast = _Get_final_iterator_unwrapped(_Range);
                _Make_heap_common(_Ubegin(_Range), _ULast, _Pass_fn(_Pred), _Pass_fn(_Proj));
                return _Rewrap_iterator(_Range, ::std:: move(_ULast));
            }
        }
    };

    inline constexpr _Make_heap_fn make_heap{_Not_quite_object::_Construct_tag{}};
} 
#line 6001 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _RanIt, class _Pr>
constexpr _RanIt _Is_heap_until_unchecked(_RanIt _First, _RanIt _Last, _Pr _Pred) {
    
    using _Diff       = _Iter_diff_t<_RanIt>;
    const _Diff _Size = _Last - _First;
    for (_Diff _Off = 1; _Off < _Size; ++_Off) {
        if (static_cast<bool>(_Pred(*(_First + ((_Off - 1) >> 1)), *(_First + _Off)))) { 
            return _First + _Off;
        }
    }

    return _Last;
}

template <class _RanIt, class _Pr>
[[nodiscard]] constexpr _RanIt is_heap_until(_RanIt _First, _RanIt _Last, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Last);
    _Seek_wrapped(_First, _Is_heap_until_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last), _Pass_fn(_Pred)));
    return _First;
}

template <class _RanIt, class _Pr>
[[nodiscard]] constexpr bool is_heap(_RanIt _First, _RanIt _Last, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Last);
    const auto _UFirst = _Get_unwrapped(_First);
    const auto _ULast  = _Get_unwrapped(_Last);
    return _Is_heap_until_unchecked(_UFirst, _ULast, _Pass_fn(_Pred)) == _ULast;
}

template <class _RanIt>
[[nodiscard]] constexpr _RanIt is_heap_until(_RanIt _First, _RanIt _Last) {
    
    return ::std:: is_heap_until(_First, _Last, less<>{});
}

template <class _RanIt>
[[nodiscard]] constexpr bool is_heap(_RanIt _First, _RanIt _Last) { 
    return ::std:: is_heap(_First, _Last, less<>{});
}


template <class _ExPo, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _RanIt is_heap_until(_ExPo&& _Exec, _RanIt _First, _RanIt _Last, _Pr _Pred) noexcept; 

template <class _ExPo, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] bool is_heap(_ExPo&& _Exec, _RanIt _First, _RanIt _Last, _Pr _Pred) noexcept  {
    
    return ::std:: is_heap_until(::std:: forward<_ExPo>(_Exec), _First, _Last, _Pass_fn(_Pred)) == _Last;
}

template <class _ExPo, class _RanIt, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _RanIt is_heap_until(_ExPo&& _Exec, _RanIt _First, _RanIt _Last) noexcept  {
    
    return ::std:: is_heap_until(::std:: forward<_ExPo>(_Exec), _First, _Last, less{});
}

template <class _ExPo, class _RanIt, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] bool is_heap(_ExPo&& _Exec, _RanIt _First, _RanIt _Last) noexcept  {
    
    return ::std:: is_heap(::std:: forward<_ExPo>(_Exec), _First, _Last, less{});
}


namespace ranges {
    template <class _It, class _Pr, class _Pj>
    [[nodiscard]] constexpr _It _Is_heap_until_unchecked(
        _It _First, const iter_difference_t<_It> _Size, _Pr _Pred, _Pj _Proj) {
        
        ;
        ;

        if (_Size == 0) {
            return _First;
        }

        using _Diff = iter_difference_t<_It>;
        _Diff _Off  = 1;
        for (; _Off < _Size; ++_Off) {
            const auto _Mid1 = _First + static_cast<_Diff>((_Off - 1) >> 1); 
            auto _Mid2       = _First + _Off;
            if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Mid1), ::std:: invoke(_Proj, *_Mid2))) {
                return _Mid2;
            }
        }

        return _First + _Off;
    }

    class _Is_heap_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <random_access_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
            indirect_strict_weak_order<projected<_It, _Pj>> _Pr = ranges::less>
        [[nodiscard]] constexpr bool operator()(_It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            auto _UFirst      = _Get_unwrapped(::std:: move(_First));
            const auto _ULast = _Get_unwrapped(::std:: move(_Last));
            const auto _Size  = ::std::ranges:: distance(_UFirst, _ULast);
            const auto _UResult =
                ::std::ranges:: _Is_heap_until_unchecked(::std:: move(_UFirst), _Size, _Pass_fn(_Pred), _Pass_fn(_Proj));
            return _UResult == _ULast;
        }

        template <random_access_range _Rng, class _Pj = identity,
            indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
        [[nodiscard]] constexpr bool operator()(_Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) const {
            const auto _Size = ::std::ranges:: distance(_Range);
            const auto _UResult =
                ::std::ranges:: _Is_heap_until_unchecked(_Ubegin(_Range), _Size, _Pass_fn(_Pred), _Pass_fn(_Proj));
            return _UResult == _Uend(_Range);
        }
    };

    inline constexpr _Is_heap_fn is_heap{_Not_quite_object::_Construct_tag{}};

    class _Is_heap_until_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <random_access_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
            indirect_strict_weak_order<projected<_It, _Pj>> _Pr = ranges::less>
        [[nodiscard]] constexpr _It operator()(_It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            auto _UFirst     = _Get_unwrapped(::std:: move(_First));
            const auto _Size = ::std::ranges:: distance(_UFirst, _Get_unwrapped(::std:: move(_Last)));
            auto _UResult =
                ::std::ranges:: _Is_heap_until_unchecked(::std:: move(_UFirst), _Size, _Pass_fn(_Pred), _Pass_fn(_Proj));
            _Seek_wrapped(_First, ::std:: move(_UResult));
            return _First;
        }

        template <random_access_range _Rng, class _Pj = identity,
            indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
        [[nodiscard]] constexpr borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) const {
            const auto _Size = ::std::ranges:: distance(_Range);
            auto _UResult = ::std::ranges:: _Is_heap_until_unchecked(_Ubegin(_Range), _Size, _Pass_fn(_Pred), _Pass_fn(_Proj));
            return _Rewrap_iterator(_Range, ::std:: move(_UResult));
        }
    };

    inline constexpr _Is_heap_until_fn is_heap_until{_Not_quite_object::_Construct_tag{}};
} 
#line 6148 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
#line 6149 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _RanIt, class _Pr>
constexpr void _Sort_heap_unchecked(_RanIt _First, _RanIt _Last, _Pr _Pred) {
    
    for (; _Last - _First >= 2; --_Last) {
        _Pop_heap_unchecked(_First, _Last, _Pred);
    }
}

template <class _RanIt, class _Pr>
constexpr void sort_heap(_RanIt _First, _RanIt _Last, _Pr _Pred) { 
    _Adl_verify_range(_First, _Last);
    const auto _UFirst = _Get_unwrapped(_First);
    const auto _ULast  = _Get_unwrapped(_Last);


#line 6169 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
    _Sort_heap_unchecked(_UFirst, _ULast, _Pass_fn(_Pred));
}

template <class _RanIt>
constexpr void sort_heap(_RanIt _First, _RanIt _Last) { 
    ::std:: sort_heap(_First, _Last, less<>{});
}


namespace ranges {
    
    template <random_access_iterator _It, class _Pr, class _Pj>
        requires sortable<_It, _Pr, _Pj>
    constexpr void _Sort_heap_common(const _It _First, _It _Last, _Pr _Pred, _Pj _Proj) {
        
        
        for (; _Last - _First >= 2; --_Last) {
            ::std::ranges:: _Pop_heap_unchecked(_First, _Last, _Pred, _Proj);
        }
    }

    class _Sort_heap_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <random_access_iterator _It, sentinel_for<_It> _Se, class _Pr = ranges::less, class _Pj = identity>
            requires sortable<_It, _Pr, _Pj>
        constexpr _It operator()(_It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) const {
            
            _Adl_verify_range(_First, _Last);
            auto _UFirst = _Get_unwrapped(::std:: move(_First));
            auto _ULast  = _Get_final_iterator_unwrapped<_It>(_UFirst, ::std:: move(_Last));
            _Seek_wrapped(_First, _ULast);
            _Sort_heap_common(::std:: move(_UFirst), ::std:: move(_ULast), _Pass_fn(_Pred), _Pass_fn(_Proj));
            return _First;
        }

        
        template <random_access_range _Rng, class _Pr = ranges::less, class _Pj = identity>
            requires sortable<iterator_t<_Rng>, _Pr, _Pj>
        constexpr borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) const {
            
            if constexpr (common_range<_Rng>) {
                _Sort_heap_common(_Ubegin(_Range), _Uend(_Range), _Pass_fn(_Pred), _Pass_fn(_Proj));
                return ::std::ranges:: end(_Range);
            } else {
                auto _ULast = _Get_final_iterator_unwrapped(_Range);
                _Sort_heap_common(_Ubegin(_Range), _ULast, _Pass_fn(_Pred), _Pass_fn(_Proj));
                return _Rewrap_iterator(_Range, ::std:: move(_ULast));
            }
        }
    };

    inline constexpr _Sort_heap_fn sort_heap{_Not_quite_object::_Construct_tag{}};

    template <class _It, class _Ty, class _Pr, class _Pj>
    [[nodiscard]] constexpr _It _Lower_bound_unchecked(
        _It _First, iter_difference_t<_It> _Count, const _Ty& _Val, _Pr _Pred, _Pj _Proj) {
        ;
        ;

        using _Diff = iter_difference_t<_It>;

        while (_Count > 0) { 
            const auto _Half = static_cast<_Diff>(_Count / 2);
            auto _Mid        = ::std::ranges:: next(_First, _Half);
            if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Mid), _Val)) { 
                _First = ::std:: move(_Mid);
                ++_First;
                _Count -= static_cast<_Diff>(_Half + 1);
            } else { 
                _Count = _Half;
            }
        }

        return _First;
    }

    class _Lower_bound_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <forward_iterator _It, sentinel_for<_It> _Se, class _Ty, class _Pj = identity,
            indirect_strict_weak_order<const _Ty*, projected<_It, _Pj>> _Pr = ranges::less>
        [[nodiscard]] constexpr _It operator()(
            _It _First, _Se _Last, const _Ty& _Val, _Pr _Pred = {}, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            auto _UFirst      = _Get_unwrapped(::std:: move(_First));
            const auto _Count = ::std::ranges:: distance(_UFirst, _Get_unwrapped(::std:: move(_Last)));
            _UFirst =
                ::std::ranges:: _Lower_bound_unchecked(::std:: move(_UFirst), _Count, _Val, _Pass_fn(_Pred), _Pass_fn(_Proj));
            _Seek_wrapped(_First, ::std:: move(_UFirst));
            return _First;
        }

        template <forward_range _Rng, class _Ty, class _Pj = identity,
            indirect_strict_weak_order<const _Ty*, projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
        [[nodiscard]] constexpr borrowed_iterator_t<_Rng> operator()(
            _Rng&& _Range, const _Ty& _Val, _Pr _Pred = {}, _Pj _Proj = {}) const {
            const auto _Count = ::std::ranges:: distance(_Range);
            auto _UResult =
                ::std::ranges:: _Lower_bound_unchecked(_Ubegin(_Range), _Count, _Val, _Pass_fn(_Pred), _Pass_fn(_Proj));
            auto _Result = ::std::ranges:: begin(_Range);
            _Seek_wrapped(_Result, ::std:: move(_UResult));
            return _Result;
        }
    };

    inline constexpr _Lower_bound_fn lower_bound{_Not_quite_object::_Construct_tag{}};
} 
#line 6281 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _FwdIt, class _Ty, class _Pr>
[[nodiscard]] constexpr _FwdIt upper_bound(_FwdIt _First, _FwdIt _Last, const _Ty& _Val, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst                = _Get_unwrapped(_First);
    _Iter_diff_t<_FwdIt> _Count = ::std:: distance(_UFirst, _Get_unwrapped(_Last));

    while (0 < _Count) { 
        _Iter_diff_t<_FwdIt> _Count2 = _Count / 2;
        const auto _UMid             = ::std:: next(_UFirst, _Count2);
        if (_Pred(_Val, *_UMid)) {
            _Count = _Count2;
        } else { 
            _UFirst = _Next_iter(_UMid);
            _Count -= _Count2 + 1;
        }
    }

    _Seek_wrapped(_First, _UFirst);
    return _First;
}

template <class _FwdIt, class _Ty>
[[nodiscard]] constexpr _FwdIt upper_bound(_FwdIt _First, _FwdIt _Last, const _Ty& _Val) {
    
    return ::std:: upper_bound(_First, _Last, _Val, less<>{});
}


namespace ranges {
    template <class _It, class _Ty, class _Pr, class _Pj>
    [[nodiscard]] constexpr _It _Upper_bound_unchecked(
        _It _First, iter_difference_t<_It> _Count, const _Ty& _Val, _Pr _Pred, _Pj _Proj) {
        ;
        ;

        using _Diff = iter_difference_t<_It>;

        while (_Count > 0) { 
            const auto _Half = static_cast<_Diff>(_Count / 2);
            auto _Mid        = ::std::ranges:: next(_First, _Half);
            if (::std:: invoke(_Pred, _Val, ::std:: invoke(_Proj, *_Mid))) {
                _Count = _Half;
            } else { 
                _First = ::std:: move(_Mid);
                ++_First;
                _Count -= static_cast<_Diff>(_Half + 1);
            }
        }

        return _First;
    }

    class _Upper_bound_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <forward_iterator _It, sentinel_for<_It> _Se, class _Ty, class _Pj = identity,
            indirect_strict_weak_order<const _Ty*, projected<_It, _Pj>> _Pr = ranges::less>
        [[nodiscard]] constexpr _It operator()(
            _It _First, _Se _Last, const _Ty& _Val, _Pr _Pred = {}, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            auto _UFirst      = _Get_unwrapped(::std:: move(_First));
            const auto _Count = ::std::ranges:: distance(_UFirst, _Get_unwrapped(::std:: move(_Last)));
            _UFirst = _Upper_bound_unchecked(::std:: move(_UFirst), _Count, _Val, _Pass_fn(_Pred), _Pass_fn(_Proj));
            _Seek_wrapped(_First, ::std:: move(_UFirst));
            return _First;
        }

        template <forward_range _Rng, class _Ty, class _Pj = identity,
            indirect_strict_weak_order<const _Ty*, projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
        [[nodiscard]] constexpr borrowed_iterator_t<_Rng> operator()(
            _Rng&& _Range, const _Ty& _Val, _Pr _Pred = {}, _Pj _Proj = {}) const {
            const auto _Count = ::std::ranges:: distance(_Range);
            auto _UResult     = _Upper_bound_unchecked(_Ubegin(_Range), _Count, _Val, _Pass_fn(_Pred), _Pass_fn(_Proj));
            auto _Result      = ::std::ranges:: begin(_Range);
            _Seek_wrapped(_Result, ::std:: move(_UResult));
            return _Result;
        }
    };

    inline constexpr _Upper_bound_fn upper_bound{_Not_quite_object::_Construct_tag{}};
} 
#line 6366 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _FwdIt, class _Ty, class _Pr>
[[nodiscard]] constexpr pair<_FwdIt, _FwdIt> equal_range(_FwdIt _First, _FwdIt _Last, const _Ty& _Val, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);

    using _Diff  = _Iter_diff_t<_FwdIt>;
    _Diff _Count = ::std:: distance(_UFirst, _ULast);

    for (;;) { 
        if (_Count <= 0) {
            _Seek_wrapped(_Last, _UFirst); 
            _Seek_wrapped(_First, _UFirst);
            break;
        }

        _Diff _Count2    = _Count / 2;
        const auto _UMid = ::std:: next(_UFirst, _Count2);
        if (static_cast<bool>(_Pred(*_UMid, _Val))) { 
            _UFirst = _Next_iter(_UMid);
            _Count -= _Count2 + 1;
        } else if (_Pred(_Val, *_UMid)) {
            _Count = _Count2; 
        } else { 
            auto _UFirst2 = ::std:: lower_bound(_UFirst, _UMid, _Val, _Pass_fn(_Pred));
            ::std:: advance(_UFirst, _Count);
            auto _ULast2 = ::std:: upper_bound(_Next_iter(_UMid), _UFirst, _Val, _Pass_fn(_Pred));
            _Seek_wrapped(_Last, _ULast2);
            _Seek_wrapped(_First, _UFirst2);
            break;
        }
    }

    return {_First, _Last};
}

template <class _FwdIt, class _Ty>
[[nodiscard]] constexpr pair<_FwdIt, _FwdIt> equal_range(_FwdIt _First, _FwdIt _Last, const _Ty& _Val) {
    
    return ::std:: equal_range(_First, _Last, _Val, less<>{});
}


namespace ranges {
    class _Equal_range_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <forward_iterator _It, sentinel_for<_It> _Se, class _Ty, class _Pj = identity,
            indirect_strict_weak_order<const _Ty*, projected<_It, _Pj>> _Pr = ranges::less>
        [[nodiscard]] constexpr subrange<_It> operator()(
            _It _First, _Se _Last, const _Ty& _Val, _Pr _Pred = {}, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            auto _UFirst      = _Get_unwrapped(::std:: move(_First));
            const auto _Count = ::std::ranges:: distance(_UFirst, _Get_unwrapped(::std:: move(_Last)));
            auto _UResult = _Equal_range_unchecked(::std:: move(_UFirst), _Count, _Val, _Pass_fn(_Pred), _Pass_fn(_Proj));
            return _Rewrap_subrange<subrange<_It>>(_First, ::std:: move(_UResult));
        }

        template <forward_range _Rng, class _Ty, class _Pj = identity,
            indirect_strict_weak_order<const _Ty*, projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
        [[nodiscard]] constexpr borrowed_subrange_t<_Rng> operator()(
            _Rng&& _Range, const _Ty& _Val, _Pr _Pred = {}, _Pj _Proj = {}) const {
            const auto _Count = ::std::ranges:: distance(_Range);
            auto _UResult     = _Equal_range_unchecked(_Ubegin(_Range), _Count, _Val, _Pass_fn(_Pred), _Pass_fn(_Proj));
            auto _Result      = ::std::ranges:: begin(_Range);
            return _Rewrap_subrange<borrowed_subrange_t<_Rng>>(_Result, ::std:: move(_UResult));
        }

    private:
        template <class _It, class _Ty, class _Pr, class _Pj>
        [[nodiscard]] static constexpr subrange<_It> _Equal_range_unchecked(
            _It _First, iter_difference_t<_It> _Count, const _Ty& _Val, _Pr _Pred, _Pj _Proj) {
            ;
            ;

            using _Diff = iter_difference_t<_It>;

            while (_Count > 0) { 
                const auto _Half = static_cast<_Diff>(_Count / 2);
                auto _Mid        = ::std::ranges:: next(_First, _Half);

                if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Mid), _Val)) { 
                    _First = ::std:: move(_Mid);
                    ++_First;
                    _Count -= static_cast<_Diff>(_Half + 1);
                } else if (::std:: invoke(_Pred, _Val, ::std:: invoke(_Proj, *_Mid))) {
                    _Count = _Half; 
                } else { 
                    _First = ::std::ranges:: _Lower_bound_unchecked(::std:: move(_First), _Half, _Val, _Pred, _Proj);
                    ++_Mid;
                    _Count -= static_cast<_Diff>(_Half + 1);
                    _Mid = ::std::ranges:: _Upper_bound_unchecked(::std:: move(_Mid), _Count, _Val, _Pred, _Proj);
                    return {::std:: move(_First), ::std:: move(_Mid)};
                }
            }

            return {_First, _First};
        }
    };

    inline constexpr _Equal_range_fn equal_range{_Not_quite_object::_Construct_tag{}};
} 
#line 6472 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _FwdIt, class _Ty, class _Pr>
[[nodiscard]] constexpr bool binary_search(_FwdIt _First, _FwdIt _Last, const _Ty& _Val, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    _UFirst           = ::std:: lower_bound(_UFirst, _ULast, _Val, _Pass_fn(_Pred));
    return _UFirst != _ULast && !_Pred(_Val, *_UFirst);
}

template <class _FwdIt, class _Ty>
[[nodiscard]] constexpr bool binary_search(_FwdIt _First, _FwdIt _Last, const _Ty& _Val) {
    
    return ::std:: binary_search(_First, _Last, _Val, less<>{});
}


namespace ranges {
    class _Binary_search_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <forward_iterator _It, sentinel_for<_It> _Se, class _Ty, class _Pj = identity,
            indirect_strict_weak_order<const _Ty*, projected<_It, _Pj>> _Pr = ranges::less>
        [[nodiscard]] constexpr bool operator()(
            _It _First, _Se _Last, const _Ty& _Val, _Pr _Pred = {}, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            auto _UFirst      = _Get_unwrapped(::std:: move(_First));
            const auto _ULast = _Get_unwrapped(::std:: move(_Last));
            const auto _Count = ::std::ranges:: distance(_UFirst, _ULast);
            _UFirst =
                ::std::ranges:: _Lower_bound_unchecked(::std:: move(_UFirst), _Count, _Val, _Pass_fn(_Pred), _Pass_fn(_Proj));
            return _UFirst != _ULast && !::std:: invoke(_Pred, _Val, ::std:: invoke(_Proj, *_UFirst));
        }

        template <forward_range _Rng, class _Ty, class _Pj = identity,
            indirect_strict_weak_order<const _Ty*, projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
        [[nodiscard]] constexpr bool operator()(_Rng&& _Range, const _Ty& _Val, _Pr _Pred = {}, _Pj _Proj = {}) const {
            const auto _Count = ::std::ranges:: distance(_Range);
            const auto _UFirst =
                ::std::ranges:: _Lower_bound_unchecked(_Ubegin(_Range), _Count, _Val, _Pass_fn(_Pred), _Pass_fn(_Proj));
            return _UFirst != _Uend(_Range) && !::std:: invoke(_Pred, _Val, ::std:: invoke(_Proj, *_UFirst));
        }
    };

    inline constexpr _Binary_search_fn binary_search{_Not_quite_object::_Construct_tag{}};
} 
#line 6521 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

[[nodiscard]] constexpr _Distance_unknown _Idl_dist_add(_Distance_unknown, _Distance_unknown) {
    return {};
}

template <class _Diff1>
[[nodiscard]] constexpr _Distance_unknown _Idl_dist_add(_Diff1, _Distance_unknown) {
    return {};
}

template <class _Diff2>
[[nodiscard]] constexpr _Distance_unknown _Idl_dist_add(_Distance_unknown, _Diff2) {
    return {};
}

template <class _Diff1, class _Diff2>
[[nodiscard]] constexpr auto _Idl_dist_add(_Diff1 _Lhs, _Diff2 _Rhs) {
    return _Lhs + _Rhs;
}

template <class _InIt1, class _InIt2, class _OutIt, class _Pr>
constexpr _OutIt merge(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred) {
    
    _Adl_verify_range(_First1, _Last1);
    _Adl_verify_range(_First2, _Last2);
    auto _UFirst1      = _Get_unwrapped(_First1);
    const auto _ULast1 = _Get_unwrapped(_Last1);
    auto _UFirst2      = _Get_unwrapped(_First2);
    const auto _ULast2 = _Get_unwrapped(_Last2);
    ;
    ;
    const auto _Count1 = _Idl_distance<_InIt1>(_UFirst1, _ULast1);
    const auto _Count2 = _Idl_distance<_InIt2>(_UFirst2, _ULast2);
    auto _UDest        = _Get_unwrapped_n(_Dest, _Idl_dist_add(_Count1, _Count2));
    if (_UFirst1 != _ULast1 && _UFirst2 != _ULast2) {
        for (;;) {
            if (static_cast<bool>(_Pred(*_UFirst2, *_UFirst1))) {
                *_UDest = *_UFirst2;
                ++_UDest;
                ++_UFirst2;

                if (_UFirst2 == _ULast2) {
                    break;
                }
            } else {
                *_UDest = *_UFirst1;
                ++_UDest;
                ++_UFirst1;

                if (_UFirst1 == _ULast1) {
                    break;
                }
            }
        }
    }

    _UDest = _Copy_unchecked(_UFirst1, _ULast1, _UDest); 
    _Seek_wrapped(_Dest, _Copy_unchecked(_UFirst2, _ULast2, _UDest));
    return _Dest;
}

template <class _InIt1, class _InIt2, class _OutIt>
constexpr _OutIt merge(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest) {
    
    return ::std:: merge(_First1, _Last1, _First2, _Last2, _Dest, less<>{});
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt3 merge(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _FwdIt3 _Dest,
    _Pr _Pred) noexcept  {
    
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt3>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: merge(_First1, _Last1, _First2, _Last2, _Dest, _Pass_fn(_Pred));
}

template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt3 merge(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _FwdIt3 _Dest) noexcept
 {
    
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt3>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: merge(_First1, _Last1, _First2, _Last2, _Dest);
}


namespace ranges {
    template <class _In1, class _In2, class _Out>
    using merge_result = in_in_out_result<_In1, _In2, _Out>;

    class _Merge_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2,
            weakly_incrementable _Out, class _Pr = ranges::less, class _Pj1 = identity, class _Pj2 = identity>
            requires mergeable<_It1, _It2, _Out, _Pr, _Pj1, _Pj2>
        constexpr merge_result<_It1, _It2, _Out> operator()(_It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2,
            _Out _Result, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            
            _Adl_verify_range(_First1, _Last1);
            _Adl_verify_range(_First2, _Last2);
            auto _UResult = _Merge_unchecked(_Get_unwrapped(::std:: move(_First1)), _Get_unwrapped(::std:: move(_Last1)),
                _Get_unwrapped(::std:: move(_First2)), _Get_unwrapped(::std:: move(_Last2)), ::std:: move(_Result),
                _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
            _Seek_wrapped(_First1, ::std:: move(_UResult.in1));
            _Seek_wrapped(_First2, ::std:: move(_UResult.in2));
            return {::std:: move(_First1), ::std:: move(_First2), ::std:: move(_UResult.out)};
        }

        
        template <input_range _Rng1, input_range _Rng2, weakly_incrementable _Out, class _Pr = ranges::less,
            class _Pj1 = identity, class _Pj2 = identity>
            requires mergeable<iterator_t<_Rng1>, iterator_t<_Rng2>, _Out, _Pr, _Pj1, _Pj2>
        constexpr merge_result<borrowed_iterator_t<_Rng1>, borrowed_iterator_t<_Rng2>, _Out> operator()(
            _Rng1&& _Range1, _Rng2&& _Range2, _Out _Result, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            
            auto _First1 = ::std::ranges:: begin(_Range1);
            auto _First2 = ::std::ranges:: begin(_Range2);
            auto _UResult =
                _Merge_unchecked(_Get_unwrapped(::std:: move(_First1)), _Uend(_Range1), _Get_unwrapped(::std:: move(_First2)),
                    _Uend(_Range2), ::std:: move(_Result), _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
            _Seek_wrapped(_First1, ::std:: move(_UResult.in1));
            _Seek_wrapped(_First2, ::std:: move(_UResult.in2));
            return {::std:: move(_First1), ::std:: move(_First2), ::std:: move(_UResult.out)};
        }

    private:
        template <class _It1, class _Se1, class _It2, class _Se2, class _Out, class _Pr, class _Pj1, class _Pj2>
        [[nodiscard]] static constexpr merge_result<_It1, _It2, _Out> _Merge_unchecked(_It1 _First1, const _Se1 _Last1,
            _It2 _First2, const _Se2 _Last2, _Out _Result, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
            ;
            ;
            ;
            ;
            ;
            ;

            for (;; ++_Result) {
                if (_First1 == _Last1) {
                    auto _Copy_result =
                        ::std::ranges:: _Copy_unchecked(::std:: move(_First2), ::std:: move(_Last2), ::std:: move(_Result));
                    return {::std:: move(_First1), ::std:: move(_Copy_result.in), ::std:: move(_Copy_result.out)};
                }

                if (_First2 == _Last2) {
                    auto _Copy_result =
                        ::std::ranges:: _Copy_unchecked(::std:: move(_First1), ::std:: move(_Last1), ::std:: move(_Result));
                    return {::std:: move(_Copy_result.in), ::std:: move(_First2), ::std:: move(_Copy_result.out)};
                }

                if (::std:: invoke(_Pred, ::std:: invoke(_Proj2, *_First2), ::std:: invoke(_Proj1, *_First1))) {
                    *_Result = *_First2;
                    ++_First2;
                } else {
                    *_Result = *_First1;
                    ++_First1;
                }
            }
        }
    };

    inline constexpr _Merge_fn merge{_Not_quite_object::_Construct_tag{}};
} 
#line 6692 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
#line 6693 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


template <class _BidIt>
void _Rotate_one_right(_BidIt _First, _BidIt _Mid, _BidIt _Last) {
    
    
    _Iter_value_t<_BidIt> _Temp(::std:: move(*_Mid));
    _Move_backward_unchecked(_First, _Mid, _Last);
    *_First = ::std:: move(_Temp);
}

template <class _BidIt>
void _Rotate_one_left(_BidIt _First, _BidIt _Mid, _BidIt _Last) {
    
    
    _Iter_value_t<_BidIt> _Temp(::std:: move(*_First));
    *_Move_unchecked(_Mid, _Last, _First) = ::std:: move(_Temp);
}

template <class _BidIt, class _Pr>
void _Inplace_merge_buffer_left(
    _BidIt _First, _BidIt _Mid, _BidIt _Last, _Iter_value_t<_BidIt>* const _Temp_ptr, _Pr _Pred) {
    
    
    using _Ptr_ty = _Iter_value_t<_BidIt>*;
    _Uninitialized_backout<_Ptr_ty> _Backout{_Temp_ptr, _Uninitialized_move_unchecked(_First, _Mid, _Temp_ptr)};
    _Ptr_ty _Left_first      = _Temp_ptr;
    const _Ptr_ty _Left_last = _Backout._Last - 1; 
    *_First                  = ::std:: move(*_Mid); 
    ++_First;
    ++_Mid;
    for (;;) {
        if (_Pred(*_Mid, *_Left_first)) { 
            *_First = ::std:: move(*_Mid);
            ++_First;
            ++_Mid;
            if (_Mid == _Last) {
                _Move_unchecked(_Left_first, _Backout._Last, _First); 
                return;
            }
        } else { 
            *_First = ::std:: move(*_Left_first);
            ++_First;
            ++_Left_first;
            if (_Left_first == _Left_last) {
                
                *_Move_unchecked(_Mid, _Last, _First) = ::std:: move(*_Left_last);
                return;
            }
        }
    }
}

template <class _BidIt, class _Pr>
void _Inplace_merge_buffer_right(
    _BidIt _First, _BidIt _Mid, _BidIt _Last, _Iter_value_t<_BidIt>* const _Temp_ptr, _Pr _Pred) {
    
    
    using _Ptr_ty = _Iter_value_t<_BidIt>*;
    _Uninitialized_backout<_Ptr_ty> _Backout{_Temp_ptr, _Uninitialized_move_unchecked(_Mid, _Last, _Temp_ptr)};
    *--_Last                   = ::std:: move(*--_Mid); 
    const _Ptr_ty _Right_first = _Temp_ptr;
    _Ptr_ty _Right_last        = _Backout._Last - 1;
    --_Mid;
    for (;;) {
        if (_Pred(*_Right_last, *_Mid)) { 
            *--_Last = ::std:: move(*_Mid);
            if (_First == _Mid) {
                *--_Last = ::std:: move(*_Right_last); 
                _Move_backward_unchecked(_Right_first, _Right_last, _Last); 
                return;
            }

            --_Mid;
        } else { 
            *--_Last = ::std:: move(*_Right_last);
            --_Right_last;
            if (_Right_first == _Right_last) { 
                *--_Last = ::std:: move(*_Mid); 
                _Move_backward_unchecked(_First, _Mid, _Last);
                *_First = ::std:: move(*_Right_first);
                return;
            }
        }
    }
}

template <class _BidIt, class _Pr>
void _Buffered_inplace_merge_unchecked(_BidIt _First, _BidIt _Mid, _BidIt _Last, _Iter_diff_t<_BidIt> _Count1,
    _Iter_diff_t<_BidIt> _Count2, _Iter_value_t<_BidIt>* const _Temp_ptr, const ptrdiff_t _Capacity, _Pr _Pred);

template <class _BidIt, class _Pr>
void _Buffered_inplace_merge_divide_and_conquer2(_BidIt _First, _BidIt _Mid, _BidIt _Last, _Iter_diff_t<_BidIt> _Count1,
    _Iter_diff_t<_BidIt> _Count2, _Iter_value_t<_BidIt>* const _Temp_ptr, const ptrdiff_t _Capacity, _Pr _Pred,
    _BidIt _Firstn, _BidIt _Lastn, _Iter_diff_t<_BidIt> _Count1n, _Iter_diff_t<_BidIt> _Count2n) {
    
    using _Diff  = _Iter_diff_t<_BidIt>;
    _BidIt _Midn = _Buffered_rotate_unchecked(_Firstn, _Mid, _Lastn, static_cast<_Diff>(_Count1 - _Count1n), _Count2n,
        _Temp_ptr, _Capacity); 
    _Buffered_inplace_merge_unchecked(
        _First, _Firstn, _Midn, _Count1n, _Count2n, _Temp_ptr, _Capacity, _Pred); 
    _Buffered_inplace_merge_unchecked(_Midn, _Lastn, _Last, static_cast<_Diff>(_Count1 - _Count1n),
        static_cast<_Diff>(_Count2 - _Count2n), _Temp_ptr, _Capacity, _Pred);
}

template <class _BidIt, class _Pr>
void _Buffered_inplace_merge_divide_and_conquer(_BidIt _First, _BidIt _Mid, _BidIt _Last, _Iter_diff_t<_BidIt> _Count1,
    _Iter_diff_t<_BidIt> _Count2, _Iter_value_t<_BidIt>* const _Temp_ptr, const ptrdiff_t _Capacity, _Pr _Pred) {
    
    
    using _Diff = _Iter_diff_t<_BidIt>;
    if (_Count1 <= _Count2) {
        const _Diff _Count1n = _Count1 >> 1; 
        const _BidIt _Firstn = ::std:: next(_First, _Count1n);
        const _BidIt _Lastn  = ::std:: lower_bound(_Mid, _Last, *_Firstn, _Pred);
        _Buffered_inplace_merge_divide_and_conquer2(_First, _Mid, _Last, _Count1, _Count2, _Temp_ptr, _Capacity, _Pred,
            _Firstn, _Lastn, _Count1n, ::std:: distance(_Mid, _Lastn));
    } else {
        const _Diff _Count2n = _Count2 >> 1; 
        const _BidIt _Lastn  = ::std:: next(_Mid, _Count2n);
        const _BidIt _Firstn = ::std:: upper_bound(_First, _Mid, *_Lastn, _Pred);
        _Buffered_inplace_merge_divide_and_conquer2(_First, _Mid, _Last, _Count1, _Count2, _Temp_ptr, _Capacity, _Pred,
            _Firstn, _Lastn, ::std:: distance(_First, _Firstn), _Count2n);
    }
}

template <class _BidIt, class _Pr>
void _Buffered_inplace_merge_unchecked_impl(_BidIt _First, _BidIt _Mid, _BidIt _Last, _Iter_diff_t<_BidIt> _Count1,
    _Iter_diff_t<_BidIt> _Count2, _Iter_value_t<_BidIt>* const _Temp_ptr, const ptrdiff_t _Capacity, _Pr _Pred) {
    
    
    if (_Count1 <= _Count2 && _Count1 <= _Capacity) {
        _Inplace_merge_buffer_left(_First, _Mid, _Last, _Temp_ptr, _Pred);
    } else if (_Count2 <= _Capacity) {
        _Inplace_merge_buffer_right(_First, _Mid, _Last, _Temp_ptr, _Pred);
    } else {
        _Buffered_inplace_merge_divide_and_conquer(_First, _Mid, _Last, _Count1, _Count2, _Temp_ptr, _Capacity, _Pred);
    }
}

template <class _BidIt, class _Pr>
void _Buffered_inplace_merge_unchecked(_BidIt _First, _BidIt _Mid, _BidIt _Last, _Iter_diff_t<_BidIt> _Count1,
    _Iter_diff_t<_BidIt> _Count2, _Iter_value_t<_BidIt>* const _Temp_ptr, const ptrdiff_t _Capacity, _Pr _Pred) {
    
    
    if (_Mid == _Last) {
        return;
    }

    for (;;) {
        if (_First == _Mid) {
            return;
        }

        if (_Pred(*_Mid, *_First)) {
            break;
        }

        ++_First;
        --_Count1;
    }

    const auto _Highest = _Prev_iter(_Mid);
    do {
        --_Last;
        --_Count2;
        if (_Mid == _Last) {
            _Rotate_one_right(_First, _Mid, ++_Last);
            return;
        }
    } while (!_Pred(*_Last, *_Highest));

    ++_Last;
    ++_Count2;

    if (_Count1 == 1) {
        _Rotate_one_left(_First, _Mid, _Last);
        return;
    }

    _Buffered_inplace_merge_unchecked_impl(_First, _Mid, _Last, _Count1, _Count2, _Temp_ptr, _Capacity, _Pred);
}

template <class _BidIt, class _Pr>
void inplace_merge(_BidIt _First, _BidIt _Mid, _BidIt _Last, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Mid);
    _Adl_verify_range(_Mid, _Last);
    auto _UFirst = _Get_unwrapped(_First);
    auto _UMid   = _Get_unwrapped(_Mid);
    auto _ULast  = _Get_unwrapped(_Last);
    ;

    
    if (_UMid == _ULast) {
        return;
    }

    for (;;) {
        if (_UFirst == _UMid) {
            return;
        }

        if (_Pred(*_UMid, *_UFirst)) { 
            break;
        }

        ++_UFirst;
    }

    const auto _Highest = _Prev_iter(_UMid);
    do {
        --_ULast;
        if (_UMid == _ULast) { 
            _Rotate_one_right(_UFirst, _UMid, ++_ULast);
            return;
        }
    } while (!_Pred(*_ULast, *_Highest)); 

    ++_ULast;

    using _Diff         = _Iter_diff_t<_BidIt>;
    const _Diff _Count1 = ::std:: distance(_UFirst, _UMid);
    if (_Count1 == 1) { 
        _Rotate_one_left(_UFirst, _UMid, _ULast);
        return;
    }

    const _Diff _Count2 = ::std:: distance(_UMid, _ULast);
    _Optimistic_temporary_buffer<_Iter_value_t<_BidIt>> _Temp_buf{(::std:: min)(_Count1, _Count2)};
    _Buffered_inplace_merge_unchecked_impl(
        _UFirst, _UMid, _ULast, _Count1, _Count2, _Temp_buf._Data, _Temp_buf._Capacity, _Pass_fn(_Pred));
}

template <class _BidIt>
void inplace_merge(_BidIt _First, _BidIt _Mid, _BidIt _Last) {
    
    ::std:: inplace_merge(_First, _Mid, _Last, less<>{});
}


template <class _ExPo, class _BidIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
void inplace_merge(_ExPo&&, _BidIt _First, _BidIt _Mid, _BidIt _Last, _Pr _Pred) noexcept  {
    
    
    ::std:: inplace_merge(_First, _Mid, _Last, _Pass_fn(_Pred));
}

template <class _ExPo, class _BidIt, _Enable_if_execution_policy_t<_ExPo> = 0>
void inplace_merge(_ExPo&&, _BidIt _First, _BidIt _Mid, _BidIt _Last) noexcept  {
    
    
    ::std:: inplace_merge(_First, _Mid, _Last);
}
#line 6956 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


namespace ranges {
    
    template <forward_iterator _It, sentinel_for<_It> _Se, class _Pr, class _Pj>
        requires indirect_strict_weak_order<_Pr, projected<_It, _Pj>>
    [[nodiscard]] constexpr _It _Is_sorted_until_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
        
        if (_First == _Last) {
            return _First;
        }

        for (auto _Prev = _First; ++_First != _Last; ++_Prev) {
            if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_First), ::std:: invoke(_Proj, *_Prev))) {
                break;
            }
        }

        return _First;
    }

    template <bidirectional_iterator _It>
    void _Rotate_one_right(_It _First, _It _Mid, _It _Last) {
        
        ;
        auto _Temp = ::std::ranges:: iter_move(_Mid);
        ::std::ranges:: _Move_backward_common(_First, ::std:: move(_Mid), ::std:: move(_Last));
        *_First = ::std:: move(_Temp);
    }

    template <bidirectional_iterator _It>
    void _Rotate_one_left(_It _First, _It _Mid, _It _Last) {
        
        ;
        auto _Temp   = ::std::ranges:: iter_move(_First);
        auto _Result = ::std::ranges:: _Move_unchecked(::std:: move(_Mid), ::std:: move(_Last), ::std:: move(_First));
        *_Result.out = ::std:: move(_Temp);
    }

    
    template <bidirectional_iterator _It, class _Pr, class _Pj>
        requires sortable<_It, _Pr, _Pj>
    void _Inplace_merge_buffer_left(_It _First, _It _Mid, _It _Last, iter_value_t<_It>* _Left_first,
        const ptrdiff_t _Capacity, _Pr _Pred, _Pj _Proj) {
        
        
        using _Ty = iter_value_t<_It>;

        _Ty* _Left_last = ::std::ranges:: _Uninitialized_move_unchecked(_First, _Mid, _Left_first, _Left_first + _Capacity).out;
        _Uninitialized_backout<_Ty*> _Backout{_Left_first, _Left_last};

        
        --_Left_last;

        
        *_First = ::std::ranges:: iter_move(_Mid);
        ++_First;
        ++_Mid;

        for (;;) {
            if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Mid), ::std:: invoke(_Proj, *_Left_first))) {
                *_First = ::std::ranges:: iter_move(_Mid); 
                ++_First;
                ++_Mid;
                if (_Mid == _Last) {
                    
                    ::std::ranges:: _Move_unchecked(_Left_first, _Backout._Last, _First);
                    return;
                }
            } else {
                *_First = ::std::ranges:: iter_move(_Left_first);
                ++_First;
                ++_Left_first;
                if (_Left_first == _Left_last) {
                    
                    const auto _Final = ::std::ranges:: _Move_unchecked(_Mid, _Last, _First);
                    *_Final.out       = ::std::ranges:: iter_move(_Left_first);
                    return;
                }
            }
        }
    }

    
    template <bidirectional_iterator _It, class _Pr, class _Pj>
        requires sortable<_It, _Pr, _Pj>
    void _Inplace_merge_buffer_right(_It _First, _It _Mid, _It _Last, iter_value_t<_It>* _Right_first,
        const ptrdiff_t _Capacity, _Pr _Pred, _Pj _Proj) {
        
        
        using _Ty = iter_value_t<_It>;

        _Ty* _Right_last =
            ::std::ranges:: _Uninitialized_move_unchecked(_Mid, _Last, _Right_first, _Right_first + _Capacity).out;
        _Uninitialized_backout<_Ty*> _Backout{_Right_first, _Right_last};

        
        *--_Last = ::std::ranges:: iter_move(--_Mid);

        
        --_Mid;
        --_Right_last;
        for (;;) {
            if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Right_last), ::std:: invoke(_Proj, *_Mid))) {
                *--_Last = ::std::ranges:: iter_move(_Mid); 
                if (_First == _Mid) {
                    ++_Right_last; 
                    ::std::ranges:: _Move_backward_common(_Right_first, _Right_last, ::std:: move(_Last));
                    return;
                }
                --_Mid;
            } else {
                *--_Last = ::std::ranges:: iter_move(_Right_last);
                --_Right_last;
                if (_Right_first == _Right_last) { 
                    ++_Mid; 
                    ::std::ranges:: _Move_backward_common(_First, ::std:: move(_Mid), ::std:: move(_Last));
                    *_First = ::std::ranges:: iter_move(_Right_first);
                    return;
                }
            }
        }
    }

    
    template <bidirectional_iterator _It, class _Pr, class _Pj>
        requires sortable<_It, _Pr, _Pj>
    void _Buffered_inplace_merge_common(_It _First, _It _Mid, _It _Last, iter_difference_t<_It> _Count1,
        iter_difference_t<_It> _Count2, iter_value_t<_It>* _Temp_ptr, ptrdiff_t _Capacity, _Pr _Pred, _Pj _Proj);
    

    template <bidirectional_iterator _It, class _Pr, class _Pj>
        requires sortable<_It, _Pr, _Pj>
    void _Buffered_inplace_merge_divide_and_conquer2(_It _First, _It _Mid, _It _Last,
        const iter_difference_t<_It> _Count1, const iter_difference_t<_It> _Count2, iter_value_t<_It>* const _Temp_ptr,
        const ptrdiff_t _Capacity, _Pr _Pred, _Pj _Proj, _It _Firstn, _It _Lastn, const iter_difference_t<_It> _Count1n,
        const iter_difference_t<_It> _Count2n) {
        
        
        _It _Midn = ::std::ranges:: _Buffered_rotate_common(_Firstn, _Mid, _Lastn,
            static_cast<iter_difference_t<_It>>(_Count1 - _Count1n), _Count2n, _Temp_ptr,
            _Capacity); 
        ::std::ranges:: _Buffered_inplace_merge_common(
            _First, _Firstn, _Midn, _Count1n, _Count2n, _Temp_ptr, _Capacity, _Pred, _Proj); 
        ::std::ranges:: _Buffered_inplace_merge_common(_Midn, _Lastn, _Last,
            static_cast<iter_difference_t<_It>>(_Count1 - _Count1n),
            static_cast<iter_difference_t<_It>>(_Count2 - _Count2n), _Temp_ptr, _Capacity, _Pred, _Proj);
    }

    
    template <bidirectional_iterator _It, class _Pr, class _Pj>
        requires sortable<_It, _Pr, _Pj>
    void _Buffered_inplace_merge_divide_and_conquer(_It _First, _It _Mid, _It _Last,
        const iter_difference_t<_It> _Count1, const iter_difference_t<_It> _Count2, iter_value_t<_It>* const _Temp_ptr,
        const ptrdiff_t _Capacity, _Pr _Pred, _Pj _Proj) {
        
        
        if (_Count1 <= _Count2) {
            const iter_difference_t<_It> _Count1n = _Count1 >> 1; 
            _It _Firstn                           = ::std::ranges:: next(_First, _Count1n);
            _It _Lastn = ::std::ranges:: _Lower_bound_unchecked(_Mid, _Count1, ::std:: invoke(_Proj, *_Firstn), _Pred, _Proj);
            const auto _Count2n = ::std::ranges:: distance(_Mid, _Lastn);
            ::std::ranges:: _Buffered_inplace_merge_divide_and_conquer2(::std:: move(_First), ::std:: move(_Mid), ::std:: move(_Last),
                _Count1, _Count2, _Temp_ptr, _Capacity, _Pred, _Proj, ::std:: move(_Firstn), ::std:: move(_Lastn), _Count1n,
                _Count2n);
        } else {
            const iter_difference_t<_It> _Count2n = _Count2 >> 1; 
            _It _Lastn                            = ::std::ranges:: next(_Mid, _Count2n);
            _It _Firstn = ::std::ranges:: _Upper_bound_unchecked(_First, _Count2, ::std:: invoke(_Proj, *_Lastn), _Pred, _Proj);
            const auto _Count1n = ::std::ranges:: distance(_First, _Firstn);
            ::std::ranges:: _Buffered_inplace_merge_divide_and_conquer2(::std:: move(_First), ::std:: move(_Mid), ::std:: move(_Last),
                _Count1, _Count2, _Temp_ptr, _Capacity, _Pred, _Proj, ::std:: move(_Firstn), ::std:: move(_Lastn), _Count1n,
                _Count2n);
        }
    }

    
    template <bidirectional_iterator _It, class _Pr, class _Pj>
        requires sortable<_It, _Pr, _Pj>
    void _Buffered_inplace_merge_common(_It _First, _It _Mid, _It _Last, iter_difference_t<_It> _Count1,
        iter_difference_t<_It> _Count2, iter_value_t<_It>* const _Temp_ptr, const ptrdiff_t _Capacity, _Pr _Pred,
        _Pj _Proj) {
        
        
        if (_First == _Mid || _Mid == _Last) {
            return;
        }

        
        while (!::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Mid), ::std:: invoke(_Proj, *_First))) {
            --_Count1;
            if (++_First == _Mid) {
                return;
            }
        }

        
        const auto _Highest = ::std::ranges:: prev(_Mid);
        do {
            
            if (_Mid == --_Last) {
                
                ::std::ranges:: _Rotate_one_right(::std:: move(_First), ::std:: move(_Mid), ::std:: move(++_Last));
                return;
            }
            --_Count2;
        } while (!::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Last), ::std:: invoke(_Proj, *_Highest)));
        ++_Last;
        ++_Count2;

        if (_Count1 == 1) {
            ::std::ranges:: _Rotate_one_left(::std:: move(_First), ::std:: move(_Mid), ::std:: move(_Last));
            return;
        }

        if (_Count1 <= _Count2 && _Count1 <= _Capacity) {
            ::std::ranges:: _Inplace_merge_buffer_left(
                ::std:: move(_First), ::std:: move(_Mid), ::std:: move(_Last), _Temp_ptr, _Capacity, _Pred, _Proj);
        } else if (_Count2 <= _Capacity) {
            ::std::ranges:: _Inplace_merge_buffer_right(
                ::std:: move(_First), ::std:: move(_Mid), ::std:: move(_Last), _Temp_ptr, _Capacity, _Pred, _Proj);
        } else {
            ::std::ranges:: _Buffered_inplace_merge_divide_and_conquer(::std:: move(_First), ::std:: move(_Mid), ::std:: move(_Last),
                _Count1, _Count2, _Temp_ptr, _Capacity, _Pred, _Proj);
        }
    }

    class _Inplace_merge_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <bidirectional_iterator _It, sentinel_for<_It> _Se, class _Pr = ranges::less, class _Pj = identity>
            requires sortable<_It, _Pr, _Pj>
        _It operator()(_It _First, _It _Mid, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) const {
            
            _Adl_verify_range(_First, _Mid);
            _Adl_verify_range(_Mid, _Last);

            auto _UFirst = _Get_unwrapped(::std:: move(_First));
            auto _ULast  = _Get_final_iterator_unwrapped<_It>(_UFirst, ::std:: move(_Last));
            _Seek_wrapped(_First, _ULast);

            _Inplace_merge_common(::std:: move(_UFirst), _Get_unwrapped(::std:: move(_Mid)), ::std:: move(_ULast),
                _Pass_fn(_Pred), _Pass_fn(_Proj));
            return _First;
        }

        
        template <bidirectional_range _Rng, class _Pr = ranges::less, class _Pj = identity>
            requires sortable<iterator_t<_Rng>, _Pr, _Pj>
        borrowed_iterator_t<_Rng> operator()(
            _Rng&& _Range, iterator_t<_Rng> _Mid, _Pr _Pred = {}, _Pj _Proj = {}) const {
            
            auto _First = ::std::ranges:: begin(_Range);
            auto _Last  = ::std::ranges:: end(_Range);

            _Adl_verify_range(_First, _Mid);
            _Adl_verify_range(_Mid, _Last);

            auto _UFirst = _Get_unwrapped(::std:: move(_First));
            auto _ULast  = _Get_final_iterator_unwrapped<iterator_t<_Rng>>(_UFirst, ::std:: move(_Last));
            _Seek_wrapped(_First, _ULast);

            _Inplace_merge_common(::std:: move(_UFirst), _Get_unwrapped(::std:: move(_Mid)), ::std:: move(_ULast),
                _Pass_fn(_Pred), _Pass_fn(_Proj));
            return _First;
        }

    private:
        template <class _It, class _Pr, class _Pj>
        static void _Inplace_merge_common(_It _First, _It _Mid, _It _Last, _Pr _Pred, _Pj _Proj) {
            ;
            ;

            if (_First == _Mid || _Mid == _Last) {
                return;
            }


#line 7246 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

            
            while (!::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Mid), ::std:: invoke(_Proj, *_First))) {
                if (++_First == _Mid) {
                    return;
                }
            }

            
            if (_Mid == --_Last) {
                
                ::std::ranges:: _Rotate_one_right(::std:: move(_First), ::std:: move(_Mid), ::std:: move(++_Last));
                return;
            }

            
            const auto _Highest = ::std::ranges:: prev(_Mid);
            while (!::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Last), ::std:: invoke(_Proj, *_Highest))) {
                if (_Mid == --_Last) {
                    
                    ::std::ranges:: _Rotate_one_right(::std:: move(_First), ::std:: move(_Mid), ::std:: move(++_Last));
                    return;
                }
            }
            ++_Last;

            const iter_difference_t<_It> _Count1 = ::std::ranges:: distance(_First, _Mid);
            if (_Count1 == 1) { 
                ::std::ranges:: _Rotate_one_left(::std:: move(_First), ::std:: move(_Mid), ::std:: move(_Last));
                return;
            }

            const iter_difference_t<_It> _Count2 = ::std::ranges:: distance(_Mid, _Last);
            _Optimistic_temporary_buffer<iter_value_t<_It>> _Temp_buf{(::std:: min)(_Count1, _Count2)};
            if (_Count1 <= _Count2 && _Count1 <= _Temp_buf._Capacity) {
                ::std::ranges:: _Inplace_merge_buffer_left(::std:: move(_First), ::std:: move(_Mid), ::std:: move(_Last),
                    _Temp_buf._Data, _Temp_buf._Capacity, _Pred, _Proj);
            } else if (_Count2 <= _Temp_buf._Capacity) {
                ::std::ranges:: _Inplace_merge_buffer_right(::std:: move(_First), ::std:: move(_Mid), ::std:: move(_Last),
                    _Temp_buf._Data, _Temp_buf._Capacity, _Pred, _Proj);
            } else {
                ::std::ranges:: _Buffered_inplace_merge_divide_and_conquer(::std:: move(_First), ::std:: move(_Mid), ::std:: move(_Last),
                    _Count1, _Count2, _Temp_buf._Data, _Temp_buf._Capacity, _Pred, _Proj);
            }
        }
    };

    inline constexpr _Inplace_merge_fn inplace_merge{_Not_quite_object::_Construct_tag{}};
} 
#line 7296 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _BidIt, class _Pr>
constexpr _BidIt _Insertion_sort_unchecked(const _BidIt _First, const _BidIt _Last, _Pr _Pred) {
    
    if (_First != _Last) {
        for (_BidIt _Mid = _First; ++_Mid != _Last;) { 
            _BidIt _Hole               = _Mid;
            _Iter_value_t<_BidIt> _Val = ::std:: move(*_Mid);

            if (static_cast<bool>(_Pred(_Val, *_First))) { 
                _Move_backward_unchecked(_First, _Mid, ++_Hole);
                *_First = ::std:: move(_Val);
            } else { 
                for (_BidIt _Prev = _Hole; static_cast<bool>(_Pred(_Val, *--_Prev)); _Hole = _Prev) {
                    *_Hole = ::std:: move(*_Prev); 
                }

                *_Hole = ::std:: move(_Val); 
            }
        }
    }

    return _Last;
}

template <class _RanIt, class _Pr>
constexpr void _Med3_unchecked(_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred) {
    
    if (static_cast<bool>(_Pred(*_Mid, *_First))) {
        ::std:: iter_swap(_Mid, _First);
    }

    if (static_cast<bool>(_Pred(*_Last, *_Mid))) { 
        ::std:: iter_swap(_Last, _Mid);

        if (static_cast<bool>(_Pred(*_Mid, *_First))) {
            ::std:: iter_swap(_Mid, _First);
        }
    }
}

template <class _RanIt, class _Pr>
constexpr void _Guess_median_unchecked(_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred) {
    
    using _Diff        = _Iter_diff_t<_RanIt>;
    const _Diff _Count = _Last - _First;
    if (40 < _Count) { 
        const _Diff _Step     = (_Count + 1) >> 3; 
        const _Diff _Two_step = _Step << 1; 
        _Med3_unchecked(_First, _First + _Step, _First + _Two_step, _Pred);
        _Med3_unchecked(_Mid - _Step, _Mid, _Mid + _Step, _Pred);
        _Med3_unchecked(_Last - _Two_step, _Last - _Step, _Last, _Pred);
        _Med3_unchecked(_First + _Step, _Mid, _Last - _Step, _Pred);
    } else {
        _Med3_unchecked(_First, _Mid, _Last, _Pred);
    }
}

template <class _RanIt, class _Pr>
constexpr pair<_RanIt, _RanIt> _Partition_by_median_guess_unchecked(_RanIt _First, _RanIt _Last, _Pr _Pred) {
    
    _RanIt _Mid = _First + ((_Last - _First) >> 1); 
    _Guess_median_unchecked(_First, _Mid, _Prev_iter(_Last), _Pred);
    _RanIt _Pfirst = _Mid;
    _RanIt _Plast  = _Next_iter(_Pfirst);

    while (_First < _Pfirst && !static_cast<bool>(_Pred(*_Prev_iter(_Pfirst), *_Pfirst))
           && !_Pred(*_Pfirst, *_Prev_iter(_Pfirst))) {
        --_Pfirst;
    }

    while (_Plast < _Last && !static_cast<bool>(_Pred(*_Plast, *_Pfirst)) && !_Pred(*_Pfirst, *_Plast)) {
        ++_Plast;
    }

    _RanIt _Gfirst = _Plast;
    _RanIt _Glast  = _Pfirst;

    for (;;) { 
        for (; _Gfirst < _Last; ++_Gfirst) {
            if (static_cast<bool>(_Pred(*_Pfirst, *_Gfirst))) {
                continue;
            } else if (_Pred(*_Gfirst, *_Pfirst)) {
                break;
            } else if (_Plast != _Gfirst) {
                ::std:: iter_swap(_Plast, _Gfirst);
                ++_Plast;
            } else {
                ++_Plast;
            }
        }

        for (; _First < _Glast; --_Glast) {
            if (static_cast<bool>(_Pred(*_Prev_iter(_Glast), *_Pfirst))) {
                continue;
            } else if (_Pred(*_Pfirst, *_Prev_iter(_Glast))) {
                break;
            } else if (--_Pfirst != _Prev_iter(_Glast)) {
                ::std:: iter_swap(_Pfirst, _Prev_iter(_Glast));
            }
        }

        if (_Glast == _First && _Gfirst == _Last) {
            return pair<_RanIt, _RanIt>(_Pfirst, _Plast);
        }

        if (_Glast == _First) { 
            if (_Plast != _Gfirst) {
                ::std:: iter_swap(_Pfirst, _Plast);
            }

            ++_Plast;
            ::std:: iter_swap(_Pfirst, _Gfirst);
            ++_Pfirst;
            ++_Gfirst;
        } else if (_Gfirst == _Last) { 
            if (--_Glast != --_Pfirst) {
                ::std:: iter_swap(_Glast, _Pfirst);
            }

            ::std:: iter_swap(_Pfirst, --_Plast);
        } else {
            ::std:: iter_swap(_Gfirst, --_Glast);
            ++_Gfirst;
        }
    }
}

template <class _RanIt, class _Pr>
constexpr void _Sort_unchecked(_RanIt _First, _RanIt _Last, _Iter_diff_t<_RanIt> _Ideal, _Pr _Pred) {
    
    for (;;) {
        if (_Last - _First <= _ISORT_MAX) { 
            _Insertion_sort_unchecked(_First, _Last, _Pred);
            return;
        }

        if (_Ideal <= 0) { 
            _Make_heap_unchecked(_First, _Last, _Pred);
            _Sort_heap_unchecked(_First, _Last, _Pred);
            return;
        }

        
        auto _Mid = _Partition_by_median_guess_unchecked(_First, _Last, _Pred);

        _Ideal = (_Ideal >> 1) + (_Ideal >> 2); 

        if (_Mid.first - _First < _Last - _Mid.second) { 
            _Sort_unchecked(_First, _Mid.first, _Ideal, _Pred);
            _First = _Mid.second;
        } else { 
            _Sort_unchecked(_Mid.second, _Last, _Ideal, _Pred);
            _Last = _Mid.first;
        }
    }
}

template <class _RanIt, class _Pr>
constexpr void sort(const _RanIt _First, const _RanIt _Last, _Pr _Pred) { 
    _Adl_verify_range(_First, _Last);
    const auto _UFirst = _Get_unwrapped(_First);
    const auto _ULast  = _Get_unwrapped(_Last);
    _Sort_unchecked(_UFirst, _ULast, _ULast - _UFirst, _Pass_fn(_Pred));
}

template <class _RanIt>
constexpr void sort(const _RanIt _First, const _RanIt _Last) { 
    ::std:: sort(_First, _Last, less<>{});
}


template <class _ExPo, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
void sort(_ExPo&& _Exec, _RanIt _First, _RanIt _Last, _Pr _Pred) noexcept; 

template <class _ExPo, class _RanIt, _Enable_if_execution_policy_t<_ExPo> = 0>
void sort(_ExPo&& _Exec, const _RanIt _First, const _RanIt _Last) noexcept  {
    
    ::std:: sort(::std:: forward<_ExPo>(_Exec), _First, _Last, less{});
}
#line 7477 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


namespace ranges {
    
    template <bidirectional_iterator _It, class _Pr, class _Pj>
        requires sortable<_It, _Pr, _Pj>
    constexpr _It _Insertion_sort_common(const _It _First, const _It _Last, _Pr _Pred, _Pj _Proj) {
        
        
        if (_First == _Last) { 
            return _Last;
        }

        for (auto _Mid = _First; ++_Mid != _Last;) { 
            iter_value_t<_It> _Val = ::std::ranges:: iter_move(_Mid);
            auto _Hole             = _Mid;

            for (auto _Prev = _Hole;;) {
                --_Prev;
                if (!::std:: invoke(_Pred, ::std:: invoke(_Proj, _Val), ::std:: invoke(_Proj, *_Prev))) {
                    break;
                }
                *_Hole = ::std::ranges:: iter_move(_Prev); 
                if (--_Hole == _First) {
                    break;
                }
            }

            *_Hole = ::std:: move(_Val); 
        }
        return _Last;
    }

    
    template <random_access_iterator _It, class _Pr, class _Pj>
        requires sortable<_It, _Pr, _Pj>
    constexpr void _Med3_common(_It _First, _It _Mid, _It _Last, _Pr _Pred, _Pj _Proj) {
        
        
        if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Mid), ::std:: invoke(_Proj, *_First))) {
            ::std::ranges:: iter_swap(_Mid, _First);
        }

        if (!::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Last), ::std:: invoke(_Proj, *_Mid))) {
            return;
        }

        
        ::std::ranges:: iter_swap(_Last, _Mid);

        if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Mid), ::std:: invoke(_Proj, *_First))) {
            ::std::ranges:: iter_swap(_Mid, _First);
        }
    }

    
    template <random_access_iterator _It, class _Pr, class _Pj>
        requires sortable<_It, _Pr, _Pj>
    constexpr void _Guess_median_common(_It _First, _It _Mid, _It _Last, _Pr _Pred, _Pj _Proj) {
        
        
        using _Diff        = iter_difference_t<_It>;
        const _Diff _Count = _Last - _First;
        if (_Count > 40) { 
            const _Diff _Step     = (_Count + 1) >> 3; 
            const _Diff _Two_step = _Step << 1; 
            _Med3_common(_First, _First + _Step, _First + _Two_step, _Pred, _Proj);
            _Med3_common(_Mid - _Step, _Mid, _Mid + _Step, _Pred, _Proj);
            _Med3_common(_Last - _Two_step, _Last - _Step, _Last, _Pred, _Proj);
            _Med3_common(_First + _Step, _Mid, _Last - _Step, _Pred, _Proj);
        } else {
            _Med3_common(_First, _Mid, _Last, _Pred, _Proj);
        }
    }

    
    template <random_access_iterator _It, class _Pr, class _Pj>
        requires sortable<_It, _Pr, _Pj>
    [[nodiscard]] constexpr subrange<_It> _Partition_by_median_guess_common(
        _It _First, _It _Last, _Pr _Pred, _Pj _Proj) {
        
        
        _It _Mid = _First + ((_Last - _First) >> 1); 
        _Guess_median_common(_First, _Mid, ::std::ranges:: prev(_Last), _Pred, _Proj);
        _It _Pfirst = _Mid;
        _It _Plast  = ::std::ranges:: next(_Pfirst);

        while (_First < _Pfirst
               && !::std:: invoke(_Pred, ::std:: invoke(_Proj, *::std::ranges:: prev(_Pfirst)), ::std:: invoke(_Proj, *_Pfirst))
               && !::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Pfirst), ::std:: invoke(_Proj, *::std::ranges:: prev(_Pfirst)))) {
            --_Pfirst;
        }

        while (_Plast < _Last && !::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Plast), ::std:: invoke(_Proj, *_Pfirst))
               && !::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Pfirst), ::std:: invoke(_Proj, *_Plast))) {
            ++_Plast;
        }

        _It _Gfirst = _Plast;
        _It _Glast  = _Pfirst;

        for (;;) { 
            for (; _Gfirst < _Last; ++_Gfirst) {
                if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Pfirst), ::std:: invoke(_Proj, *_Gfirst))) {
                    continue;
                } else if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Gfirst), ::std:: invoke(_Proj, *_Pfirst))) {
                    break;
                } else if (_Plast != _Gfirst) {
                    ::std::ranges:: iter_swap(_Plast, _Gfirst);
                    ++_Plast;
                } else {
                    ++_Plast;
                }
            }

            for (; _First < _Glast; --_Glast) {
                if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *::std::ranges:: prev(_Glast)), ::std:: invoke(_Proj, *_Pfirst))) {
                    continue;
                } else if (::std:: invoke(
                               _Pred, ::std:: invoke(_Proj, *_Pfirst), ::std:: invoke(_Proj, *::std::ranges:: prev(_Glast)))) {
                    break;
                } else if (--_Pfirst != ::std::ranges:: prev(_Glast)) {
                    ::std::ranges:: iter_swap(_Pfirst, ::std::ranges:: prev(_Glast));
                }
            }

            if (_Glast == _First && _Gfirst == _Last) {
                return {::std:: move(_Pfirst), ::std:: move(_Plast)};
            }

            if (_Glast == _First) { 
                if (_Plast != _Gfirst) {
                    ::std::ranges:: iter_swap(_Pfirst, _Plast);
                }

                ++_Plast;
                ::std::ranges:: iter_swap(_Pfirst, _Gfirst);
                ++_Pfirst;
                ++_Gfirst;
            } else if (_Gfirst == _Last) { 
                if (--_Glast != --_Pfirst) {
                    ::std::ranges:: iter_swap(_Glast, _Pfirst);
                }

                ::std::ranges:: iter_swap(_Pfirst, --_Plast);
            } else {
                ::std::ranges:: iter_swap(_Gfirst, --_Glast);
                ++_Gfirst;
            }
        }
    }

    class _Sort_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <random_access_iterator _It, sentinel_for<_It> _Se, class _Pr = ranges::less, class _Pj = identity>
            requires sortable<_It, _Pr, _Pj>
        constexpr _It operator()(_It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) const {
            
            _Adl_verify_range(_First, _Last);
            auto _UFirst = _Get_unwrapped(::std:: move(_First));
            auto _ULast  = _Get_final_iterator_unwrapped<_It>(_UFirst, ::std:: move(_Last));
            _Seek_wrapped(_First, _ULast);
            const auto _Count = _ULast - _UFirst;
            _Sort_common(::std:: move(_UFirst), ::std:: move(_ULast), _Count, _Pass_fn(_Pred), _Pass_fn(_Proj));
            return _First;
        }

        
        template <random_access_range _Rng, class _Pr = ranges::less, class _Pj = identity>
            requires sortable<iterator_t<_Rng>, _Pr, _Pj>
        constexpr borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) const {
            
            auto _UFirst      = _Ubegin(_Range);
            auto _ULast       = _Get_final_iterator_unwrapped(_Range);
            const auto _Count = _ULast - _UFirst;
            _Sort_common(::std:: move(_UFirst), _ULast, _Count, _Pass_fn(_Pred), _Pass_fn(_Proj));
            return _Rewrap_iterator(_Range, ::std:: move(_ULast));
        }

    private:
        template <class _It, class _Pr, class _Pj>
        static constexpr void _Sort_common(_It _First, _It _Last, iter_difference_t<_It> _Ideal, _Pr _Pred, _Pj _Proj) {
            
            ;
            ;

            for (;;) {
                if (_Last - _First <= _ISORT_MAX) { 
                    _Insertion_sort_common(::std:: move(_First), ::std:: move(_Last), _Pred, _Proj);
                    return;
                }

                if (_Ideal <= 0) { 
                    _Make_heap_common(_First, _Last, _Pred, _Proj);
                    _Sort_heap_common(::std:: move(_First), ::std:: move(_Last), _Pred, _Proj);
                    return;
                }

                
#line 7685 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
                auto _Mid       = _Partition_by_median_guess_common(_First, _Last, _Pred, _Proj);
                auto _Mid_first = _Mid.begin();
                auto _Mid_last  = _Mid.end();
#line 7689 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

                _Ideal = (_Ideal >> 1) + (_Ideal >> 2); 

                if (_Mid_first - _First < _Last - _Mid_last) { 
                    _Sort_common(_First, ::std:: move(_Mid_first), _Ideal, _Pred, _Proj);
                    _First = ::std:: move(_Mid_last);
                } else { 
                    _Sort_common(::std:: move(_Mid_last), _Last, _Ideal, _Pred, _Proj);
                    _Last = ::std:: move(_Mid_first);
                }
            }
        }
    };

    inline constexpr _Sort_fn sort{_Not_quite_object::_Construct_tag{}};
} 
#line 7706 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _FwdIt, class _Ty, class _Pr>
_Ty* _Uninitialized_merge_move(_FwdIt _First, const _FwdIt _Mid, const _FwdIt _Last, _Ty* const _Dest, _Pr _Pred) {
    
    
    _Uninitialized_backout<_Ty*> _Backout{_Dest};
    _FwdIt _Next = _Mid;
    for (;;) {
        if (static_cast<bool>(_Pred(*_Next, *_First))) {
            _Backout._Emplace_back(::std:: move(*_Next));
            ++_Next;

            if (_Next == _Last) {
                _Backout._Last = _Uninitialized_move_unchecked(_First, _Mid, _Backout._Last);
                return _Backout._Release();
            }
        } else {
            _Backout._Emplace_back(::std:: move(*_First));
            ++_First;

            if (_First == _Mid) {
                _Backout._Last = _Uninitialized_move_unchecked(_Next, _Last, _Backout._Last);
                return _Backout._Release();
            }
        }
    }
}

template <class _InIt, class _OutIt, class _Pr>
_OutIt _Merge_move(_InIt _First, const _InIt _Mid, const _InIt _Last, _OutIt _Dest, _Pr _Pred) {
    
    
    _InIt _Next = _Mid;
    for (;;) {
        if (static_cast<bool>(_Pred(*_Next, *_First))) {
            *_Dest = ::std:: move(*_Next);
            ++_Dest;
            ++_Next;

            if (_Next == _Last) {
                return _Move_unchecked(_First, _Mid, _Dest);
            }
        } else {
            *_Dest = ::std:: move(*_First);
            ++_Dest;
            ++_First;

            if (_First == _Mid) {
                return _Move_unchecked(_Next, _Last, _Dest);
            }
        }
    }
}

template <class _BidIt, class _Ty, class _Pr>
void _Uninitialized_chunked_merge_unchecked2(
    _BidIt _First, const _BidIt _Last, _Ty* _Dest, _Iter_diff_t<_BidIt> _Count, _Pr _Pred) {
    
    
    _Uninitialized_backout<_Ty*> _Backout{_Dest};
    while (_Count > _Isort_max<_BidIt>) {
        _Count -= _Isort_max<_BidIt>;
        const _BidIt _Mid1 = ::std:: next(_First, _Isort_max<_BidIt>);
        const auto _Chunk2 = (::std:: min)(_Isort_max<_BidIt>, _Count);
        _Count -= _Chunk2;
        const _BidIt _Mid2 = ::std:: next(_Mid1, _Chunk2);
        _Backout._Last     = _Uninitialized_merge_move(_First, _Mid1, _Mid2, _Backout._Last, _Pred);
        _First             = _Mid2;
    }

    _Uninitialized_move_unchecked(_First, _Last, _Backout._Last); 
    _Backout._Release();
}

template <class _BidIt, class _OutIt, class _Pr>
void _Chunked_merge_unchecked(_BidIt _First, const _BidIt _Last, _OutIt _Dest, const _Iter_diff_t<_BidIt> _Chunk,
    _Iter_diff_t<_BidIt> _Count, _Pr _Pred) {
    
    
    while (_Chunk < _Count) {
        _Count -= _Chunk;
        const _BidIt _Mid1 = ::std:: next(_First, _Chunk);
        const auto _Chunk2 = (::std:: min)(_Chunk, _Count);
        _Count -= _Chunk2;
        const _BidIt _Mid2 = ::std:: next(_Mid1, _Chunk2);
        _Dest              = _Merge_move(_First, _Mid1, _Mid2, _Dest, _Pred);
        _First             = _Mid2;
    }

    _Move_unchecked(_First, _Last, _Dest); 
}

template <class _BidIt, class _Pr>
void _Insertion_sort_isort_max_chunks(_BidIt _First, const _BidIt _Last, _Iter_diff_t<_BidIt> _Count, _Pr _Pred) {
    
    
    for (; _Isort_max<_BidIt> < _Count; _Count -= _Isort_max<_BidIt>) { 
        _First = _Insertion_sort_unchecked(_First, ::std:: next(_First, _Isort_max<_BidIt>), _Pred);
    }

    _Insertion_sort_unchecked(_First, _Last, _Pred); 
}

template <class _BidIt, class _Pr>
void _Buffered_merge_sort_unchecked(const _BidIt _First, const _BidIt _Last, const _Iter_diff_t<_BidIt> _Count,
    _Iter_value_t<_BidIt>* const _Temp_ptr, _Pr _Pred) {
    
    
    _Insertion_sort_isort_max_chunks(_First, _Last, _Count, _Pred);
    
    if (_Count <= _Isort_max<_BidIt>) {
        return;
    }

    
    _Uninitialized_chunked_merge_unchecked2(_First, _Last, _Temp_ptr, _Count, _Pred);
    _Uninitialized_backout<_Iter_value_t<_BidIt>*> _Backout{_Temp_ptr, _Temp_ptr + _Count};
    auto _Chunk = _Isort_max<_BidIt>;
    for (;;) {
        
        _Chunk <<= 1;
        _Chunked_merge_unchecked(_Temp_ptr, _Temp_ptr + _Count, _First, static_cast<ptrdiff_t>(_Chunk),
            static_cast<ptrdiff_t>(_Count), _Pred);
        _Chunk <<= 1;
        if (_Count <= _Chunk) { 
            return;
        }

        
        _Chunked_merge_unchecked(_First, _Last, _Temp_ptr, _Chunk, _Count, _Pred);
    }
}

template <class _BidIt, class _Pr>
void _Stable_sort_unchecked(const _BidIt _First, const _BidIt _Last, const _Iter_diff_t<_BidIt> _Count,
    _Iter_value_t<_BidIt>* const _Temp_ptr, const ptrdiff_t _Capacity, _Pr _Pred) {
    
    using _Diff = _Iter_diff_t<_BidIt>;
    if (_Count <= _ISORT_MAX) {
        _Insertion_sort_unchecked(_First, _Last, _Pred); 
    } else { 
        const auto _Half_count      = static_cast<_Diff>(_Count >> 1); 
        const auto _Half_count_ceil = static_cast<_Diff>(_Count - _Half_count);
        const _BidIt _Mid           = ::std:: next(_First, _Half_count_ceil);
        if (_Half_count_ceil <= _Capacity) { 
            _Buffered_merge_sort_unchecked(_First, _Mid, _Half_count_ceil, _Temp_ptr, _Pred);
            _Buffered_merge_sort_unchecked(_Mid, _Last, _Half_count, _Temp_ptr, _Pred);
        } else { 
            _Stable_sort_unchecked(_First, _Mid, _Half_count_ceil, _Temp_ptr, _Capacity, _Pred);
            _Stable_sort_unchecked(_Mid, _Last, _Half_count, _Temp_ptr, _Capacity, _Pred);
        }

        _Buffered_inplace_merge_unchecked(
            _First, _Mid, _Last, _Half_count_ceil, _Half_count, _Temp_ptr, _Capacity, _Pred); 
    }
}

template <class _BidIt, class _Pr>
void stable_sort(const _BidIt _First, const _BidIt _Last, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Last);
    const auto _UFirst = _Get_unwrapped(_First);
    const auto _ULast  = _Get_unwrapped(_Last);
    const auto _Count  = ::std:: distance(_UFirst, _ULast);
    if (_Count <= _ISORT_MAX) {
        _Insertion_sort_unchecked(_UFirst, _ULast, _Pass_fn(_Pred));
        return;
    }

    _Optimistic_temporary_buffer<_Iter_value_t<_BidIt>> _Temp_buf{_Count - _Count / 2};
    _Stable_sort_unchecked(_UFirst, _ULast, _Count, _Temp_buf._Data, _Temp_buf._Capacity, _Pass_fn(_Pred));
}


template <class _ExPo, class _BidIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
void stable_sort(_ExPo&& _Exec, const _BidIt _First, const _BidIt _Last, _Pr _Pred) noexcept; 
#line 7886 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _BidIt>
void stable_sort(const _BidIt _First, const _BidIt _Last) { 
    ::std:: stable_sort(_First, _Last, less<>{});
}


template <class _ExPo, class _BidIt, _Enable_if_execution_policy_t<_ExPo> = 0>
void stable_sort(_ExPo&& _Exec, _BidIt _First, _BidIt _Last) noexcept  {
    
    ::std:: stable_sort(::std:: forward<_ExPo>(_Exec), _First, _Last, less{});
}
#line 7899 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"


namespace ranges {
    class _Stable_sort_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <random_access_iterator _It, sentinel_for<_It> _Se, class _Pr = ranges::less, class _Pj = identity>
            requires sortable<_It, _Pr, _Pj>
        _It operator()(_It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) const {
            
            _Adl_verify_range(_First, _Last);
            auto _UFirst = _Get_unwrapped(::std:: move(_First));
            auto _ULast  = _Get_final_iterator_unwrapped<_It>(_UFirst, ::std:: move(_Last));
            _Seek_wrapped(_First, _ULast);

            const auto _Count = _ULast - _UFirst;
            _Stable_sort_common(::std:: move(_UFirst), ::std:: move(_ULast), _Count, _Pass_fn(_Pred), _Pass_fn(_Proj));
            return _First;
        }

        
        template <random_access_range _Rng, class _Pr = ranges::less, class _Pj = identity>
            requires sortable<iterator_t<_Rng>, _Pr, _Pj>
        borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) const {
            
            auto _UFirst = _Ubegin(_Range);
            auto _ULast  = _Get_final_iterator_unwrapped(_Range);

            const auto _Count = _ULast - _UFirst;
            _Stable_sort_common(::std:: move(_UFirst), _ULast, _Count, _Pass_fn(_Pred), _Pass_fn(_Proj));
            return _Rewrap_iterator(_Range, ::std:: move(_ULast));
        }

    private:
        template <class _It, class _Pr, class _Pj>
        static void _Stable_sort_common(
            _It _First, _It _Last, const iter_difference_t<_It> _Count, _Pr _Pred, _Pj _Proj) {
            
            ;
            ;
            ;

            if (_Count <= _Isort_max<_It>) {
                ::std::ranges:: _Insertion_sort_common(::std:: move(_First), ::std:: move(_Last), _Pred, _Proj);
                return;
            }

            _Optimistic_temporary_buffer<_Iter_value_t<_It>> _Temp_buf{_Count - _Count / 2};
            _Stable_sort_common_buffered(
                ::std:: move(_First), ::std:: move(_Last), _Count, _Temp_buf._Data, _Temp_buf._Capacity, _Pred, _Proj);
        }

        template <class _It, class _Pr, class _Pj>
        static void _Stable_sort_common_buffered(_It _First, _It _Last, const iter_difference_t<_It> _Count,
            iter_value_t<_It>* const _Temp_ptr, const ptrdiff_t _Capacity, _Pr _Pred, _Pj _Proj) {
            
            ;
            ;
            ;
            

            if (_Count <= _Isort_max<_It>) {
                ::std::ranges:: _Insertion_sort_common(::std:: move(_First), ::std:: move(_Last), _Pred, _Proj);
            } else { 
                const iter_difference_t<_It> _Half_count      = _Count >> 1; 
                const iter_difference_t<_It> _Half_count_ceil = _Count - _Half_count;
                const _It _Mid                                = _First + _Half_count_ceil;
                if (_Half_count_ceil <= _Capacity) { 
                    _Buffered_merge_sort_common(_First, _Mid, _Half_count_ceil, _Temp_ptr, _Pred, _Proj);
                    _Buffered_merge_sort_common(_Mid, _Last, _Half_count, _Temp_ptr, _Pred, _Proj);
                } else { 
                    _Stable_sort_common_buffered(_First, _Mid, _Half_count_ceil, _Temp_ptr, _Capacity, _Pred, _Proj);
                    _Stable_sort_common_buffered(_Mid, _Last, _Half_count, _Temp_ptr, _Capacity, _Pred, _Proj);
                }
                
                ::std::ranges:: _Buffered_inplace_merge_common(::std:: move(_First), ::std:: move(_Mid), ::std:: move(_Last),
                    _Half_count_ceil, _Half_count, _Temp_ptr, _Capacity, _Pred, _Proj);
            }
        }

        template <class _It, class _Pr, class _Pj>
        static void _Buffered_merge_sort_common(const _It _First, const _It _Last, const iter_difference_t<_It> _Count,
            iter_value_t<_It>* const _Temp_ptr, _Pr _Pred, _Pj _Proj) {
            
            
            ;
            ;
            ;

            _Insertion_sort_isort_max_chunks(_First, _Last, _Count, _Pred, _Proj);
            
            if (_Count <= _Isort_max<_It>) {
                return;
            }

            
            _Uninitialized_chunked_merge_common(_First, _Last, _Temp_ptr, _Count, _Pred, _Proj);
            _Uninitialized_backout<iter_value_t<_It>*> _Backout{_Temp_ptr, _Temp_ptr + _Count};
            iter_difference_t<_It> _Chunk_size = _Isort_max<_It>;
            for (;;) {
                
                _Chunk_size <<= 1;
                _Chunked_merge_common(_Temp_ptr, _Temp_ptr + _Count, _First, _Chunk_size, _Count, _Pred, _Proj);
                _Chunk_size <<= 1;
                if (_Count <= _Chunk_size) { 
                    return;
                }

                
                _Chunked_merge_common(_First, _Last, _Temp_ptr, _Chunk_size, _Count, _Pred, _Proj);
            }
        }

        template <class _It, class _Pr, class _Pj>
        static void _Insertion_sort_isort_max_chunks(
            _It _First, _It _Last, iter_difference_t<_It> _Count, _Pr _Pred, _Pj _Proj) {
            
            ;
            ;
            ;

            for (; _Isort_max<_It> < _Count; _Count -= _Isort_max<_It>) { 
                _First = ::std::ranges:: _Insertion_sort_common(_First, _First + _Isort_max<_It>, _Pred, _Proj);
            }

            
            ::std::ranges:: _Insertion_sort_common(::std:: move(_First), ::std:: move(_Last), _Pred, _Proj);
        }

        template <class _It, class _Pr, class _Pj>
        static void _Uninitialized_chunked_merge_common(_It _First, const _It _Last, iter_value_t<_It>* const _Dest,
            iter_difference_t<_It> _Count, _Pr _Pred, _Pj _Proj) {
            
            ;
            ;
            ;
            ;

            _Uninitialized_backout<iter_value_t<_It>*> _Backout{_Dest};
            const auto _Backout_end = _Dest + _Count;
            while (_Isort_max<_It> < _Count) {
                _Count -= _Isort_max<_It>;
                const auto _Chunk2 = (::std:: min)(_Isort_max<_It>, _Count);
                _Count -= _Chunk2;

                auto _Mid1     = _First + _Isort_max<_It>;
                auto _Last1    = _Mid1 + _Chunk2;
                auto _Last2    = _Backout._Last + _Isort_max<_It> + _Chunk2;
                _Backout._Last = _Uninitialized_merge_move(
                    ::std:: move(_First), ::std:: move(_Mid1), _Last1, _Backout._Last, _Last2, _Pred, _Proj);
                _First = ::std:: move(_Last1);
            }

            
            ::std::ranges:: _Uninitialized_move_unchecked(::std:: move(_First), ::std:: move(_Last), _Backout._Last, _Backout_end);
            _Backout._Release();
        }

        template <class _It, class _Pr, class _Pj>
        [[nodiscard]] static iter_value_t<_It>* _Uninitialized_merge_move(_It _First, _It _Mid, _It _Last,
            iter_value_t<_It>* const _Dest, iter_value_t<_It>* const _Dest_last, _Pr _Pred, _Pj _Proj) {
            
            ;
            ;
            ;
            ;
            ;

            _Uninitialized_backout<iter_value_t<_It>*> _Backout{_Dest};
            _It _Next = _Mid;
            for (;;) {
                if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Next), ::std:: invoke(_Proj, *_First))) {
                    _Backout._Emplace_back(::std::ranges:: iter_move(_Next));
                    ++_Next;

                    if (_Next == _Last) {
                        _Backout._Last = ::std::ranges:: _Uninitialized_move_unchecked(
                            ::std:: move(_First), ::std:: move(_Mid), _Backout._Last, _Dest_last)
                                             .out;
                        return _Backout._Release();
                    }
                } else {
                    _Backout._Emplace_back(::std::ranges:: iter_move(_First));
                    ++_First;

                    if (_First == _Mid) {
                        _Backout._Last = ::std::ranges:: _Uninitialized_move_unchecked(
                            ::std:: move(_Next), ::std:: move(_Last), _Backout._Last, _Dest_last)
                                             .out;
                        return _Backout._Release();
                    }
                }
            }
        }

        template <class _InIt, class _OutIt, class _Pr, class _Pj>
        [[nodiscard]] static _OutIt _Merge_move_common(
            _InIt _First, _InIt _Mid, _InIt _Last, _OutIt _Dest, _Pr _Pred, _Pj _Proj) {
            
            ;
            ;
            ;
            ;

            _InIt _Next = _Mid;
            for (;;) {
                if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Next), ::std:: invoke(_Proj, *_First))) {
                    *_Dest = ::std::ranges:: iter_move(_Next);
                    ++_Dest;
                    ++_Next;

                    if (_Next == _Last) {
                        return ::std::ranges:: _Move_unchecked(::std:: move(_First), ::std:: move(_Mid), ::std:: move(_Dest)).out;
                    }
                } else {
                    *_Dest = ::std::ranges:: iter_move(_First);
                    ++_Dest;
                    ++_First;

                    if (_First == _Mid) {
                        return ::std::ranges:: _Move_unchecked(::std:: move(_Next), ::std:: move(_Last), ::std:: move(_Dest)).out;
                    }
                }
            }
        }

        template <class _It1, class _It2, class _Pr, class _Pj>
        static void _Chunked_merge_common(_It1 _First, const _It1 _Last, _It2 _Dest,
            const iter_difference_t<_It1> _Chunk_size, iter_difference_t<_It1> _Count, _Pr _Pred, _Pj _Proj) {
            
            ;
            ;
            ;
            ;
            ;

            while (_Chunk_size < _Count) {
                _Count -= _Chunk_size;
                const auto _Right_chunk_size = (::std:: min)(_Chunk_size, _Count);
                _Count -= _Right_chunk_size;

                auto _Mid1  = _First + _Chunk_size;
                auto _Last1 = _Mid1 + _Right_chunk_size;
                _Dest       = _Merge_move_common(::std:: move(_First), ::std:: move(_Mid1), _Last1, _Dest, _Pred, _Proj);
                _First      = ::std:: move(_Last1);
            }

            
            ::std::ranges:: _Move_unchecked(::std:: move(_First), ::std:: move(_Last), ::std:: move(_Dest));
        }
    };

    inline constexpr _Stable_sort_fn stable_sort{_Not_quite_object::_Construct_tag{}};
} 
#line 8157 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _RanIt, class _Pr>
constexpr void partial_sort(_RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Mid);
    _Adl_verify_range(_Mid, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _UMid  = _Get_unwrapped(_Mid);
    const auto _ULast = _Get_unwrapped(_Last);

    if (_UFirst == _UMid) {
        return; 
    }

    _Make_heap_unchecked(_UFirst, _UMid, _Pass_fn(_Pred));
    for (auto _UNext = _UMid; _UNext < _ULast; ++_UNext) {
        if (static_cast<bool>(_Pred(*_UNext, *_UFirst))) { 
            _Iter_value_t<_RanIt> _Val = ::std:: move(*_UNext);
            _Pop_heap_hole_unchecked(_UFirst, _UMid, _UNext, ::std:: move(_Val), _Pass_fn(_Pred));
        }
    }

    _Sort_heap_unchecked(_UFirst, _UMid, _Pass_fn(_Pred));
}

template <class _RanIt>
constexpr void partial_sort(_RanIt _First, _RanIt _Mid, _RanIt _Last) {
    
    ::std:: partial_sort(_First, _Mid, _Last, less<>{});
}


template <class _ExPo, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
void partial_sort(_ExPo&&, _RanIt _First, _RanIt _Mid, _RanIt _Last, _Pr _Pred) noexcept  {
    
    
    return ::std:: partial_sort(_First, _Mid, _Last, _Pass_fn(_Pred));
}

template <class _ExPo, class _RanIt, _Enable_if_execution_policy_t<_ExPo> = 0>
void partial_sort(_ExPo&&, _RanIt _First, _RanIt _Mid, _RanIt _Last) noexcept  {
    
    
    return ::std:: partial_sort(_First, _Mid, _Last);
}


namespace ranges {
    class _Partial_sort_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <random_access_iterator _It, sentinel_for<_It> _Se, class _Pr = ranges::less, class _Pj = identity>
            requires sortable<_It, _Pr, _Pj>
        constexpr _It operator()(_It _First, _It _Mid, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) const {
            
            _Adl_verify_range(_First, _Mid);
            _Adl_verify_range(_Mid, _Last);

            if constexpr (is_same_v<_It, _Se>) {
                _Partial_sort_common(_Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Mid)),
                    _Get_unwrapped(_Last), _Pass_fn(_Pred), _Pass_fn(_Proj));
                return _Last;
            } else {
                auto _UMid  = _Get_unwrapped(::std:: move(_Mid));
                auto _ULast = _Get_final_iterator_unwrapped<_It>(_UMid, ::std:: move(_Last));
                _Seek_wrapped(_Mid, _ULast);
                _Partial_sort_common(_Get_unwrapped(::std:: move(_First)), ::std:: move(_UMid), ::std:: move(_ULast),
                    _Pass_fn(_Pred), _Pass_fn(_Proj));
                return _Mid;
            }
        }

        
        template <random_access_range _Rng, class _Pr = ranges::less, class _Pj = identity>
            requires sortable<iterator_t<_Rng>, _Pr, _Pj>
        constexpr borrowed_iterator_t<_Rng> operator()(
            _Rng&& _Range, iterator_t<_Rng> _Mid, _Pr _Pred = {}, _Pj _Proj = {}) const {
            
            _Adl_verify_range(::std::ranges:: begin(_Range), _Mid);
            _Adl_verify_range(_Mid, ::std::ranges:: end(_Range));

            if constexpr (common_range<_Rng>) {
                _Partial_sort_common(
                    _Ubegin(_Range), _Get_unwrapped(::std:: move(_Mid)), _Uend(_Range), _Pass_fn(_Pred), _Pass_fn(_Proj));
                return ::std::ranges:: end(_Range);
            } else {
                auto _UMid  = _Get_unwrapped(::std:: move(_Mid));
                auto _ULast = _Get_final_iterator_unwrapped(_Range, _UMid);
                _Seek_wrapped(_Mid, _ULast);
                _Partial_sort_common(
                    _Ubegin(_Range), ::std:: move(_UMid), ::std:: move(_ULast), _Pass_fn(_Pred), _Pass_fn(_Proj));
                return _Mid;
            }
        }

    private:
        template <class _It, class _Pr, class _Pj>
        static constexpr void _Partial_sort_common(_It _First, _It _Mid, const _It _Last, _Pr _Pred, _Pj _Proj) {
            ;
            ;

            if (_First == _Mid) {
                return; 
            }

            _Make_heap_common(_First, _Mid, _Pred, _Proj);
            for (auto _Next = _Mid; _Next != _Last; ++_Next) {
                if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Next), ::std:: invoke(_Proj, *_First))) {
                    
                    iter_value_t<_It> _Val = ::std::ranges:: iter_move(_Next);
                    ::std::ranges:: _Pop_heap_hole_unchecked(_First, _Mid, _Next, ::std:: move(_Val), _Pred, _Proj, _Proj);
                }
            }

            _Sort_heap_common(::std:: move(_First), ::std:: move(_Mid), _Pred, _Proj);
        }
    };

    inline constexpr _Partial_sort_fn partial_sort{_Not_quite_object::_Construct_tag{}};
} 
#line 8280 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
#line 8281 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _InIt, class _RanIt, class _Pr>
constexpr _RanIt partial_sort_copy(_InIt _First1, _InIt _Last1, _RanIt _First2, _RanIt _Last2, _Pr _Pred) {
    
    _Adl_verify_range(_First1, _Last1);
    _Adl_verify_range(_First2, _Last2);
    auto _UFirst1      = _Get_unwrapped(_First1);
    const auto _ULast1 = _Get_unwrapped(_Last1);
    auto _UFirst2      = _Get_unwrapped(_First2);
    const auto _ULast2 = _Get_unwrapped(_Last2);
    auto _UMid2        = _UFirst2;
    if (_UFirst1 != _ULast1 && _UFirst2 != _ULast2) {
        for (; _UFirst1 != _ULast1 && _UMid2 != _ULast2; ++_UFirst1, (void) ++_UMid2) {
            *_UMid2 = *_UFirst1; 
        }

        _Make_heap_unchecked(_UFirst2, _UMid2, _Pass_fn(_Pred));
        for (; _UFirst1 != _ULast1; ++_UFirst1) {
            if (static_cast<bool>(_Pred(*_UFirst1, *_UFirst2))) {
                
                using _Diff = _Iter_diff_t<_RanIt>;
                _Pop_heap_hole_by_index(
                    _UFirst2, static_cast<_Diff>(0), static_cast<_Diff>(_UMid2 - _UFirst2), *_UFirst1, _Pass_fn(_Pred));
            }
        }

        _Sort_heap_unchecked(_UFirst2, _UMid2, _Pass_fn(_Pred));
    }

    _Seek_wrapped(_First2, _UMid2);
    return _First2;
}

template <class _InIt, class _RanIt>
constexpr _RanIt partial_sort_copy(_InIt _First1, _InIt _Last1, _RanIt _First2, _RanIt _Last2) {
    
    return ::std:: partial_sort_copy(_First1, _Last1, _First2, _Last2, less<>{});
}


template <class _ExPo, class _FwdIt, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
_RanIt partial_sort_copy(_ExPo&&, _FwdIt _First1, _FwdIt _Last1, _RanIt _First2, _RanIt _Last2, _Pr _Pred) noexcept
 {
    
    
    static_assert(_Is_fwd_iter_v<_FwdIt>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: partial_sort_copy(_First1, _Last1, _First2, _Last2, _Pass_fn(_Pred));
}

template <class _ExPo, class _FwdIt, class _RanIt, _Enable_if_execution_policy_t<_ExPo> = 0>
_RanIt partial_sort_copy(_ExPo&&, _FwdIt _First1, _FwdIt _Last1, _RanIt _First2, _RanIt _Last2) noexcept
 {
    
    
    static_assert(_Is_fwd_iter_v<_FwdIt>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: partial_sort_copy(_First1, _Last1, _First2, _Last2);
}


namespace ranges {
    template <class _In, class _Out>
    using partial_sort_copy_result = in_out_result<_In, _Out>;

    class _Partial_sort_copy_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It1, sentinel_for<_It1> _Se1, random_access_iterator _It2, sentinel_for<_It2> _Se2,
            class _Pr = ranges::less, class _Pj1 = identity, class _Pj2 = identity>
            requires indirectly_copyable<_It1, _It2>
                && sortable<_It2, _Pr, _Pj2>
                && indirect_strict_weak_order<_Pr, projected<_It1, _Pj1>, projected<_It2, _Pj2>>
        constexpr partial_sort_copy_result<_It1, _It2> operator()(_It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2,
            _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            
            _Adl_verify_range(_First1, _Last1);
            _Adl_verify_range(_First2, _Last2);

            auto _UResult = _Partial_sort_copy_unchecked(_Get_unwrapped(::std:: move(_First1)),
                _Get_unwrapped(::std:: move(_Last1)), _Get_unwrapped(::std:: move(_First2)),
                _Get_unwrapped(::std:: move(_Last2)), _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));

            _Seek_wrapped(_First1, ::std:: move(_UResult.in));
            _Seek_wrapped(_First2, ::std:: move(_UResult.out));
            return {::std:: move(_First1), ::std:: move(_First2)};
        }

        
        template <input_range _Rng1, random_access_range _Rng2, class _Pr = ranges::less, class _Pj1 = identity,
            class _Pj2 = identity>
            requires indirectly_copyable<iterator_t<_Rng1>, iterator_t<_Rng2>>
                && sortable<iterator_t<_Rng2>, _Pr, _Pj2>
                && indirect_strict_weak_order<_Pr, projected<iterator_t<_Rng1>, _Pj1>,
                    projected<iterator_t<_Rng2>, _Pj2>>
        constexpr partial_sort_copy_result<borrowed_iterator_t<_Rng1>, borrowed_iterator_t<_Rng2>> operator()(
            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            
            auto _First   = ::std::ranges:: begin(_Range1);
            auto _UResult = _Partial_sort_copy_unchecked(_Get_unwrapped(::std:: move(_First)), _Uend(_Range1),
                _Ubegin(_Range2), _Uend(_Range2), _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));

            _Seek_wrapped(_First, ::std:: move(_UResult.in));
            return {::std:: move(_First), _Rewrap_iterator(_Range2, ::std:: move(_UResult.out))};
        }

    private:
        template <class _It1, class _Se1, class _It2, class _Se2, class _Pr, class _Pj1, class _Pj2>
        [[nodiscard]] static constexpr partial_sort_copy_result<_It1, _It2> _Partial_sort_copy_unchecked(
            _It1 _First1, _Se1 _Last1, _It2 _First2, const _Se2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
            ;
            ;
            ;
            ;
            ;
            ;
            ;

            if (_First1 == _Last1 || _First2 == _Last2) {
                ::std::ranges:: advance(_First1, ::std:: move(_Last1));
                return {::std:: move(_First1), ::std:: move(_First2)};
            }

            
            auto _Mid2 = _First2;
            do {
                *_Mid2 = *_First1;
                ++_First1;
                ++_Mid2;
            } while (_First1 != _Last1 && _Mid2 != _Last2);

            _Make_heap_common(_First2, _Mid2, _Pred, _Proj2); 
            for (; _First1 != _Last1; ++_First1) { 
                
                if (::std:: invoke(_Pred, ::std:: invoke(_Proj1, *_First1), ::std:: invoke(_Proj2, *_First2))) {
                    
                    using _Diff = iter_difference_t<_It2>;
                    ::std::ranges:: _Pop_heap_hole_by_index(_First2, static_cast<_Diff>(0), static_cast<_Diff>(_Mid2 - _First2),
                        *_First1, _Pred, _Proj2, _Proj1);
                }
            }

            
            _Sort_heap_common(::std:: move(_First2), _Mid2, _Pred, _Proj2);
            return {::std:: move(_First1), ::std:: move(_Mid2)};
        }
    };

    inline constexpr _Partial_sort_copy_fn partial_sort_copy{_Not_quite_object::_Construct_tag{}};
} 
#line 8432 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
#line 8433 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _RanIt, class _Pr>
constexpr void nth_element(_RanIt _First, _RanIt _Nth, _RanIt _Last, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Nth);
    _Adl_verify_range(_Nth, _Last);
    auto _UFirst     = _Get_unwrapped(_First);
    const auto _UNth = _Get_unwrapped(_Nth);
    auto _ULast      = _Get_unwrapped(_Last);
    if (_UNth == _ULast) {
        return; 
    }

    while (_ISORT_MAX < _ULast - _UFirst) { 
        auto _UMid = _Partition_by_median_guess_unchecked(_UFirst, _ULast, _Pass_fn(_Pred));

        if (_UMid.second <= _UNth) {
            _UFirst = _UMid.second;
        } else if (_UMid.first <= _UNth) {
            return; 
        } else {
            _ULast = _UMid.first;
        }
    }

    _Insertion_sort_unchecked(_UFirst, _ULast, _Pass_fn(_Pred)); 
}

template <class _RanIt>
constexpr void nth_element(_RanIt _First, _RanIt _Nth, _RanIt _Last) { 
    ::std:: nth_element(_First, _Nth, _Last, less<>{});
}


template <class _ExPo, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
void nth_element(_ExPo&&, _RanIt _First, _RanIt _Nth, _RanIt _Last, _Pr _Pred) noexcept  {
    
    
    ::std:: nth_element(_First, _Nth, _Last, _Pass_fn(_Pred));
}

template <class _ExPo, class _RanIt, _Enable_if_execution_policy_t<_ExPo> = 0>
void nth_element(_ExPo&&, _RanIt _First, _RanIt _Nth, _RanIt _Last) noexcept  {
    
    
    ::std:: nth_element(_First, _Nth, _Last);
}


namespace ranges {
    class _Nth_element_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <random_access_iterator _It, sentinel_for<_It> _Se, class _Pr = ranges::less, class _Pj = identity>
            requires sortable<_It, _Pr, _Pj>
        constexpr _It operator()(_It _First, _It _Nth, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Nth);
            _Adl_verify_range(_Nth, _Last);
            auto _UNth   = _Get_unwrapped(_Nth);
            auto _UFinal = _Get_final_iterator_unwrapped<_It>(_UNth, ::std:: move(_Last));
            _Seek_wrapped(_Nth, _UFinal);

            _Nth_element_common(_Get_unwrapped(::std:: move(_First)), ::std:: move(_UNth), ::std:: move(_UFinal),
                _Pass_fn(_Pred), _Pass_fn(_Proj));
            return _Nth;
        }

        template <random_access_range _Rng, class _Pr = ranges::less, class _Pj = identity>
            requires sortable<iterator_t<_Rng>, _Pr, _Pj>
        constexpr borrowed_iterator_t<_Rng> operator()(
            _Rng&& _Range, iterator_t<_Rng> _Nth, _Pr _Pred = {}, _Pj _Proj = {}) const {
            _Adl_verify_range(::std::ranges:: begin(_Range), _Nth);
            _Adl_verify_range(_Nth, ::std::ranges:: end(_Range));
            auto _UNth   = _Get_unwrapped(_Nth);
            auto _UFinal = [&] {
                if constexpr (common_range<_Rng>) {
                    return _Uend(_Range);
                } else if constexpr (sized_range<_Rng>) {
                    return ::std::ranges:: next(_Ubegin(_Range), ::std::ranges:: distance(_Range));
                } else {
                    return ::std::ranges:: next(_UNth, _Uend(_Range));
                }
            }();
            _Seek_wrapped(_Nth, _UFinal);

            _Nth_element_common(
                _Ubegin(_Range), ::std:: move(_UNth), ::std:: move(_UFinal), _Pass_fn(_Pred), _Pass_fn(_Proj));
            return _Nth;
        }
        
    private:
        template <class _It, class _Pr, class _Pj>
        static constexpr void _Nth_element_common(_It _First, _It _Nth, _It _Last, _Pr _Pred, _Pj _Proj) {
            ;
            ;

            if (_Nth == _Last) {
                return; 
            }

            while (_ISORT_MAX < _Last - _First) { 
                subrange<_It> _Mid = _Partition_by_median_guess_common(_First, _Last, _Pred, _Proj);

                if (_Mid.end() <= _Nth) {
                    _First = _Mid.end();
                } else if (_Mid.begin() <= _Nth) {
                    return; 
                } else {
                    _Last = _Mid.begin();
                }
            }

            
            _Insertion_sort_common(::std:: move(_First), ::std:: move(_Last), _Pred, _Proj);
        }
    };

    inline constexpr _Nth_element_fn nth_element{_Not_quite_object::_Construct_tag{}};
} 
#line 8555 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
#line 8556 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _InIt1, class _InIt2, class _Pr>
[[nodiscard]] constexpr bool includes(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _Pr _Pred) {
    
    _Adl_verify_range(_First1, _Last1);
    _Adl_verify_range(_First2, _Last2);
    auto _UFirst1      = _Get_unwrapped(_First1);
    const auto _ULast1 = _Get_unwrapped(_Last1);
    auto _UFirst2      = _Get_unwrapped(_First2);
    const auto _ULast2 = _Get_unwrapped(_Last2);
    ;
    ;
    for (; _UFirst1 != _ULast1 && _UFirst2 != _ULast2; ++_UFirst1) {
        if (static_cast<bool>(_Pred(*_UFirst2, *_UFirst1))) {
            return false;
        }

        if (!_Pred(*_UFirst1, *_UFirst2)) {
            ++_UFirst2;
        }
    }

    return _UFirst2 == _ULast2;
}

template <class _InIt1, class _InIt2>
[[nodiscard]] constexpr bool includes(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2) {
    
    return ::std:: includes(_First1, _Last1, _First2, _Last2, less<>{});
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] bool includes(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred) noexcept
 {
    
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: includes(_First1, _Last1, _First2, _Last2, _Pass_fn(_Pred));
}

template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] bool includes(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2) noexcept
 {
    
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: includes(_First1, _Last1, _First2, _Last2);
}


namespace ranges {
    class _Includes_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2,
            class _Pj1 = identity, class _Pj2 = identity,
            indirect_strict_weak_order<projected<_It1, _Pj1>, projected<_It2, _Pj2>> _Pr = ranges::less>
        [[nodiscard]] constexpr bool operator()(_It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2, _Pr _Pred = {},
            _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            _Adl_verify_range(_First1, _Last1);
            _Adl_verify_range(_First2, _Last2);
            return _Includes_unchecked(_Get_unwrapped(::std:: move(_First1)), _Get_unwrapped(::std:: move(_Last1)),
                _Get_unwrapped(::std:: move(_First2)), _Get_unwrapped(::std:: move(_Last2)), _Pass_fn(_Pred),
                _Pass_fn(_Proj1), _Pass_fn(_Proj2));
        }

        template <input_range _Rng1, input_range _Rng2, class _Pj1 = identity, class _Pj2 = identity,
            indirect_strict_weak_order<projected<iterator_t<_Rng1>, _Pj1>, projected<iterator_t<_Rng2>, _Pj2>> _Pr =
                ranges::less>
        [[nodiscard]] constexpr bool operator()(
            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            return _Includes_unchecked(_Ubegin(_Range1), _Uend(_Range1), _Ubegin(_Range2), _Uend(_Range2),
                _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
        }

    private:
        template <class _It1, class _Se1, class _It2, class _Se2, class _Pr, class _Pj1, class _Pj2>
        [[nodiscard]] static constexpr bool _Includes_unchecked(
            _It1 _First1, const _Se1 _Last1, _It2 _First2, const _Se2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
            ;
            ;
            ;
            ;
            ;

            if (_First2 == _Last2) {
                return true;
            } else if (_First1 == _Last1) {
                return false;
            }

            for (;;) {
                if (::std:: invoke(_Pred, ::std:: invoke(_Proj1, *_First1), ::std:: invoke(_Proj2, *_First2))) {
                    ++_First1;
                    if (_First1 == _Last1) {
                        return false;
                    }

                    continue;
                }

                if (::std:: invoke(_Pred, ::std:: invoke(_Proj2, *_First2), ::std:: invoke(_Proj1, *_First1))) {
                    return false;
                }

                ++_First1;
                ++_First2;
                if (_First2 == _Last2) {
                    return true;
                } else if (_First1 == _Last1) {
                    return false;
                }
            }
        }
    };

    inline constexpr _Includes_fn includes{_Not_quite_object::_Construct_tag{}};
} 
#line 8679 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
#line 8680 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _InIt1, class _InIt2, class _OutIt, class _Pr>
constexpr _OutIt set_union(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred) {
    
    _Adl_verify_range(_First1, _Last1);
    _Adl_verify_range(_First2, _Last2);
    auto _UFirst1      = _Get_unwrapped(_First1);
    const auto _ULast1 = _Get_unwrapped(_Last1);
    auto _UFirst2      = _Get_unwrapped(_First2);
    const auto _ULast2 = _Get_unwrapped(_Last2);
    ;
    ;
    auto _UDest = _Get_unwrapped_unverified(_Dest);
    for (; _UFirst1 != _ULast1 && _UFirst2 != _ULast2; ++_UDest) {
        if (static_cast<bool>(_Pred(*_UFirst1, *_UFirst2))) { 
            *_UDest = *_UFirst1;
            ++_UFirst1;
        } else if (_Pred(*_UFirst2, *_UFirst1)) { 
            *_UDest = *_UFirst2;
            ++_UFirst2;
        } else { 
            *_UDest = *_UFirst1;
            ++_UFirst1;
            ++_UFirst2;
        }
    }

    _UDest = _Copy_unchecked(_UFirst1, _ULast1, _UDest);
    _Seek_wrapped(_Dest, _Copy_unchecked(_UFirst2, _ULast2, _UDest));
    return _Dest;
}

template <class _InIt1, class _InIt2, class _OutIt>
constexpr _OutIt set_union(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest) {
    
    return ::std:: set_union(_First1, _Last1, _First2, _Last2, _Dest, less<>{});
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt3 set_union(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _FwdIt3 _Dest,
    _Pr _Pred) noexcept  {
    
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt3>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: set_union(_First1, _Last1, _First2, _Last2, _Dest, _Pass_fn(_Pred));
}

template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt3 set_union(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _FwdIt3 _Dest) noexcept
 {
    
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt3>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: set_union(_First1, _Last1, _First2, _Last2, _Dest);
}


namespace ranges {
    template <class _In1, class _In2, class _Out>
    using set_union_result = in_in_out_result<_In1, _In2, _Out>;

    class _Set_union_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2,
            weakly_incrementable _Out, class _Pr = ranges::less, class _Pj1 = identity, class _Pj2 = identity>
            requires mergeable<_It1, _It2, _Out, _Pr, _Pj1, _Pj2>
        constexpr set_union_result<_It1, _It2, _Out> operator()(_It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2,
            _Out _Result, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            _Adl_verify_range(_First1, _Last1);
            _Adl_verify_range(_First2, _Last2);
            auto _UResult = _Set_union_unchecked(_Get_unwrapped(::std:: move(_First1)), _Get_unwrapped(::std:: move(_Last1)),
                _Get_unwrapped(::std:: move(_First2)), _Get_unwrapped(::std:: move(_Last2)),
                _Get_unwrapped_unverified(::std:: move(_Result)), _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
            _Seek_wrapped(_First1, ::std:: move(_UResult.in1));
            _Seek_wrapped(_First2, ::std:: move(_UResult.in2));
            _Seek_wrapped(_Result, ::std:: move(_UResult.out));
            return {::std:: move(_First1), ::std:: move(_First2), ::std:: move(_Result)};
        }

        template <input_range _Rng1, input_range _Rng2, weakly_incrementable _Out, class _Pr = ranges::less,
            class _Pj1 = identity, class _Pj2 = identity>
            requires mergeable<iterator_t<_Rng1>, iterator_t<_Rng2>, _Out, _Pr, _Pj1, _Pj2>
        constexpr set_union_result<borrowed_iterator_t<_Rng1>, borrowed_iterator_t<_Rng2>, _Out> operator()(
            _Rng1&& _Range1, _Rng2&& _Range2, _Out _Result, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            auto _First1  = ::std::ranges:: begin(_Range1);
            auto _First2  = ::std::ranges:: begin(_Range2);
            auto _UResult = _Set_union_unchecked(_Get_unwrapped(::std:: move(_First1)), _Uend(_Range1),
                _Get_unwrapped(::std:: move(_First2)), _Uend(_Range2), _Get_unwrapped_unverified(::std:: move(_Result)),
                _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
            _Seek_wrapped(_First1, ::std:: move(_UResult.in1));
            _Seek_wrapped(_First2, ::std:: move(_UResult.in2));
            _Seek_wrapped(_Result, ::std:: move(_UResult.out));
            return {::std:: move(_First1), ::std:: move(_First2), ::std:: move(_Result)};
        }
        
    private:
        template <class _It1, class _Se1, class _It2, class _Se2, class _Out, class _Pr, class _Pj1, class _Pj2>
        [[nodiscard]] static constexpr set_union_result<_It1, _It2, _Out> _Set_union_unchecked(_It1 _First1,
            const _Se1 _Last1, _It2 _First2, const _Se2 _Last2, _Out _Result, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
            ;
            ;
            ;
            ;
            ;
            ;

            for (; _First1 != _Last1 && _First2 != _Last2; ++_Result) {
                if (::std:: invoke(_Pred, ::std:: invoke(_Proj2, *_First2), ::std:: invoke(_Proj1, *_First1))) {
                    *_Result = *_First2;
                    ++_First2;
                } else {
                    *_Result = *_First1;
                    if (!::std:: invoke(_Pred, ::std:: invoke(_Proj1, *_First1), ::std:: invoke(_Proj2, *_First2))) {
                        ++_First2;
                    }
                    ++_First1;
                }
            }

            auto _UResult1 = ::std::ranges:: _Copy_unchecked(::std:: move(_First1), ::std:: move(_Last1), ::std:: move(_Result));
            auto _UResult2 = ::std::ranges:: _Copy_unchecked(::std:: move(_First2), ::std:: move(_Last2), ::std:: move(_UResult1.out));
            return {::std:: move(_UResult1.in), ::std:: move(_UResult2.in), ::std:: move(_UResult2.out)};
        }
    };

    inline constexpr _Set_union_fn set_union{_Not_quite_object::_Construct_tag{}};
} 
#line 8816 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
#line 8817 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _InIt1, class _InIt2, class _OutIt, class _Pr>
constexpr _OutIt set_intersection(
    _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred) {
    
    _Adl_verify_range(_First1, _Last1);
    _Adl_verify_range(_First2, _Last2);
    auto _UFirst1      = _Get_unwrapped(_First1);
    const auto _ULast1 = _Get_unwrapped(_Last1);
    auto _UFirst2      = _Get_unwrapped(_First2);
    const auto _ULast2 = _Get_unwrapped(_Last2);
    ;
    ;
    auto _UDest = _Get_unwrapped_unverified(_Dest);
    while (_UFirst1 != _ULast1 && _UFirst2 != _ULast2) {
        if (static_cast<bool>(_Pred(*_UFirst1, *_UFirst2))) {
            ++_UFirst1;
        } else if (_Pred(*_UFirst2, *_UFirst1)) {
            ++_UFirst2;
        } else {
            *_UDest = *_UFirst1;
            ++_UDest;
            ++_UFirst1;
            ++_UFirst2;
        }
    }

    _Seek_wrapped(_Dest, _UDest);
    return _Dest;
}

template <class _InIt1, class _InIt2, class _OutIt>
constexpr _OutIt set_intersection(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest) {
    
    return ::std:: set_intersection(_First1, _Last1, _First2, _Last2, _Dest, less<>{});
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt3 set_intersection(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _FwdIt3 _Dest,
    _Pr _Pred) noexcept; 

template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt3 set_intersection(_ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2,
    _FwdIt3 _Dest) noexcept  {
    
    return ::std:: set_intersection(::std:: forward<_ExPo>(_Exec), _First1, _Last1, _First2, _Last2, _Dest, less{});
}


namespace ranges {
    template <class _In1, class _In2, class _Out>
    using set_intersection_result = in_in_out_result<_In1, _In2, _Out>;

    class _Set_intersection_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2,
            weakly_incrementable _Out, class _Pr = ranges::less, class _Pj1 = identity, class _Pj2 = identity>
            requires mergeable<_It1, _It2, _Out, _Pr, _Pj1, _Pj2>
        constexpr set_intersection_result<_It1, _It2, _Out> operator()(_It1 _First1, _Se1 _Last1, _It2 _First2,
            _Se2 _Last2, _Out _Result, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            _Adl_verify_range(_First1, _Last1);
            _Adl_verify_range(_First2, _Last2);
            auto _UResult =
                _Set_intersection_unchecked(_Get_unwrapped(::std:: move(_First1)), _Get_unwrapped(::std:: move(_Last1)),
                    _Get_unwrapped(::std:: move(_First2)), _Get_unwrapped(::std:: move(_Last2)),
                    _Get_unwrapped_unverified(::std:: move(_Result)), _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
            _Seek_wrapped(_First1, ::std:: move(_UResult.in1));
            _Seek_wrapped(_First2, ::std:: move(_UResult.in2));
            _Seek_wrapped(_Result, ::std:: move(_UResult.out));
            return {::std:: move(_First1), ::std:: move(_First2), ::std:: move(_Result)};
        }

        template <input_range _Rng1, input_range _Rng2, weakly_incrementable _Out, class _Pr = ranges::less,
            class _Pj1 = identity, class _Pj2 = identity>
            requires mergeable<iterator_t<_Rng1>, iterator_t<_Rng2>, _Out, _Pr, _Pj1, _Pj2>
        constexpr set_intersection_result<borrowed_iterator_t<_Rng1>, borrowed_iterator_t<_Rng2>, _Out> operator()(
            _Rng1&& _Range1, _Rng2&& _Range2, _Out _Result, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            auto _First1  = ::std::ranges:: begin(_Range1);
            auto _First2  = ::std::ranges:: begin(_Range2);
            auto _UResult = _Set_intersection_unchecked(_Get_unwrapped(::std:: move(_First1)), _Uend(_Range1),
                _Get_unwrapped(::std:: move(_First2)), _Uend(_Range2), _Get_unwrapped_unverified(::std:: move(_Result)),
                _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
            _Seek_wrapped(_First1, ::std:: move(_UResult.in1));
            _Seek_wrapped(_First2, ::std:: move(_UResult.in2));
            _Seek_wrapped(_Result, ::std:: move(_UResult.out));
            return {::std:: move(_First1), ::std:: move(_First2), ::std:: move(_Result)};
        }
        
    private:
        template <class _It1, class _Se1, class _It2, class _Se2, class _Out, class _Pr, class _Pj1, class _Pj2>
        [[nodiscard]] static constexpr set_intersection_result<_It1, _It2, _Out> _Set_intersection_unchecked(_It1 _First1,
            const _Se1 _Last1, _It2 _First2, const _Se2 _Last2, _Out _Result, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
            ;
            ;
            ;
            ;
            ;
            ;

            for (;;) {
                if (_First1 == _Last1) {
                    ::std::ranges:: advance(_First2, _Last2);
                    break;
                } else if (_First2 == _Last2) {
                    ::std::ranges:: advance(_First1, _Last1);
                    break;
                }

                if (::std:: invoke(_Pred, ::std:: invoke(_Proj1, *_First1), ::std:: invoke(_Proj2, *_First2))) {
                    ++_First1;
                } else if (::std:: invoke(_Pred, ::std:: invoke(_Proj2, *_First2), ::std:: invoke(_Proj1, *_First1))) {
                    ++_First2;
                } else {
                    *_Result = *_First1;
                    ++_Result;
                    ++_First1;
                    ++_First2;
                }
            }

            return {::std:: move(_First1), ::std:: move(_First2), ::std:: move(_Result)};
        }
    };

    inline constexpr _Set_intersection_fn set_intersection{_Not_quite_object::_Construct_tag{}};
} 
#line 8948 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
#line 8949 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _InIt1, class _InIt2, class _OutIt, class _Pr>
constexpr _OutIt set_difference(
    _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred) {
    
    _Adl_verify_range(_First1, _Last1);
    _Adl_verify_range(_First2, _Last2);
    auto _UFirst1      = _Get_unwrapped(_First1);
    const auto _ULast1 = _Get_unwrapped(_Last1);
    auto _UFirst2      = _Get_unwrapped(_First2);
    const auto _ULast2 = _Get_unwrapped(_Last2);
    ;
    ;
    auto _UDest = _Get_unwrapped_unverified(_Dest);
    while (_UFirst1 != _ULast1 && _UFirst2 != _ULast2) {
        if (static_cast<bool>(_Pred(*_UFirst1, *_UFirst2))) { 
            *_UDest = *_UFirst1;
            ++_UDest;
            ++_UFirst1;
        } else {
            if (!_Pred(*_UFirst2, *_UFirst1)) {
                ++_UFirst1;
            }

            ++_UFirst2;
        }
    }

    _Seek_wrapped(_Dest, _Copy_unchecked(_UFirst1, _ULast1, _UDest));
    return _Dest;
}

template <class _InIt1, class _InIt2, class _OutIt>
constexpr _OutIt set_difference(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest) {
    
    return ::std:: set_difference(_First1, _Last1, _First2, _Last2, _Dest, less<>{});
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt3 set_difference(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _FwdIt3 _Dest,
    _Pr _Pred) noexcept; 

template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt3 set_difference(_ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2,
    _FwdIt3 _Dest) noexcept  {
    
    return ::std:: set_difference(::std:: forward<_ExPo>(_Exec), _First1, _Last1, _First2, _Last2, _Dest, less{});
}


namespace ranges {
    template <class _In, class _Out>
    using set_difference_result = in_out_result<_In, _Out>;

    class _Set_difference_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2,
            weakly_incrementable _Out, class _Pr = ranges::less, class _Pj1 = identity, class _Pj2 = identity>
            requires mergeable<_It1, _It2, _Out, _Pr, _Pj1, _Pj2>
        constexpr set_difference_result<_It1, _Out> operator()(_It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2,
            _Out _Result, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            _Adl_verify_range(_First1, _Last1);
            _Adl_verify_range(_First2, _Last2);
            auto _UResult =
                _Set_difference_unchecked(_Get_unwrapped(::std:: move(_First1)), _Get_unwrapped(::std:: move(_Last1)),
                    _Get_unwrapped(::std:: move(_First2)), _Get_unwrapped(::std:: move(_Last2)),
                    _Get_unwrapped_unverified(::std:: move(_Result)), _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
            _Seek_wrapped(_First1, ::std:: move(_UResult.in));
            _Seek_wrapped(_Result, ::std:: move(_UResult.out));
            return {::std:: move(_First1), ::std:: move(_Result)};
        }

        template <input_range _Rng1, input_range _Rng2, weakly_incrementable _Out, class _Pr = ranges::less,
            class _Pj1 = identity, class _Pj2 = identity>
            requires mergeable<iterator_t<_Rng1>, iterator_t<_Rng2>, _Out, _Pr, _Pj1, _Pj2>
        constexpr set_difference_result<borrowed_iterator_t<_Rng1>, _Out> operator()(
            _Rng1&& _Range1, _Rng2&& _Range2, _Out _Result, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            auto _First1  = ::std::ranges:: begin(_Range1);
            auto _UResult = _Set_difference_unchecked(_Get_unwrapped(::std:: move(_First1)), _Uend(_Range1),
                _Ubegin(_Range2), _Uend(_Range2), _Get_unwrapped_unverified(::std:: move(_Result)), _Pass_fn(_Pred),
                _Pass_fn(_Proj1), _Pass_fn(_Proj2));
            _Seek_wrapped(_First1, ::std:: move(_UResult.in));
            _Seek_wrapped(_Result, ::std:: move(_UResult.out));
            return {::std:: move(_First1), ::std:: move(_Result)};
        }
        
    private:
        template <class _It1, class _Se1, class _It2, class _Se2, class _Out, class _Pr, class _Pj1, class _Pj2>
        [[nodiscard]] static constexpr set_difference_result<_It1, _Out> _Set_difference_unchecked(_It1 _First1,
            const _Se1 _Last1, _It2 _First2, const _Se2 _Last2, _Out _Result, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
            ;
            ;
            ;
            ;
            ;
            ;

            for (;;) {
                if (_First1 == _Last1) {
                    return {::std:: move(_First1), ::std:: move(_Result)};
                }

                if (_First2 == _Last2) {
                    return ::std::ranges:: _Copy_unchecked(::std:: move(_First1), ::std:: move(_Last1), ::std:: move(_Result));
                }

                if (::std:: invoke(_Pred, ::std:: invoke(_Proj1, *_First1), ::std:: invoke(_Proj2, *_First2))) {
                    *_Result = *_First1;
                    ++_Result;
                    ++_First1;
                } else {
                    if (!::std:: invoke(_Pred, ::std:: invoke(_Proj2, *_First2), ::std:: invoke(_Proj1, *_First1))) {
                        ++_First1;
                    }

                    ++_First2;
                }
            }
        }
    };

    inline constexpr _Set_difference_fn set_difference{_Not_quite_object::_Construct_tag{}};
} 
#line 9077 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
#line 9078 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _InIt1, class _InIt2, class _OutIt, class _Pr>
constexpr _OutIt set_symmetric_difference(
    _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred) {
    
    _Adl_verify_range(_First1, _Last1);
    _Adl_verify_range(_First2, _Last2);
    auto _UFirst1      = _Get_unwrapped(_First1);
    const auto _ULast1 = _Get_unwrapped(_Last1);
    auto _UFirst2      = _Get_unwrapped(_First2);
    const auto _ULast2 = _Get_unwrapped(_Last2);
    ;
    ;
    auto _UDest = _Get_unwrapped_unverified(_Dest);
    while (_UFirst1 != _ULast1 && _UFirst2 != _ULast2) {
        if (static_cast<bool>(_Pred(*_UFirst1, *_UFirst2))) { 
            *_UDest = *_UFirst1;
            ++_UDest;
            ++_UFirst1;
        } else if (_Pred(*_UFirst2, *_UFirst1)) { 
            *_UDest = *_UFirst2;
            ++_UDest;
            ++_UFirst2;
        } else { 
            ++_UFirst1;
            ++_UFirst2;
        }
    }

    _UDest = _Copy_unchecked(_UFirst1, _ULast1, _UDest);
    _Seek_wrapped(_Dest, _Copy_unchecked(_UFirst2, _ULast2, _UDest));
    return _Dest;
}

template <class _InIt1, class _InIt2, class _OutIt>
constexpr _OutIt set_symmetric_difference(
    _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest) {
    
    return ::std:: set_symmetric_difference(_First1, _Last1, _First2, _Last2, _Dest, less<>{});
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt3 set_symmetric_difference(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2,
    _FwdIt3 _Dest, _Pr _Pred) noexcept  {
    
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt3>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: set_symmetric_difference(_First1, _Last1, _First2, _Last2, _Dest, _Pass_fn(_Pred));
}

template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt3 set_symmetric_difference(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2,
    _FwdIt3 _Dest) noexcept  {
    
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt3>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: set_symmetric_difference(_First1, _Last1, _First2, _Last2, _Dest);
}


namespace ranges {
    template <class _In1, class _In2, class _Out>
    using set_symmetric_difference_result = in_in_out_result<_In1, _In2, _Out>;

    class _Set_symmetric_difference_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2,
            weakly_incrementable _Out, class _Pr = ranges::less, class _Pj1 = identity, class _Pj2 = identity>
            requires mergeable<_It1, _It2, _Out, _Pr, _Pj1, _Pj2>
        constexpr set_symmetric_difference_result<_It1, _It2, _Out> operator()(_It1 _First1, _Se1 _Last1, _It2 _First2,
            _Se2 _Last2, _Out _Result, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            _Adl_verify_range(_First1, _Last1);
            _Adl_verify_range(_First2, _Last2);
            auto _UResult = _Set_symmetric_difference_unchecked(_Get_unwrapped(::std:: move(_First1)),
                _Get_unwrapped(::std:: move(_Last1)), _Get_unwrapped(::std:: move(_First2)),
                _Get_unwrapped(::std:: move(_Last2)), _Get_unwrapped_unverified(::std:: move(_Result)), _Pass_fn(_Pred),
                _Pass_fn(_Proj1), _Pass_fn(_Proj2));
            _Seek_wrapped(_First1, ::std:: move(_UResult.in1));
            _Seek_wrapped(_First2, ::std:: move(_UResult.in2));
            _Seek_wrapped(_Result, ::std:: move(_UResult.out));
            return {::std:: move(_First1), ::std:: move(_First2), ::std:: move(_Result)};
        }

        template <input_range _Rng1, input_range _Rng2, weakly_incrementable _Out, class _Pr = ranges::less,
            class _Pj1 = identity, class _Pj2 = identity>
            requires mergeable<iterator_t<_Rng1>, iterator_t<_Rng2>, _Out, _Pr, _Pj1, _Pj2>
        constexpr set_symmetric_difference_result<borrowed_iterator_t<_Rng1>, borrowed_iterator_t<_Rng2>, _Out>
            operator()(_Rng1&& _Range1, _Rng2&& _Range2, _Out _Result, _Pr _Pred = {}, _Pj1 _Proj1 = {},
                _Pj2 _Proj2 = {}) const {
            auto _First1  = ::std::ranges:: begin(_Range1);
            auto _First2  = ::std::ranges:: begin(_Range2);
            auto _UResult = _Set_symmetric_difference_unchecked(_Get_unwrapped(::std:: move(_First1)), _Uend(_Range1),
                _Get_unwrapped(::std:: move(_First2)), _Uend(_Range2), _Get_unwrapped_unverified(::std:: move(_Result)),
                _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
            _Seek_wrapped(_First1, ::std:: move(_UResult.in1));
            _Seek_wrapped(_First2, ::std:: move(_UResult.in2));
            _Seek_wrapped(_Result, ::std:: move(_UResult.out));
            return {::std:: move(_First1), ::std:: move(_First2), ::std:: move(_Result)};
        }
        
    private:
        template <class _It1, class _Se1, class _It2, class _Se2, class _Out, class _Pr, class _Pj1, class _Pj2>
        [[nodiscard]] static constexpr set_symmetric_difference_result<_It1, _It2, _Out>
            _Set_symmetric_difference_unchecked(_It1 _First1, const _Se1 _Last1, _It2 _First2, const _Se2 _Last2,
                _Out _Result, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
            ;
            ;
            ;
            ;
            ;
            ;

            for (;;) {
                if (_First1 == _Last1) {
                    auto _UResult = ::std::ranges:: _Copy_unchecked(::std:: move(_First2), ::std:: move(_Last2), ::std:: move(_Result));
                    return {::std:: move(_First1), ::std:: move(_UResult.in), ::std:: move(_UResult.out)};
                }

                if (_First2 == _Last2) {
                    auto _UResult = ::std::ranges:: _Copy_unchecked(::std:: move(_First1), ::std:: move(_Last1), ::std:: move(_Result));
                    return {::std:: move(_UResult.in), ::std:: move(_First2), ::std:: move(_UResult.out)};
                }

                if (::std:: invoke(_Pred, ::std:: invoke(_Proj1, *_First1), ::std:: invoke(_Proj2, *_First2))) {
                    *_Result = *_First1;
                    ++_Result;
                    ++_First1;
                } else if (::std:: invoke(_Pred, ::std:: invoke(_Proj2, *_First2), ::std:: invoke(_Proj1, *_First1))) {
                    *_Result = *_First2;
                    ++_Result;
                    ++_First2;
                } else {
                    ++_First1;
                    ++_First2;
                }
            }
        }
    };

    inline constexpr _Set_symmetric_difference_fn set_symmetric_difference{_Not_quite_object::_Construct_tag{}};
} 
#line 9228 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
#line 9229 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _FwdIt, class _Pr>
constexpr _FwdIt _Max_element_unchecked(_FwdIt _First, _FwdIt _Last, _Pr _Pred) { 
    _FwdIt _Found = _First;
    if (_First != _Last) {
        while (++_First != _Last) {
            if (static_cast<bool>(_Pred(*_Found, *_First))) {
                _Found = _First;
            }
        }
    }

    return _Found;
}

template <class _FwdIt, class _Pr>
[[nodiscard]] constexpr _FwdIt max_element(_FwdIt _First, _FwdIt _Last, _Pr _Pred) { 
    _Adl_verify_range(_First, _Last);
    _Seek_wrapped(_First, _Max_element_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last), _Pass_fn(_Pred)));
    return _First;
}

template <class _FwdIt>
[[nodiscard]] constexpr _FwdIt max_element(_FwdIt _First, _FwdIt _Last) { 
    return ::std:: max_element(_First, _Last, less<>{});
}


template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _FwdIt max_element(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept  {
    
    
    return ::std:: max_element(_First, _Last, _Pass_fn(_Pred));
}

template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _FwdIt max_element(_ExPo&&, _FwdIt _First, _FwdIt _Last) noexcept  {
    
    
    return ::std:: max_element(_First, _Last);
}


namespace ranges {
    template <class _It, class _Se, class _Pr, class _Pj>
    [[nodiscard]] constexpr _It _Max_element_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
        ;
        ;
        ;

        auto _Found = _First;
        if (_First == _Last) {
            return _Found;
        }

        while (++_First != _Last) {
            if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Found), ::std:: invoke(_Proj, *_First))) {
                _Found = _First;
            }
        }

        return _Found;
    }

    class _Max_element_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <forward_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
            indirect_strict_weak_order<projected<_It, _Pj>> _Pr = ranges::less>
        [[nodiscard]] constexpr _It operator()(_It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            _Seek_wrapped(_First, ::std::ranges:: _Max_element_unchecked(_Get_unwrapped(::std:: move(_First)),
                                      _Get_unwrapped(::std:: move(_Last)), _Pass_fn(_Pred), _Pass_fn(_Proj)));
            return _First;
        }

        template <forward_range _Rng, class _Pj = identity,
            indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
        [[nodiscard]] constexpr borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) const {
            auto _First = ::std::ranges:: begin(_Range);
            _Seek_wrapped(_First, ::std::ranges:: _Max_element_unchecked(_Get_unwrapped(::std:: move(_First)), _Uend(_Range),
                                      _Pass_fn(_Pred), _Pass_fn(_Proj)));
            return _First;
        }
    };

    inline constexpr _Max_element_fn max_element{_Not_quite_object::_Construct_tag{}};
} 
#line 9319 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
#line 9320 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _FwdIt, class _Pr>
constexpr _FwdIt _Min_element_unchecked(_FwdIt _First, _FwdIt _Last, _Pr _Pred) { 
    _FwdIt _Found = _First;
    if (_First != _Last) {
        while (++_First != _Last) {
            if (static_cast<bool>(_Pred(*_First, *_Found))) {
                _Found = _First;
            }
        }
    }

    return _Found;
}

template <class _FwdIt, class _Pr>
[[nodiscard]] constexpr _FwdIt min_element(_FwdIt _First, _FwdIt _Last, _Pr _Pred) { 
    _Adl_verify_range(_First, _Last);
    _Seek_wrapped(_First, _Min_element_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last), _Pass_fn(_Pred)));
    return _First;
}

template <class _FwdIt>
[[nodiscard]] constexpr _FwdIt min_element(_FwdIt _First, _FwdIt _Last) { 
    return ::std:: min_element(_First, _Last, less<>{});
}


template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _FwdIt min_element(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept  {
    
    
    return ::std:: min_element(_First, _Last, _Pass_fn(_Pred));
}

template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _FwdIt min_element(_ExPo&&, _FwdIt _First, _FwdIt _Last) noexcept  {
    
    
    return ::std:: min_element(_First, _Last);
}


namespace ranges {
    template <class _It, class _Se, class _Pr, class _Pj>
    [[nodiscard]] constexpr _It _Min_element_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
        ;
        ;
        ;

        auto _Found = _First;
        if (_First == _Last) {
            return _Found;
        }

        while (++_First != _Last) {
            if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_First), ::std:: invoke(_Proj, *_Found))) {
                _Found = _First;
            }
        }

        return _Found;
    }

    class _Min_element_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <forward_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
            indirect_strict_weak_order<projected<_It, _Pj>> _Pr = ranges::less>
        [[nodiscard]] constexpr _It operator()(_It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            _Seek_wrapped(_First, ::std::ranges:: _Min_element_unchecked(_Get_unwrapped(::std:: move(_First)),
                                      _Get_unwrapped(::std:: move(_Last)), _Pass_fn(_Pred), _Pass_fn(_Proj)));
            return _First;
        }

        template <forward_range _Rng, class _Pj = identity,
            indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
        [[nodiscard]] constexpr borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) const {
            auto _First = ::std::ranges:: begin(_Range);
            _Seek_wrapped(_First, ::std::ranges:: _Min_element_unchecked(_Get_unwrapped(::std:: move(_First)), _Uend(_Range),
                                      _Pass_fn(_Pred), _Pass_fn(_Proj)));
            return _First;
        }
    };

    inline constexpr _Min_element_fn min_element{_Not_quite_object::_Construct_tag{}};
} 
#line 9410 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
#line 9411 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _FwdIt, class _Pr>
constexpr pair<_FwdIt, _FwdIt> _Minmax_element_unchecked(_FwdIt _First, _FwdIt _Last, _Pr _Pred) {
    
    pair<_FwdIt, _FwdIt> _Found(_First, _First);

    if (_First != _Last) {
        while (++_First != _Last) { 
            _FwdIt _Next = _First;
            if (++_Next == _Last) { 
                if (static_cast<bool>(_Pred(*_First, *_Found.first))) {
                    _Found.first = _First;
                } else if (!static_cast<bool>(_Pred(*_First, *_Found.second))) {
                    _Found.second = _First;
                }
            } else { 
                if (static_cast<bool>(_Pred(*_Next, *_First))) { 
                    if (static_cast<bool>(_Pred(*_Next, *_Found.first))) {
                        _Found.first = _Next;
                    }
                    if (!static_cast<bool>(_Pred(*_First, *_Found.second))) {
                        _Found.second = _First;
                    }
                } else { 
                    if (static_cast<bool>(_Pred(*_First, *_Found.first))) {
                        _Found.first = _First;
                    }
                    if (!static_cast<bool>(_Pred(*_Next, *_Found.second))) {
                        _Found.second = _Next;
                    }
                }
                _First = _Next;
            }
        }
    }

    return _Found;
}

template <class _FwdIt, class _Pr>
[[nodiscard]] constexpr pair<_FwdIt, _FwdIt> minmax_element(_FwdIt _First, _FwdIt _Last, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Last);
    const auto _Result = _Minmax_element_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last), _Pass_fn(_Pred));
    _Seek_wrapped(_Last, _Result.second);
    _Seek_wrapped(_First, _Result.first);
    return {_First, _Last};
}

template <class _FwdIt>
[[nodiscard]] constexpr pair<_FwdIt, _FwdIt> minmax_element(_FwdIt _First, _FwdIt _Last) {
    
    return ::std:: minmax_element(_First, _Last, less<>{});
}


template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] pair<_FwdIt, _FwdIt> minmax_element(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept
 {
    
    
    return ::std:: minmax_element(_First, _Last, _Pass_fn(_Pred));
}

template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] pair<_FwdIt, _FwdIt> minmax_element(_ExPo&&, _FwdIt _First, _FwdIt _Last) noexcept  {
    
    
    return ::std:: minmax_element(_First, _Last);
}


namespace ranges {
    template <class _Ty>
    using minmax_element_result = min_max_result<_Ty>;

    template <class _It, class _Se, class _Pr, class _Pj>
    constexpr min_max_result<_It> _Minmax_element_unchecked(_It _First, const _Se _Last, _Pr _Pred, _Pj _Proj) {
        ;
        ;
        ;

        min_max_result<_It> _Found{_First, _First};

        if (_First == _Last) {
            return _Found;
        }

        while (++_First != _Last) { 
            _It _Prev = _First;
            if (++_First == _Last) { 
                if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Prev), ::std:: invoke(_Proj, *_Found.min))) {
                    _Found.min = _Prev;
                } else if (!::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Prev), ::std:: invoke(_Proj, *_Found.max))) {
                    _Found.max = _Prev;
                }

                break;
            }

            
            if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_First), ::std:: invoke(_Proj, *_Prev))) {
                
                if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_First), ::std:: invoke(_Proj, *_Found.min))) {
                    _Found.min = _First;
                }

                if (!::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Prev), ::std:: invoke(_Proj, *_Found.max))) {
                    _Found.max = _Prev;
                }
            } else { 
                if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Prev), ::std:: invoke(_Proj, *_Found.min))) {
                    _Found.min = _Prev;
                }

                if (!::std:: invoke(_Pred, ::std:: invoke(_Proj, *_First), ::std:: invoke(_Proj, *_Found.max))) {
                    _Found.max = _First;
                }
            }
        }

        return _Found;
    }

    class _Minmax_element_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <forward_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
            indirect_strict_weak_order<projected<_It, _Pj>> _Pr = ranges::less>
        [[nodiscard]] constexpr minmax_element_result<_It> operator()(
            _It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            auto _UResult = ::std::ranges:: _Minmax_element_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)), _Pass_fn(_Pred), _Pass_fn(_Proj));
            _Seek_wrapped(_First, ::std:: move(_UResult.min));
            auto _Second = _First;
            _Seek_wrapped(_Second, ::std:: move(_UResult.max));
            return {::std:: move(_First), ::std:: move(_Second)};
        }

        template <forward_range _Rng, class _Pj = identity,
            indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
        [[nodiscard]] constexpr minmax_element_result<borrowed_iterator_t<_Rng>> operator()(
            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) const {
            auto _First   = ::std::ranges:: begin(_Range);
            auto _UResult = ::std::ranges:: _Minmax_element_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Uend(_Range), _Pass_fn(_Pred), _Pass_fn(_Proj));
            _Seek_wrapped(_First, ::std:: move(_UResult.min));
            auto _Second = _First;
            _Seek_wrapped(_Second, ::std:: move(_UResult.max));
            return {::std:: move(_First), ::std:: move(_Second)};
        }
    };

    inline constexpr _Minmax_element_fn minmax_element{_Not_quite_object::_Construct_tag{}};
} 
#line 9569 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
#line 9570 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _Ty, class _Pr>
[[nodiscard]] constexpr _Ty(max)(initializer_list<_Ty> _Ilist, _Pr _Pred) {
    
    const _Ty* _Res = _Max_element_unchecked(_Ilist.begin(), _Ilist.end(), _Pass_fn(_Pred));
    return *_Res;
}

template <class _Ty>
[[nodiscard]] constexpr _Ty(max)(initializer_list<_Ty> _Ilist) {
    
    return (::std:: max)(_Ilist, less<>{});
}


namespace ranges {
    template <class _It>
    concept _Prefer_iterator_copies = 
                                      
        sizeof(_It) <= 2 * sizeof(iter_value_t<_It>)
        && (is_trivially_copyable_v<_It> || !is_trivially_copyable_v<iter_value_t<_It>>);

    class _Max_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <class _Ty, class _Pj = identity,
            indirect_strict_weak_order<projected<const _Ty*, _Pj>> _Pr = ranges::less>
        [[nodiscard]] constexpr const _Ty& operator()(
            const _Ty& _Left, const _Ty& _Right, _Pr _Pred = {}, _Pj _Proj = {}) const {
            if (::std:: invoke(_Pred, ::std:: invoke(_Proj, _Left), ::std:: invoke(_Proj, _Right))) {
                return _Right;
            } else {
                return _Left;
            }
        }

        template <copyable _Ty, class _Pj = identity,
            indirect_strict_weak_order<projected<const _Ty*, _Pj>> _Pr = ranges::less>
        [[nodiscard]] constexpr _Ty operator()(initializer_list<_Ty> _Range, _Pr _Pred = {}, _Pj _Proj = {}) const {
            const auto _First = _Range.begin();
            const auto _Last  = _Range.end();
            ;
#line 9614 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
            return *::std::ranges:: _Max_element_unchecked(_First, _Last, _Pass_fn(_Pred), _Pass_fn(_Proj));
        }

        
        template <input_range _Rng, class _Pj = identity,
            indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
            requires indirectly_copyable_storable<iterator_t<_Rng>, range_value_t<_Rng>*>
        [[nodiscard]] constexpr range_value_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) const {
            auto _UFirst = _Ubegin(_Range);
            auto _ULast  = _Uend(_Range);
            ;
#line 9626 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
            if constexpr (forward_range<_Rng> && _Prefer_iterator_copies<iterator_t<_Rng>>) {
                return static_cast<range_value_t<_Rng>>(*::std::ranges:: _Max_element_unchecked(
                    ::std:: move(_UFirst), ::std:: move(_ULast), _Pass_fn(_Pred), _Pass_fn(_Proj)));
            } else {
                range_value_t<_Rng> _Found(*_UFirst);
                while (++_UFirst != _ULast) {
                    if (::std:: invoke(_Pred, ::std:: invoke(_Proj, _Found), ::std:: invoke(_Proj, *_UFirst))) {
                        _Found = *_UFirst;
                    }
                }

                return _Found;
            }
        }
        
    };

    inline constexpr _Max_fn max{_Not_quite_object::_Construct_tag{}};
} 
#line 9646 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _Ty, class _Pr>
[[nodiscard]] constexpr _Ty(min)(initializer_list<_Ty> _Ilist, _Pr _Pred) {
    
    const _Ty* _Res = _Min_element_unchecked(_Ilist.begin(), _Ilist.end(), _Pass_fn(_Pred));
    return *_Res;
}

template <class _Ty>
[[nodiscard]] constexpr _Ty(min)(initializer_list<_Ty> _Ilist) {
    
    return (::std:: min)(_Ilist, less<>{});
}


namespace ranges {
    class _Min_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <class _Ty, class _Pj = identity,
            indirect_strict_weak_order<projected<const _Ty*, _Pj>> _Pr = ranges::less>
        [[nodiscard]] constexpr const _Ty& operator()(
            const _Ty& _Left, const _Ty& _Right, _Pr _Pred = {}, _Pj _Proj = {}) const {
            if (::std:: invoke(_Pred, ::std:: invoke(_Proj, _Right), ::std:: invoke(_Proj, _Left))) {
                return _Right;
            } else {
                return _Left;
            }
        }

        template <copyable _Ty, class _Pj = identity,
            indirect_strict_weak_order<projected<const _Ty*, _Pj>> _Pr = ranges::less>
        [[nodiscard]] constexpr _Ty operator()(initializer_list<_Ty> _Range, _Pr _Pred = {}, _Pj _Proj = {}) const {
            const auto _First = _Range.begin();
            const auto _Last  = _Range.end();
            ;
#line 9684 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
            return *::std::ranges:: _Min_element_unchecked(_First, _Last, _Pass_fn(_Pred), _Pass_fn(_Proj));
        }

        
        template <input_range _Rng, class _Pj = identity,
            indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
            requires indirectly_copyable_storable<iterator_t<_Rng>, range_value_t<_Rng>*>
        [[nodiscard]] constexpr range_value_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) const {
            auto _UFirst = _Ubegin(_Range);
            auto _ULast  = _Uend(_Range);
            ;
#line 9696 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
            if constexpr (forward_range<_Rng> && _Prefer_iterator_copies<iterator_t<_Rng>>) {
                return static_cast<range_value_t<_Rng>>(*::std::ranges:: _Min_element_unchecked(
                    ::std:: move(_UFirst), ::std:: move(_ULast), _Pass_fn(_Pred), _Pass_fn(_Proj)));
            } else {
                range_value_t<_Rng> _Found(*_UFirst);
                while (++_UFirst != _ULast) {
                    if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_UFirst), ::std:: invoke(_Proj, _Found))) {
                        _Found = *_UFirst;
                    }
                }

                return _Found;
            }
        }
        
    };

    inline constexpr _Min_fn min{_Not_quite_object::_Construct_tag{}};
} 
#line 9716 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _Ty, class _Pr>
[[nodiscard]] constexpr pair<const _Ty&, const _Ty&> minmax(const _Ty& _Left, const _Ty& _Right, _Pr _Pred) noexcept(
    noexcept(static_cast<bool>(_Pred(_Right, _Left))))  {
    
    if (static_cast<bool>(_Pred(_Right, _Left))) {
        return {_Right, _Left};
    }

    return {_Left, _Right};
}

template <class _Ty, class _Pr>
[[nodiscard]] constexpr pair<_Ty, _Ty> minmax(initializer_list<_Ty> _Ilist, _Pr _Pred) {
    
    pair<const _Ty*, const _Ty*> _Res = _Minmax_element_unchecked(_Ilist.begin(), _Ilist.end(), _Pass_fn(_Pred));
    return pair<_Ty, _Ty>(*_Res.first, *_Res.second);
}

template <class _Ty>
[[nodiscard]] constexpr pair<const _Ty&, const _Ty&> minmax(const _Ty& _Left, const _Ty& _Right) noexcept(
    noexcept(_Right < _Left))  {
    
    if (_Right < _Left) {
        ;
        return {_Right, _Left};
    }

    return {_Left, _Right};
}

template <class _Ty>
[[nodiscard]] constexpr pair<_Ty, _Ty> minmax(initializer_list<_Ty> _Ilist) {
    
    return ::std:: minmax(_Ilist, less<>{});
}


namespace ranges {
    template <class _Ty>
    using minmax_result = min_max_result<_Ty>;

    class _Minmax_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <class _Ty, class _Pj = identity,
            indirect_strict_weak_order<projected<const _Ty*, _Pj>> _Pr = ranges::less>
        [[nodiscard]] constexpr minmax_result<const _Ty&> operator()(
            const _Ty& _Left, const _Ty& _Right, _Pr _Pred = {}, _Pj _Proj = {}) const {
            if (::std:: invoke(_Pred, ::std:: invoke(_Proj, _Right), ::std:: invoke(_Proj, _Left))) {
                return {_Right, _Left};
            } else {
                return {_Left, _Right};
            }
        }

        template <copyable _Ty, class _Pj = identity,
            indirect_strict_weak_order<projected<const _Ty*, _Pj>> _Pr = ranges::less>
        [[nodiscard]] constexpr minmax_result<_Ty> operator()(
            initializer_list<_Ty> _Range, _Pr _Pred = {}, _Pj _Proj = {}) const {
            const auto _First = _Range.begin();
            const auto _Last  = _Range.end();
            ;
#line 9781 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
            const auto _Found = ::std::ranges:: _Minmax_element_unchecked(_First, _Last, _Pass_fn(_Pred), _Pass_fn(_Proj));
            return {static_cast<_Ty>(*_Found.min), static_cast<_Ty>(*_Found.max)};
        }

        
        template <input_range _Rng, class _Pj = identity,
            indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
            requires indirectly_copyable_storable<iterator_t<_Rng>, range_value_t<_Rng>*>
        [[nodiscard]] constexpr minmax_result<range_value_t<_Rng>> operator()(
            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) const {
            
            auto _UFirst = _Ubegin(_Range);
            auto _ULast  = _Uend(_Range);
            ;
#line 9796 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
            using _Vty = range_value_t<_Rng>;
            if constexpr (forward_range<_Rng> && _Prefer_iterator_copies<iterator_t<_Rng>>) {
                const auto _Found = ::std::ranges:: _Minmax_element_unchecked(
                    ::std:: move(_UFirst), ::std:: move(_ULast), _Pass_fn(_Pred), _Pass_fn(_Proj));
                return {static_cast<_Vty>(*_Found.min), static_cast<_Vty>(*_Found.max)};
            } else {
                minmax_result<_Vty> _Found = {static_cast<_Vty>(*_UFirst), static_cast<_Vty>(*_UFirst)};
                if (_UFirst == _ULast) {
                    return _Found;
                }

                while (++_UFirst != _ULast) { 
                    auto _Prev = *_UFirst;
                    if (++_UFirst == _ULast) { 
                        if (::std:: invoke(_Pred, ::std:: invoke(_Proj, _Prev), ::std:: invoke(_Proj, _Found.min))) {
                            _Found.min = ::std:: move(_Prev);
                        } else if (!::std:: invoke(_Pred, ::std:: invoke(_Proj, _Prev), ::std:: invoke(_Proj, _Found.max))) {
                            _Found.max = ::std:: move(_Prev);
                        }

                        break;
                    }

                    
                    if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_UFirst), ::std:: invoke(_Proj, _Prev))) {
                        
                        if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_UFirst), ::std:: invoke(_Proj, _Found.min))) {
                            _Found.min = *_UFirst;
                        }

                        if (!::std:: invoke(_Pred, ::std:: invoke(_Proj, _Prev), ::std:: invoke(_Proj, _Found.max))) {
                            _Found.max = ::std:: move(_Prev);
                        }
                    } else { 
                        if (::std:: invoke(_Pred, ::std:: invoke(_Proj, _Prev), ::std:: invoke(_Proj, _Found.min))) {
                            _Found.min = ::std:: move(_Prev);
                        }

                        if (!::std:: invoke(_Pred, ::std:: invoke(_Proj, *_UFirst), ::std:: invoke(_Proj, _Found.max))) {
                            _Found.max = *_UFirst;
                        }
                    }
                }

                return _Found;
            }
        }
    };

    inline constexpr _Minmax_fn minmax{_Not_quite_object::_Construct_tag{}};
} 
#line 9848 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _BidIt, class _Pr>
constexpr bool next_permutation(_BidIt _First, _BidIt _Last, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    auto _UNext       = _ULast;
    if (_UFirst == _ULast || _UFirst == --_UNext) {
        return false;
    }

    for (;;) { 
        auto _UNext1 = _UNext;
        if (static_cast<bool>(_Pred(*--_UNext, *_UNext1))) { 
            auto _UMid = _ULast;
            do {
                --_UMid;
            } while (!static_cast<bool>(_Pred(*_UNext, *_UMid)));

            ::std:: iter_swap(_UNext, _UMid);
            ::std:: reverse(_UNext1, _ULast);
            return true;
        }

        if (_UNext == _UFirst) { 
            ::std:: reverse(_UFirst, _ULast);
            return false;
        }
    }
}

template <class _BidIt>
constexpr bool next_permutation(_BidIt _First, _BidIt _Last) {
    
    return ::std:: next_permutation(_First, _Last, less<>{});
}


namespace ranges {
    template <class _In>
    using next_permutation_result = in_found_result<_In>;

    class _Next_permutation_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <bidirectional_iterator _It, sentinel_for<_It> _Se, class _Pr = ranges::less, class _Pj = identity>
            requires sortable<_It, _Pr, _Pj>
        constexpr next_permutation_result<_It> operator()(_It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) const {
            
            _Adl_verify_range(_First, _Last);
            auto _UFirst = _Get_unwrapped(::std:: move(_First));
            auto _ULast  = _Get_final_iterator_unwrapped<_It>(_UFirst, ::std:: move(_Last));
            _Seek_wrapped(_First, _ULast);
            const bool _Found =
                _Next_permutation_common(::std:: move(_UFirst), ::std:: move(_ULast), _Pass_fn(_Pred), _Pass_fn(_Proj));
            return {::std:: move(_First), _Found};
        }

        
        template <bidirectional_range _Rng, class _Pr = ranges::less, class _Pj = identity>
            requires sortable<iterator_t<_Rng>, _Pr, _Pj>
        constexpr next_permutation_result<borrowed_iterator_t<_Rng>> operator()(
            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) const {
            
            auto _ULast       = _Get_final_iterator_unwrapped(_Range);
            const bool _Found = _Next_permutation_common(_Ubegin(_Range), _ULast, _Pass_fn(_Pred), _Pass_fn(_Proj));
            return {_Rewrap_iterator(_Range, ::std:: move(_ULast)), _Found};
        }

    private:
        template <class _It, class _Pr, class _Pj>
        [[nodiscard]] static constexpr bool _Next_permutation_common(_It _First, _It _Last, _Pr _Pred, _Pj _Proj) {
            ;
            ;

            auto _Next = _Last;
            if (_First == _Last || _First == --_Next) {
                return false;
            }

            for (;;) { 
                auto _Next1 = _Next;
                if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *--_Next), ::std:: invoke(_Proj, *_Next1))) {
                    
                    auto _Mid = _Last;
                    do {
                        --_Mid;
                    } while (!::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Next), ::std:: invoke(_Proj, *_Mid)));

                    ::std::ranges:: iter_swap(_Next, _Mid);
                    _Reverse_common(::std:: move(_Next1), ::std:: move(_Last));
                    return true;
                }

                if (_Next == _First) { 
                    _Reverse_common(::std:: move(_First), ::std:: move(_Last));
                    return false;
                }
            }
        }
    };

    inline constexpr _Next_permutation_fn next_permutation{_Not_quite_object::_Construct_tag{}};
} 
#line 9956 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _BidIt, class _Pr>
constexpr bool prev_permutation(_BidIt _First, _BidIt _Last, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    auto _UNext       = _ULast;
    if (_UFirst == _ULast || _UFirst == --_UNext) {
        return false;
    }

    for (;;) { 
        auto _UNext1 = _UNext;
        if (static_cast<bool>(_Pred(*_UNext1, *--_UNext))) { 
            auto _UMid = _ULast;
            do {
                --_UMid;
            } while (!static_cast<bool>(_Pred(*_UMid, *_UNext)));

            ::std:: iter_swap(_UNext, _UMid);
            ::std:: reverse(_UNext1, _ULast);
            return true;
        }

        if (_UNext == _UFirst) { 
            ::std:: reverse(_UFirst, _ULast);
            return false;
        }
    }
}

template <class _BidIt>
constexpr bool prev_permutation(_BidIt _First, _BidIt _Last) {
    
    return ::std:: prev_permutation(_First, _Last, less<>{});
}


namespace ranges {
    template <class _In>
    using prev_permutation_result = in_found_result<_In>;

    class _Prev_permutation_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <bidirectional_iterator _It, sentinel_for<_It> _Se, class _Pr = ranges::less, class _Pj = identity>
            requires sortable<_It, _Pr, _Pj>
        constexpr prev_permutation_result<_It> operator()(_It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) const {
            
            _Adl_verify_range(_First, _Last);
            auto _UFirst = _Get_unwrapped(::std:: move(_First));
            auto _ULast  = _Get_final_iterator_unwrapped<_It>(_UFirst, ::std:: move(_Last));
            _Seek_wrapped(_First, _ULast);
            const bool _Found =
                _Prev_permutation_common(::std:: move(_UFirst), ::std:: move(_ULast), _Pass_fn(_Pred), _Pass_fn(_Proj));
            return {::std:: move(_First), _Found};
        }

        
        template <bidirectional_range _Rng, class _Pr = ranges::less, class _Pj = identity>
            requires sortable<iterator_t<_Rng>, _Pr, _Pj>
        constexpr prev_permutation_result<borrowed_iterator_t<_Rng>> operator()(
            _Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) const {
            
            auto _ULast       = _Get_final_iterator_unwrapped(_Range);
            const bool _Found = _Prev_permutation_common(_Ubegin(_Range), _ULast, _Pass_fn(_Pred), _Pass_fn(_Proj));
            return {_Rewrap_iterator(_Range, ::std:: move(_ULast)), _Found};
        }

    private:
        template <class _It, class _Pr, class _Pj>
        [[nodiscard]] static constexpr bool _Prev_permutation_common(_It _First, _It _Last, _Pr _Pred, _Pj _Proj) {
            ;
            ;

            auto _Next = _Last;
            if (_First == _Last || _First == --_Next) {
                return false;
            }

            for (;;) { 
                auto _Next1 = _Next;
                if (::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Next1), ::std:: invoke(_Proj, *--_Next))) {
                    
                    auto _Mid = _Last;
                    do {
                        --_Mid;
                    } while (!::std:: invoke(_Pred, ::std:: invoke(_Proj, *_Mid), ::std:: invoke(_Proj, *_Next)));

                    ::std::ranges:: iter_swap(_Next, _Mid);
                    _Reverse_common(::std:: move(_Next1), ::std:: move(_Last));
                    return true;
                }

                if (_Next == _First) { 
                    _Reverse_common(::std:: move(_First), ::std:: move(_Last));
                    return false;
                }
            }
        }
    };

    inline constexpr _Prev_permutation_fn prev_permutation{_Not_quite_object::_Construct_tag{}};
} 
#line 10064 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _FwdIt, class _Pr>
[[nodiscard]] constexpr _FwdIt is_sorted_until(const _FwdIt _First, _FwdIt _Last, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst = _Get_unwrapped(_First);
    auto _ULast  = _Get_unwrapped(_Last);
    if (_UFirst != _ULast) {
        for (auto _UNext = _UFirst; ++_UNext != _ULast; ++_UFirst) {
            if (static_cast<bool>(_Pred(*_UNext, *_UFirst))) {
                _ULast = _UNext;
                break;
            }
        }
    }

    _Seek_wrapped(_Last, _ULast);
    return _Last;
}

template <class _FwdIt, class _Pr>
[[nodiscard]] constexpr bool is_sorted(_FwdIt _First, _FwdIt _Last, _Pr _Pred) {
    
    _Adl_verify_range(_First, _Last);
    const auto _UFirst = _Get_unwrapped(_First);
    const auto _ULast  = _Get_unwrapped(_Last);
    return ::std:: is_sorted_until(_UFirst, _ULast, _Pass_fn(_Pred)) == _ULast;
}

template <class _FwdIt>
[[nodiscard]] constexpr _FwdIt is_sorted_until(_FwdIt _First, _FwdIt _Last) {
    
    return ::std:: is_sorted_until(_First, _Last, less<>{});
}

template <class _FwdIt>
[[nodiscard]] constexpr bool is_sorted(_FwdIt _First, _FwdIt _Last) { 
    return ::std:: is_sorted(_First, _Last, less<>{});
}


template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _FwdIt is_sorted_until(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept; 

template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] bool is_sorted(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept  {
    
    return ::std:: is_sorted_until(::std:: forward<_ExPo>(_Exec), _First, _Last, _Pass_fn(_Pred)) == _Last;
}

template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _FwdIt is_sorted_until(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last) noexcept  {
    
    return ::std:: is_sorted_until(::std:: forward<_ExPo>(_Exec), _First, _Last, less{});
}

template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] bool is_sorted(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last) noexcept  {
    
    return ::std:: is_sorted(::std:: forward<_ExPo>(_Exec), _First, _Last, less{});
}


namespace ranges {
    class _Is_sorted_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <forward_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
            indirect_strict_weak_order<projected<_It, _Pj>> _Pr = ranges::less>
        [[nodiscard]] constexpr bool operator()(_It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            const auto _ULast = _Get_unwrapped(::std:: move(_Last));
            const auto _UFirst =
                _Is_sorted_until_unchecked(_Get_unwrapped(::std:: move(_First)), _ULast, _Pass_fn(_Pred), _Pass_fn(_Proj));
            return _UFirst == _ULast;
        }

        template <forward_range _Rng, class _Pj = identity,
            indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
        [[nodiscard]] constexpr bool operator()(_Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) const {
            const auto _ULast  = _Uend(_Range);
            const auto _UFirst = _Is_sorted_until_unchecked(_Ubegin(_Range), _ULast, _Pass_fn(_Pred), _Pass_fn(_Proj));
            return _UFirst == _ULast;
        }
    };

    inline constexpr _Is_sorted_fn is_sorted{_Not_quite_object::_Construct_tag{}};

    class _Is_sorted_until_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <forward_iterator _It, sentinel_for<_It> _Se, class _Pj = identity,
            indirect_strict_weak_order<projected<_It, _Pj>> _Pr = ranges::less>
        [[nodiscard]] constexpr _It operator()(_It _First, _Se _Last, _Pr _Pred = {}, _Pj _Proj = {}) const {
            _Adl_verify_range(_First, _Last);
            auto _UFirst = _Is_sorted_until_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)), _Pass_fn(_Pred), _Pass_fn(_Proj));
            _Seek_wrapped(_First, ::std:: move(_UFirst));
            return _First;
        }

        template <forward_range _Rng, class _Pj = identity,
            indirect_strict_weak_order<projected<iterator_t<_Rng>, _Pj>> _Pr = ranges::less>
        [[nodiscard]] constexpr borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, _Pr _Pred = {}, _Pj _Proj = {}) const {
            auto _First = ::std::ranges:: begin(_Range);
            auto _UFirst =
                _Is_sorted_until_unchecked(_Get_unwrapped(_First), _Uend(_Range), _Pass_fn(_Pred), _Pass_fn(_Proj));
            _Seek_wrapped(_First, ::std:: move(_UFirst));
            return _First;
        }
    };

    inline constexpr _Is_sorted_until_fn is_sorted_until{_Not_quite_object::_Construct_tag{}};
} 
#line 10181 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

template <class _Ty, class _Pr>
[[nodiscard]] constexpr const _Ty& clamp(const _Ty& _Val, const _Ty& _Min_val, const _Ty& _Max_val, _Pr _Pred) {
    

#line 10191 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

    if (static_cast<bool>(_Pred(_Max_val, _Val))) {
        return _Max_val;
    }

    if (static_cast<bool>(_Pred(_Val, _Min_val))) {
        return _Min_val;
    }

    return _Val;
}

template <class _Ty>
[[nodiscard]] constexpr const _Ty& clamp(const _Ty& _Val, const _Ty& _Min_val, const _Ty& _Max_val) {
    
    return ::std:: clamp(_Val, _Min_val, _Max_val, less{});
}


namespace ranges {
    class _Clamp_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <class _Ty, class _Pj = identity,
            indirect_strict_weak_order<projected<const _Ty*, _Pj>> _Pr = ranges::less>
        [[nodiscard]] constexpr const _Ty& operator()(
            const _Ty& _Val, const _Ty& _Lo, const _Ty& _Hi, _Pr _Pred = {}, _Pj _Proj = {}) const {
            ;
#line 10222 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

            auto&& _Temp = ::std:: invoke(_Proj, _Val);
            if (::std:: invoke(_Pred, ::std:: forward<decltype(_Temp)>(_Temp), ::std:: invoke(_Proj, _Lo))) {
                return _Lo;
            }
            
            
            if (::std:: invoke(_Pred, ::std:: invoke(_Proj, _Hi), ::std:: forward<decltype(_Temp)>(_Temp))) {
                return _Hi;
            }

            return _Val;
        }
    };

    inline constexpr _Clamp_fn clamp{_Not_quite_object::_Construct_tag{}};

    class _Lexicographical_compare_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <input_iterator _It1, sentinel_for<_It1> _Se1, input_iterator _It2, sentinel_for<_It2> _Se2,
            class _Pj1 = identity, class _Pj2 = identity,
            indirect_strict_weak_order<projected<_It1, _Pj1>, projected<_It2, _Pj2>> _Pr = ranges::less>
        [[nodiscard]] constexpr bool operator()(_It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2, _Pr _Pred = {},
            _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            _Adl_verify_range(_First1, _Last1);
            _Adl_verify_range(_First2, _Last2);

            return _Lexicographical_compare_unchecked(_Get_unwrapped(::std:: move(_First1)),
                _Get_unwrapped(::std:: move(_Last1)), _Get_unwrapped(::std:: move(_First2)),
                _Get_unwrapped(::std:: move(_Last2)), _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
        }

        template <input_range _Rng1, input_range _Rng2, class _Pj1 = identity, class _Pj2 = identity,
            indirect_strict_weak_order<projected<iterator_t<_Rng1>, _Pj1>, projected<iterator_t<_Rng2>, _Pj2>> _Pr =
                ranges::less>
        [[nodiscard]] constexpr bool operator()(
            _Rng1&& _Range1, _Rng2&& _Range2, _Pr _Pred = {}, _Pj1 _Proj1 = {}, _Pj2 _Proj2 = {}) const {
            return _Lexicographical_compare_unchecked(_Ubegin(_Range1), _Uend(_Range1), _Ubegin(_Range2),
                _Uend(_Range2), _Pass_fn(_Pred), _Pass_fn(_Proj1), _Pass_fn(_Proj2));
        }

    private:
        template <class _It1, class _Se1, class _It2, class _Se2, class _Pr, class _Pj1, class _Pj2>
        [[nodiscard]] static constexpr bool _Lexicographical_compare_unchecked(
            _It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
            ;
            ;
            ;
            ;
            ;

            using _Memcmp_classification_pred = _Lex_compare_memcmp_classify<_It1, _It2, _Pr>;
            constexpr bool _Is_sized1         = sized_sentinel_for<_Se1, _It1>;
            constexpr bool _Is_sized2         = sized_sentinel_for<_Se2, _It2>;
            if constexpr (!is_void_v<_Memcmp_classification_pred> && _Sized_or_unreachable_sentinel_for<_Se1, _It1> 
                          && _Sized_or_unreachable_sentinel_for<_Se2, _It2> 
                          && same_as<_Pj1, identity> && same_as<_Pj2, identity>) {
                if (!::std:: is_constant_evaluated()) {
                    size_t _Num1;
                    if constexpr (_Is_sized1) {
                        _Num1 = static_cast<size_t>(_Last1 - _First1);
                    } else {
                        _Num1 = 0xffffffffui32;
                    }

                    size_t _Num2;
                    if constexpr (_Is_sized2) {
                        _Num2 = static_cast<size_t>(_Last2 - _First2);
                    } else {
                        _Num2 = 0xffffffffui32;
                    }

                    const int _Ans = _Memcmp_count(_First1, _First2, (::std:: min)(_Num1, _Num2));
                    return _Memcmp_classification_pred{}(_Ans, 0) || (_Ans == 0 && _Num1 < _Num2);
                }
            }

            for (;; ++_First1, (void) ++_First2) {
                if (_First2 == _Last2) {
                    return false;
                } else if (_First1 == _Last1) {
                    return true;
                } else if (::std:: invoke(_Pred, ::std:: invoke(_Proj1, *_First1), ::std:: invoke(_Proj2, *_First2))) {
                    return true;
                } else if (::std:: invoke(_Pred, ::std:: invoke(_Proj2, *_First2), ::std:: invoke(_Proj1, *_First1))) {
                    return false;
                }
            }
        }
    };

    inline constexpr _Lexicographical_compare_fn lexicographical_compare{_Not_quite_object::_Construct_tag{}};
} 
#line 10318 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
#line 10319 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"

}


#pragma warning(pop)
#pragma pack(pop)
#line 10326 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
#line 10327 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\algorithm"
#line 21 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xatomic_wait.h"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


inline constexpr unsigned long long _Atomic_wait_no_deadline = 0xFFFF'FFFF'FFFF'FFFF;
inline constexpr unsigned long _Atomic_wait_no_timeout       = 0xFFFF'FFFF; 

extern "C" {
enum class __std_atomic_api_level : unsigned long {
    __not_set,
    __detecting,
    __has_srwlock,
    __has_wait_on_address,
};


__std_atomic_api_level __stdcall __std_atomic_set_api_level(__std_atomic_api_level _Requested_api_level) noexcept;


int __stdcall __std_atomic_wait_direct(
    const void* _Storage, void* _Comparand, size_t _Size, unsigned long _Remaining_timeout) noexcept;
void __stdcall __std_atomic_notify_one_direct(const void* _Storage) noexcept;
void __stdcall __std_atomic_notify_all_direct(const void* _Storage) noexcept;


using _Atomic_wait_indirect_equal_callback_t = bool(__stdcall*)(
    const void* _Storage, void* _Comparand, size_t _Size, void* _Param) noexcept;

int __stdcall __std_atomic_wait_indirect(const void* _Storage, void* _Comparand, size_t _Size, void* _Param,
    _Atomic_wait_indirect_equal_callback_t _Are_equal, unsigned long _Remaining_timeout) noexcept;
void __stdcall __std_atomic_notify_one_indirect(const void* _Storage) noexcept;
void __stdcall __std_atomic_notify_all_indirect(const void* _Storage) noexcept;


unsigned long long __stdcall __std_atomic_wait_get_deadline(unsigned long long _Timeout) noexcept;
unsigned long __stdcall __std_atomic_wait_get_remaining_timeout(unsigned long long _Deadline) noexcept;

}


#pragma warning(pop)
#pragma pack(pop)
#line 72 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xatomic_wait.h"
#line 73 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xatomic_wait.h"
#line 22 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
#line 23 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xthreads.h"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


extern "C" {
using _Thrd_id_t = unsigned int;
struct _Thrd_t { 
    void* _Hnd; 
    _Thrd_id_t _Id;
};


inline constexpr size_t _Mtx_internal_imp_size      = 48;
inline constexpr size_t _Mtx_internal_imp_alignment = 4;
inline constexpr size_t _Cnd_internal_imp_size      = 40;
inline constexpr size_t _Cnd_internal_imp_alignment = 4;
#line 53 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xthreads.h"
#line 54 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xthreads.h"

using _Mtx_t = struct _Mtx_internal_imp_t*;

using _Cnd_t = struct _Cnd_internal_imp_t*;

enum { _Thrd_success, _Thrd_nomem, _Thrd_timedout, _Thrd_busy, _Thrd_error };


 int __cdecl _Thrd_detach(_Thrd_t);
 int __cdecl _Thrd_join(_Thrd_t, int*);
 void __cdecl _Thrd_sleep(const xtime*);
 void __cdecl _Thrd_yield();
 unsigned int __cdecl _Thrd_hardware_concurrency();
 _Thrd_id_t __cdecl _Thrd_id();


enum { 
    _Mtx_plain     = 0x01,
    _Mtx_try       = 0x02,
    _Mtx_timed     = 0x04,
    _Mtx_recursive = 0x100
};

 int __cdecl _Mtx_init(_Mtx_t*, int);
 void __cdecl _Mtx_destroy(_Mtx_t);
 void __cdecl _Mtx_init_in_situ(_Mtx_t, int);
 void __cdecl _Mtx_destroy_in_situ(_Mtx_t);
 int __cdecl _Mtx_current_owns(_Mtx_t);
 int __cdecl _Mtx_lock(_Mtx_t);
 int __cdecl _Mtx_trylock(_Mtx_t);
 int __cdecl _Mtx_timedlock(_Mtx_t, const xtime*);
 int __cdecl _Mtx_unlock(_Mtx_t); 

 void* __cdecl _Mtx_getconcrtcs(_Mtx_t);
 void __cdecl _Mtx_clear_owner(_Mtx_t);
 void __cdecl _Mtx_reset_owner(_Mtx_t);


using _Smtx_t = void*;
void __cdecl _Smtx_lock_exclusive(_Smtx_t*);
void __cdecl _Smtx_lock_shared(_Smtx_t*);
int __cdecl _Smtx_try_lock_exclusive(_Smtx_t*);
int __cdecl _Smtx_try_lock_shared(_Smtx_t*);
void __cdecl _Smtx_unlock_exclusive(_Smtx_t*);
void __cdecl _Smtx_unlock_shared(_Smtx_t*);


 int __cdecl _Cnd_init(_Cnd_t*);
 void __cdecl _Cnd_destroy(_Cnd_t);
 void __cdecl _Cnd_init_in_situ(_Cnd_t);
 void __cdecl _Cnd_destroy_in_situ(_Cnd_t);
 int __cdecl _Cnd_wait(_Cnd_t, _Mtx_t); 
 int __cdecl _Cnd_timedwait(_Cnd_t, _Mtx_t, const xtime*);
 int __cdecl _Cnd_broadcast(_Cnd_t); 
 int __cdecl _Cnd_signal(_Cnd_t); 
 void __cdecl _Cnd_register_at_thread_exit(_Cnd_t, _Mtx_t, int*);
 void __cdecl _Cnd_unregister_at_thread_exit(_Mtx_t);
 void __cdecl _Cnd_do_broadcast_at_thread_exit();
}

namespace std {
enum { 
    _DEVICE_OR_RESOURCE_BUSY,
    _INVALID_ARGUMENT,
    _NO_SUCH_PROCESS,
    _NOT_ENOUGH_MEMORY,
    _OPERATION_NOT_PERMITTED,
    _RESOURCE_DEADLOCK_WOULD_OCCUR,
    _RESOURCE_UNAVAILABLE_TRY_AGAIN
};

[[noreturn]]  void __cdecl _Throw_C_error(int _Code);
[[noreturn]]  void __cdecl _Throw_Cpp_error(int _Code);

inline int _Check_C_return(int _Res) { 
    if (_Res != _Thrd_success) {
        _Throw_C_error(_Res);
    }

    return _Res;
}
}


#pragma warning(pop)
#pragma pack(pop)
#line 142 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xthreads.h"
#line 143 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xthreads.h"


#line 24 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


#line 38 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"


#line 43 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"


#line 50 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
#line 51 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"


#line 75 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"


#line 102 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"


#line 108 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"


extern "C" {
_Smtx_t* __stdcall __std_atomic_get_mutex(const void* _Key) noexcept;
}


#line 128 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"

namespace std {

struct _Form_mask_t {};
inline constexpr _Form_mask_t _Form_mask{};
#line 134 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"

template <class _Ty>
struct _Storage_for {
    
    alignas(_Ty) unsigned char _Storage[sizeof(_Ty)];

    _Storage_for()                    = default;
    _Storage_for(const _Storage_for&) = delete;
    _Storage_for& operator=(const _Storage_for&) = delete;


    explicit _Storage_for(_Form_mask_t) noexcept {
        :: memset(_Storage, 0xff, sizeof(_Ty));
        __builtin_zero_non_value_bits(_Ptr());
    }
#line 150 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"

    [[nodiscard]] _Ty& _Ref() noexcept {
        return reinterpret_cast<_Ty&>(_Storage);
    }

    [[nodiscard]] _Ty* _Ptr() noexcept {
        return reinterpret_cast<_Ty*>(&_Storage);
    }
};


template <class _Ty>
inline constexpr bool _Might_have_non_value_bits =
    !has_unique_object_representations_v<_Ty> && !is_floating_point_v<_Ty>;
#line 165 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"

extern "C" inline void atomic_thread_fence(const memory_order _Order) noexcept {
    if (_Order == memory_order_relaxed) {
        return;
    }


    __pragma(warning(push)) __pragma(warning(disable : 4996)) _ReadWriteBarrier() __pragma(warning(pop));
    if (_Order == memory_order_seq_cst) {
        volatile long _Guard; 

        
#pragma warning(suppress : 6001) 
#pragma warning(suppress : 28113) 
                                  
        (void) _InterlockedIncrement(&_Guard);
        __pragma(warning(push)) __pragma(warning(disable : 4996)) _ReadWriteBarrier() __pragma(warning(pop));
    }


#line 190 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
}

extern "C" inline void atomic_signal_fence(const memory_order _Order) noexcept {
    if (_Order != memory_order_relaxed) {
        __pragma(warning(push)) __pragma(warning(disable : 4996)) _ReadWriteBarrier() __pragma(warning(pop));
    }
}

template <class _Ty>
_Ty kill_dependency(_Ty _Arg) noexcept { 
    return _Arg;
}

inline void _Check_memory_order(const memory_order _Order) noexcept {
    
    if (static_cast<unsigned int>(_Order) > static_cast<unsigned int>(memory_order_seq_cst)) {
        ;
    }
}

inline void _Check_store_memory_order(const memory_order _Order) noexcept {
    switch (_Order) {
    case memory_order_relaxed:
    case memory_order_release:
    case memory_order_seq_cst:
        
        break;
    case memory_order_consume:
    case memory_order_acquire:
    case memory_order_acq_rel:
    default:
        ;
        break;
    }
}

inline void _Check_load_memory_order(const memory_order _Order) noexcept {
    switch (_Order) {
    case memory_order_relaxed:
    case memory_order_consume:
    case memory_order_acquire:
    case memory_order_seq_cst:
        
        break;
    case memory_order_release:
    case memory_order_acq_rel:
    default:
        ;
        break;
    }
}

[[nodiscard]] inline memory_order _Combine_cas_memory_orders(
    const memory_order _Success, const memory_order _Failure) noexcept {
    
    
    static constexpr memory_order _Combined_memory_orders[6][6] = {
        {memory_order_relaxed, memory_order_consume, memory_order_acquire, memory_order_release, memory_order_acq_rel,
            memory_order_seq_cst},
        {memory_order_consume, memory_order_consume, memory_order_acquire, memory_order_acq_rel, memory_order_acq_rel,
            memory_order_seq_cst},
        {memory_order_acquire, memory_order_acquire, memory_order_acquire, memory_order_acq_rel, memory_order_acq_rel,
            memory_order_seq_cst},
        {memory_order_release, memory_order_acq_rel, memory_order_acq_rel, memory_order_release, memory_order_acq_rel,
            memory_order_seq_cst},
        {memory_order_acq_rel, memory_order_acq_rel, memory_order_acq_rel, memory_order_acq_rel, memory_order_acq_rel,
            memory_order_seq_cst},
        {memory_order_seq_cst, memory_order_seq_cst, memory_order_seq_cst, memory_order_seq_cst, memory_order_seq_cst,
            memory_order_seq_cst}};

    _Check_memory_order(_Success);
    _Check_load_memory_order(_Failure);
    return _Combined_memory_orders[static_cast<int>(_Success)][static_cast<int>(_Failure)];
}

template <class _Integral, class _Ty>
[[nodiscard]] _Integral _Atomic_reinterpret_as(const _Ty& _Source) noexcept {
    
    static_assert(is_integral_v<_Integral>, "Tried to reinterpret memory as non-integral");
    if constexpr (is_integral_v<_Ty> && sizeof(_Integral) == sizeof(_Ty)) {
        return static_cast<_Integral>(_Source);
    } else if constexpr (is_pointer_v<_Ty> && sizeof(_Integral) == sizeof(_Ty)) {
        return reinterpret_cast<_Integral>(_Source);
    } else {
        _Integral _Result{}; 
        :: memcpy(&_Result, ::std:: addressof(_Source), sizeof(_Source));
        return _Result;
    }
}

inline void _Load_barrier(const memory_order _Order) noexcept { 
    _Check_load_memory_order(_Order);
    if (_Order != memory_order_relaxed) {
        __pragma(warning(push)) __pragma(warning(disable : 4996)) _ReadWriteBarrier() __pragma(warning(pop));
    }
}


template <class _Ty>
struct _Atomic_padded {
    alignas(sizeof(_Ty)) mutable _Ty _Value; 
};


#line 341 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"

template <class _Ty>
struct _Atomic_storage_types {
    using _TStorage = _Atomic_padded<_Ty>;
    using _Spinlock = long;
};

template <class _Ty>
struct _Atomic_storage_types<_Ty&> {
    using _TStorage = _Ty&;
    using _Spinlock = _Smtx_t*; 
};


template <class _Ty, size_t = sizeof(remove_reference_t<_Ty>)>


#line 359 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
struct _Atomic_storage;


template <class _Ty, class _Value_type>
void _Atomic_wait_direct(
    const _Atomic_storage<_Ty>* const _This, _Value_type _Expected_bytes, const memory_order _Order) noexcept {
    const auto _Storage_ptr = ::std:: addressof(_This->_Storage);
    for (;;) {
        const _Value_type _Observed_bytes = _Atomic_reinterpret_as<_Value_type>(_This->load(_Order));
        if (_Expected_bytes != _Observed_bytes) {

            using _TVal = remove_reference_t<_Ty>;
            if constexpr (_Might_have_non_value_bits<_TVal>) {
                _Storage_for<_TVal> _Mask{_Form_mask};
                const _Value_type _Mask_val = _Atomic_reinterpret_as<_Value_type>(_Mask._Ref());

                if (((_Expected_bytes ^ _Observed_bytes) & _Mask_val) == 0) {
                    _Expected_bytes = _Observed_bytes;
                    continue;
                }
            }
#line 381 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"

            return;
        }

        __std_atomic_wait_direct(_Storage_ptr, &_Expected_bytes, sizeof(_Value_type), _Atomic_wait_no_timeout);
    }
}
#line 389 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"


inline void _Atomic_lock_acquire(long& _Spinlock) noexcept {

    
    int _Current_backoff   = 1;
    const int _Max_backoff = 64;
    while (_InterlockedExchange(&_Spinlock, 1) != 0) {
        while (__iso_volatile_load32(&reinterpret_cast<int&>(_Spinlock)) != 0) {
            for (int _Count_down = _Current_backoff; _Count_down != 0; --_Count_down) {
                _mm_pause();
            }
            _Current_backoff = _Current_backoff < _Max_backoff ? _Current_backoff << 1 : _Max_backoff;
        }
    }


#line 415 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
}

inline void _Atomic_lock_release(long& _Spinlock) noexcept {

    _InterlockedExchange(&_Spinlock, 0); 


#line 427 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
}

inline void _Atomic_lock_acquire(_Smtx_t* _Spinlock) noexcept {
    _Smtx_lock_exclusive(_Spinlock);
}

inline void _Atomic_lock_release(_Smtx_t* _Spinlock) noexcept {
    _Smtx_unlock_exclusive(_Spinlock);
}

template <class _Spinlock_t>
class [[nodiscard]] _Atomic_lock_guard {
public:
    explicit _Atomic_lock_guard(_Spinlock_t& _Spinlock_) noexcept : _Spinlock(_Spinlock_) {
        _Atomic_lock_acquire(_Spinlock);
    }

    ~_Atomic_lock_guard() {
        _Atomic_lock_release(_Spinlock);
    }

    _Atomic_lock_guard(const _Atomic_lock_guard&) = delete;
    _Atomic_lock_guard& operator=(const _Atomic_lock_guard&) = delete;

private:
    _Spinlock_t& _Spinlock;
};


template <class _Spinlock_t>
bool __stdcall _Atomic_wait_compare_non_lock_free(
    const void* _Storage, void* _Comparand, size_t _Size, void* _Spinlock_raw) noexcept {
    _Spinlock_t& _Spinlock = *static_cast<_Spinlock_t*>(_Spinlock_raw);
    _Atomic_lock_acquire(_Spinlock);
    const auto _Cmp_result = :: memcmp(_Storage, _Comparand, _Size);
    _Atomic_lock_release(_Spinlock);
    return _Cmp_result == 0;
}


#line 479 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
#line 480 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"

template <class _Ty, size_t >
struct _Atomic_storage {
    
    
    using _TVal  = remove_reference_t<_Ty>;
    using _Guard = _Atomic_lock_guard<typename _Atomic_storage_types<_Ty>::_Spinlock>;

    _Atomic_storage() = default;

     constexpr _Atomic_storage(conditional_t<is_reference_v<_Ty>, _Ty, const _TVal> _Value) noexcept
        : _Storage(_Value) {
        
    }

    void store(const _TVal _Value, const memory_order _Order = memory_order_seq_cst) noexcept {
        
        _Check_store_memory_order(_Order);
        _Guard _Lock{_Spinlock};
        _Storage = _Value;
    }

    [[nodiscard]] _TVal load(const memory_order _Order = memory_order_seq_cst) const noexcept {
        
        _Check_load_memory_order(_Order);
        _Guard _Lock{_Spinlock};
        _TVal _Local(_Storage);
        return _Local;
    }

    _TVal exchange(const _TVal _Value, const memory_order _Order = memory_order_seq_cst) noexcept {
        
        _Check_memory_order(_Order);
        _Guard _Lock{_Spinlock};
        _TVal _Result(_Storage);
        _Storage = _Value;
        return _Result;
    }

    bool compare_exchange_strong(_TVal& _Expected, const _TVal _Desired,
        const memory_order _Order = memory_order_seq_cst) noexcept { 
        _Check_memory_order(_Order);
        const auto _Storage_ptr  = ::std:: addressof(_Storage);
        const auto _Expected_ptr = ::std:: addressof(_Expected);
        bool _Result;

        __builtin_zero_non_value_bits(_Expected_ptr);
#line 529 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        _Guard _Lock{_Spinlock};

        if constexpr (_Might_have_non_value_bits<_TVal>) {
            _Storage_for<_TVal> _Local;
            const auto _Local_ptr = _Local._Ptr();
            :: memcpy(_Local_ptr, _Storage_ptr, sizeof(_TVal));
            __builtin_zero_non_value_bits(_Local_ptr);
            _Result = :: memcmp(_Local_ptr, _Expected_ptr, sizeof(_TVal)) == 0;
        } else {
            _Result = :: memcmp(_Storage_ptr, _Expected_ptr, sizeof(_TVal)) == 0;
        }


#line 543 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        if (_Result) {
            :: memcpy(_Storage_ptr, ::std:: addressof(_Desired), sizeof(_TVal));
        } else {
            :: memcpy(_Expected_ptr, _Storage_ptr, sizeof(_TVal));
        }

        return _Result;
    }


    void wait(_TVal _Expected, memory_order = memory_order_seq_cst) const noexcept {
        const auto _Storage_ptr  = ::std:: addressof(_Storage);
        const auto _Expected_ptr = ::std:: addressof(_Expected);
        for (;;) {
            {
                _Guard _Lock{_Spinlock};
                if (:: memcmp(_Storage_ptr, _Expected_ptr, sizeof(_TVal)) != 0) {
                    

                    if constexpr (_Might_have_non_value_bits<_TVal>) {
                        _Storage_for<_TVal> _Local;
                        const auto _Local_ptr = _Local._Ptr();
                        :: memcpy(_Local_ptr, _Storage_ptr, sizeof(_TVal));
                        __builtin_zero_non_value_bits(_Local_ptr);
                        __builtin_zero_non_value_bits(_Expected_ptr);
                        if (:: memcmp(_Local_ptr, _Expected_ptr, sizeof(_TVal)) == 0) {
                            
                            
                            :: memcpy(_Expected_ptr, _Storage_ptr, sizeof(_TVal));
                        } else {
                            
                            return;
                        }
                    } else
#line 578 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
                    {
                        return;
                    }
                }
            } 

            __std_atomic_wait_indirect(_Storage_ptr, _Expected_ptr, sizeof(_TVal), &_Spinlock,
                &_Atomic_wait_compare_non_lock_free<decltype(_Spinlock)>, _Atomic_wait_no_timeout);
        }
    }

    void notify_one() noexcept {
        __std_atomic_notify_one_indirect(::std:: addressof(_Storage));
    }

    void notify_all() noexcept {
        __std_atomic_notify_all_indirect(::std:: addressof(_Storage));
    }
#line 597 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"


protected:
    void _Init_spinlock_for_ref() noexcept {
        _Spinlock = __std_atomic_get_mutex(::std:: addressof(_Storage));
    }

private:
    
    mutable typename _Atomic_storage_types<_Ty>::_Spinlock _Spinlock{};

public:
    _Ty _Storage{};


#line 615 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
};

template <class _Ty>
struct _Atomic_storage<_Ty, 1> { 

    using _TVal = remove_reference_t<_Ty>;

    _Atomic_storage() = default;

     constexpr _Atomic_storage(conditional_t<is_reference_v<_Ty>, _Ty, const _TVal> _Value) noexcept
        : _Storage{_Value} {
        
    }

    void store(const _TVal _Value) noexcept { 
        const auto _Mem      = _Atomic_address_as<char>(_Storage);
        const char _As_bytes = _Atomic_reinterpret_as<char>(_Value);


#line 637 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        (void) _InterlockedExchange8(_Mem, _As_bytes);
#line 639 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
    }

    void store(const _TVal _Value, const memory_order _Order) noexcept { 
        const auto _Mem      = _Atomic_address_as<char>(_Storage);
        const char _As_bytes = _Atomic_reinterpret_as<char>(_Value);
        switch (_Order) {
        case memory_order_relaxed:
            __iso_volatile_store8(_Mem, _As_bytes);
            return;
        case memory_order_release:
            __pragma(warning(push)) __pragma(warning(disable : 4996)) _ReadWriteBarrier() __pragma(warning(pop));
            __iso_volatile_store8(_Mem, _As_bytes);
            return;
        default:
        case memory_order_consume:
        case memory_order_acquire:
        case memory_order_acq_rel:
            ;
            
        case memory_order_seq_cst:
            store(_Value);
            return;
        }
    }

    [[nodiscard]] _TVal load() const noexcept { 
        const auto _Mem = _Atomic_address_as<char>(_Storage);
        char _As_bytes  = __iso_volatile_load8(_Mem);
        __pragma(warning(push)) __pragma(warning(disable : 4996)) _ReadWriteBarrier() __pragma(warning(pop));
        return reinterpret_cast<_TVal&>(_As_bytes);
    }

    [[nodiscard]] _TVal load(const memory_order _Order) const noexcept { 
        const auto _Mem = _Atomic_address_as<char>(_Storage);
        char _As_bytes  = __iso_volatile_load8(_Mem);
        _Load_barrier(_Order);
        return reinterpret_cast<_TVal&>(_As_bytes);
    }

    _TVal exchange(const _TVal _Value, const memory_order _Order = memory_order_seq_cst) noexcept {
        
        char _As_bytes;
        _Check_memory_order(_Order); _As_bytes = _InterlockedExchange8(_Atomic_address_as<char>(_Storage), _Atomic_reinterpret_as<char>(_Value));
#line 683 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        return reinterpret_cast<_TVal&>(_As_bytes);
    }

    bool compare_exchange_strong(_TVal& _Expected, const _TVal _Desired,
        const memory_order _Order = memory_order_seq_cst) noexcept { 
        char _Expected_bytes = _Atomic_reinterpret_as<char>(_Expected); 
        char _Prev_bytes;


        if constexpr (_Might_have_non_value_bits<_TVal>) {
            _Storage_for<_TVal> _Mask{_Form_mask};
            const char _Mask_val = _Atomic_reinterpret_as<char>(_Mask._Ref());

            for (;;) {
                _Check_memory_order(_Order); _Prev_bytes = _InterlockedCompareExchange8(_Atomic_address_as<char>(_Storage), _Atomic_reinterpret_as<char>(_Desired), _Expected_bytes);
#line 699 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
                if (_Prev_bytes == _Expected_bytes) {
                    return true;
                }

                if ((_Prev_bytes ^ _Expected_bytes) & _Mask_val) {
                    reinterpret_cast<char&>(_Expected) = _Prev_bytes;
                    return false;
                }
                _Expected_bytes = (_Expected_bytes & _Mask_val) | (_Prev_bytes & ~_Mask_val);
            }
        }
#line 711 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        _Check_memory_order(_Order); _Prev_bytes = _InterlockedCompareExchange8(_Atomic_address_as<char>(_Storage), _Atomic_reinterpret_as<char>(_Desired), _Expected_bytes);
#line 713 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        if (_Prev_bytes == _Expected_bytes) {
            return true;
        }

        reinterpret_cast<char&>(_Expected) = _Prev_bytes;
        return false;
    }


    void wait(const _TVal _Expected, const memory_order _Order = memory_order_seq_cst) const noexcept {
        _Atomic_wait_direct(this, _Atomic_reinterpret_as<char>(_Expected), _Order);
    }

    void notify_one() noexcept {
        __std_atomic_notify_one_direct(::std:: addressof(_Storage));
    }

    void notify_all() noexcept {
        __std_atomic_notify_all_direct(::std:: addressof(_Storage));
    }
#line 734 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"

    typename _Atomic_storage_types<_Ty>::_TStorage _Storage;
};

template <class _Ty>
struct _Atomic_storage<_Ty, 2> { 

    using _TVal = remove_reference_t<_Ty>;

    _Atomic_storage() = default;

     constexpr _Atomic_storage(conditional_t<is_reference_v<_Ty>, _Ty, const _TVal> _Value) noexcept
        : _Storage{_Value} {
        
    }

    void store(const _TVal _Value) noexcept { 
        const auto _Mem       = _Atomic_address_as<short>(_Storage);
        const short _As_bytes = _Atomic_reinterpret_as<short>(_Value);


#line 758 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        (void) _InterlockedExchange16(_Mem, _As_bytes);
#line 760 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
    }

    void store(const _TVal _Value, const memory_order _Order) noexcept { 
        const auto _Mem       = _Atomic_address_as<short>(_Storage);
        const short _As_bytes = _Atomic_reinterpret_as<short>(_Value);
        switch (_Order) {
        case memory_order_relaxed:
            __iso_volatile_store16(_Mem, _As_bytes);
            return;
        case memory_order_release:
            __pragma(warning(push)) __pragma(warning(disable : 4996)) _ReadWriteBarrier() __pragma(warning(pop));
            __iso_volatile_store16(_Mem, _As_bytes);
            return;
        default:
        case memory_order_consume:
        case memory_order_acquire:
        case memory_order_acq_rel:
            ;
            
        case memory_order_seq_cst:
            store(_Value);
            return;
        }
    }

    [[nodiscard]] _TVal load() const noexcept { 
        const auto _Mem = _Atomic_address_as<short>(_Storage);
        short _As_bytes = __iso_volatile_load16(_Mem);
        __pragma(warning(push)) __pragma(warning(disable : 4996)) _ReadWriteBarrier() __pragma(warning(pop));
        return reinterpret_cast<_TVal&>(_As_bytes);
    }

    [[nodiscard]] _TVal load(const memory_order _Order) const noexcept { 
        const auto _Mem = _Atomic_address_as<short>(_Storage);
        short _As_bytes = __iso_volatile_load16(_Mem);
        _Load_barrier(_Order);
        return reinterpret_cast<_TVal&>(_As_bytes);
    }

    _TVal exchange(const _TVal _Value, const memory_order _Order = memory_order_seq_cst) noexcept {
        
        short _As_bytes;
        _Check_memory_order(_Order); _As_bytes = _InterlockedExchange16(_Atomic_address_as<short>(_Storage), _Atomic_reinterpret_as<short>(_Value));
#line 804 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        return reinterpret_cast<_TVal&>(_As_bytes);
    }

    bool compare_exchange_strong(_TVal& _Expected, const _TVal _Desired,
        const memory_order _Order = memory_order_seq_cst) noexcept { 
        short _Expected_bytes = _Atomic_reinterpret_as<short>(_Expected); 
        short _Prev_bytes;

        if constexpr (_Might_have_non_value_bits<_Ty>) {
            _Storage_for<_TVal> _Mask{_Form_mask};
            const short _Mask_val = _Atomic_reinterpret_as<short>(_Mask._Ref());

            for (;;) {
                _Check_memory_order(_Order); _Prev_bytes = _InterlockedCompareExchange16(_Atomic_address_as<short>(_Storage), _Atomic_reinterpret_as<short>(_Desired), _Expected_bytes);
#line 819 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
                if (_Prev_bytes == _Expected_bytes) {
                    return true;
                }

                if ((_Prev_bytes ^ _Expected_bytes) & _Mask_val) {
                    :: memcpy(::std:: addressof(_Expected), &_Prev_bytes, sizeof(_TVal));
                    return false;
                }
                _Expected_bytes = (_Expected_bytes & _Mask_val) | (_Prev_bytes & ~_Mask_val);
            }
        }
#line 831 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        _Check_memory_order(_Order); _Prev_bytes = _InterlockedCompareExchange16(_Atomic_address_as<short>(_Storage), _Atomic_reinterpret_as<short>(_Desired), _Expected_bytes);
#line 833 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        if (_Prev_bytes == _Expected_bytes) {
            return true;
        }

        :: memcpy(::std:: addressof(_Expected), &_Prev_bytes, sizeof(_Ty));
        return false;
    }


    void wait(const _TVal _Expected, const memory_order _Order = memory_order_seq_cst) const noexcept {
        _Atomic_wait_direct(this, _Atomic_reinterpret_as<short>(_Expected), _Order);
    }

    void notify_one() noexcept {
        __std_atomic_notify_one_direct(::std:: addressof(_Storage));
    }

    void notify_all() noexcept {
        __std_atomic_notify_all_direct(::std:: addressof(_Storage));
    }
#line 854 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"

    typename _Atomic_storage_types<_Ty>::_TStorage _Storage;
};

template <class _Ty>
struct _Atomic_storage<_Ty, 4> { 

    using _TVal = remove_reference_t<_Ty>;

    _Atomic_storage() = default;

     constexpr _Atomic_storage(conditional_t<is_reference_v<_Ty>, _Ty, const _TVal> _Value) noexcept
        : _Storage{_Value} {
        
    }

    void store(const _TVal _Value) noexcept { 


#line 876 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        (void) _InterlockedExchange(_Atomic_address_as<long>(_Storage), _Atomic_reinterpret_as<long>(_Value));
#line 878 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
    }

    void store(const _TVal _Value, const memory_order _Order) noexcept { 
        const auto _Mem     = _Atomic_address_as<int>(_Storage);
        const int _As_bytes = _Atomic_reinterpret_as<int>(_Value);
        switch (_Order) {
        case memory_order_relaxed:
            __iso_volatile_store32(_Mem, _As_bytes);
            return;
        case memory_order_release:
            __pragma(warning(push)) __pragma(warning(disable : 4996)) _ReadWriteBarrier() __pragma(warning(pop));
            __iso_volatile_store32(_Mem, _As_bytes);
            return;
        default:
        case memory_order_consume:
        case memory_order_acquire:
        case memory_order_acq_rel:
            ;
            
        case memory_order_seq_cst:
            store(_Value);
            return;
        }
    }

    [[nodiscard]] _TVal load() const noexcept { 
        const auto _Mem = _Atomic_address_as<int>(_Storage);
        auto _As_bytes  = __iso_volatile_load32(_Mem);
        __pragma(warning(push)) __pragma(warning(disable : 4996)) _ReadWriteBarrier() __pragma(warning(pop));
        return reinterpret_cast<_TVal&>(_As_bytes);
    }

    [[nodiscard]] _TVal load(const memory_order _Order) const noexcept { 
        const auto _Mem = _Atomic_address_as<int>(_Storage);
        auto _As_bytes  = __iso_volatile_load32(_Mem);
        _Load_barrier(_Order);
        return reinterpret_cast<_TVal&>(_As_bytes);
    }

    _TVal exchange(const _TVal _Value, const memory_order _Order = memory_order_seq_cst) noexcept {
        
        long _As_bytes;
        _Check_memory_order(_Order); _As_bytes = _InterlockedExchange(_Atomic_address_as<long>(_Storage), _Atomic_reinterpret_as<long>(_Value));
#line 922 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        return reinterpret_cast<_TVal&>(_As_bytes);
    }

    bool compare_exchange_strong(_TVal& _Expected, const _TVal _Desired,
        const memory_order _Order = memory_order_seq_cst) noexcept { 
        long _Expected_bytes = _Atomic_reinterpret_as<long>(_Expected); 
        long _Prev_bytes;

        if constexpr (_Might_have_non_value_bits<_TVal>) {
            _Storage_for<_TVal> _Mask{_Form_mask};
            const long _Mask_val = _Atomic_reinterpret_as<long>(_Mask);

            for (;;) {
                _Check_memory_order(_Order); _Prev_bytes = _InterlockedCompareExchange(_Atomic_address_as<long>(_Storage), _Atomic_reinterpret_as<long>(_Desired), _Expected_bytes);
#line 937 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
                if (_Prev_bytes == _Expected_bytes) {
                    return true;
                }

                if ((_Prev_bytes ^ _Expected_bytes) & _Mask_val) {
                    :: memcpy(::std:: addressof(_Expected), &_Prev_bytes, sizeof(_TVal));
                    return false;
                }
                _Expected_bytes = (_Expected_bytes & _Mask_val) | (_Prev_bytes & ~_Mask_val);
            }
        }
#line 949 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        _Check_memory_order(_Order); _Prev_bytes = _InterlockedCompareExchange(_Atomic_address_as<long>(_Storage), _Atomic_reinterpret_as<long>(_Desired), _Expected_bytes);
#line 951 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        if (_Prev_bytes == _Expected_bytes) {
            return true;
        }

        :: memcpy(::std:: addressof(_Expected), &_Prev_bytes, sizeof(_TVal));
        return false;
    }


    void wait(const _TVal _Expected, const memory_order _Order = memory_order_seq_cst) const noexcept {
        _Atomic_wait_direct(this, _Atomic_reinterpret_as<long>(_Expected), _Order);
    }

    void notify_one() noexcept {
        __std_atomic_notify_one_direct(::std:: addressof(_Storage));
    }

    void notify_all() noexcept {
        __std_atomic_notify_all_direct(::std:: addressof(_Storage));
    }
#line 972 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"

    typename _Atomic_storage_types<_Ty>::_TStorage _Storage;
};

template <class _Ty>
struct _Atomic_storage<_Ty, 8> { 

    using _TVal = remove_reference_t<_Ty>;

    _Atomic_storage() = default;

     constexpr _Atomic_storage(conditional_t<is_reference_v<_Ty>, _Ty, const _TVal> _Value) noexcept
        : _Storage{_Value} {
        
    }

    void store(const _TVal _Value) noexcept { 
        const auto _Mem           = _Atomic_address_as<long long>(_Storage);
        const long long _As_bytes = _Atomic_reinterpret_as<long long>(_Value);

        __pragma(warning(push)) __pragma(warning(disable : 4996)) _ReadWriteBarrier() __pragma(warning(pop));
        __iso_volatile_store64(_Mem, _As_bytes);
        ::std:: atomic_thread_fence(memory_order_seq_cst);


#line 1002 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
    }

    void store(const _TVal _Value, const memory_order _Order) noexcept { 
        const auto _Mem           = _Atomic_address_as<long long>(_Storage);
        const long long _As_bytes = _Atomic_reinterpret_as<long long>(_Value);
        switch (_Order) {
        case memory_order_relaxed:
            __iso_volatile_store64(_Mem, _As_bytes);
            return;
        case memory_order_release:
            __pragma(warning(push)) __pragma(warning(disable : 4996)) _ReadWriteBarrier() __pragma(warning(pop));
            __iso_volatile_store64(_Mem, _As_bytes);
            return;
        default:
        case memory_order_consume:
        case memory_order_acquire:
        case memory_order_acq_rel:
            ;
            
        case memory_order_seq_cst:
            store(_Value);
            return;
        }
    }

    [[nodiscard]] _TVal load() const noexcept { 
        const auto _Mem = _Atomic_address_as<long long>(_Storage);
        long long _As_bytes;


        _As_bytes = __iso_volatile_load64(_Mem);
        __pragma(warning(push)) __pragma(warning(disable : 4996)) _ReadWriteBarrier() __pragma(warning(pop));
#line 1037 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        return reinterpret_cast<_TVal&>(_As_bytes);
    }

    [[nodiscard]] _TVal load(const memory_order _Order) const noexcept { 
        const auto _Mem = _Atomic_address_as<long long>(_Storage);


        long long _As_bytes = __iso_volatile_load64(_Mem);
#line 1047 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        _Load_barrier(_Order);
        return reinterpret_cast<_TVal&>(_As_bytes);
    }


    _TVal exchange(const _TVal _Value, const memory_order _Order = memory_order_seq_cst) noexcept {
        
        _TVal _Temp{load()};
        while (!compare_exchange_strong(_Temp, _Value, _Order)) { 
        }

        return _Temp;
    }


#line 1069 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"

    bool compare_exchange_strong(_TVal& _Expected, const _TVal _Desired,
        const memory_order _Order = memory_order_seq_cst) noexcept { 
        long long _Expected_bytes = _Atomic_reinterpret_as<long long>(_Expected); 
        long long _Prev_bytes;


        if constexpr (_Might_have_non_value_bits<_TVal>) {
            _Storage_for<_TVal> _Mask{_Form_mask};
            const long long _Mask_val = _Atomic_reinterpret_as<long long>(_Mask);

            for (;;) {
                _Check_memory_order(_Order); _Prev_bytes = _InterlockedCompareExchange64(_Atomic_address_as<long long>(_Storage), _Atomic_reinterpret_as<long long>(_Desired), _Expected_bytes);
#line 1084 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
                if (_Prev_bytes == _Expected_bytes) {
                    return true;
                }

                if ((_Prev_bytes ^ _Expected_bytes) & _Mask_val) {
                    :: memcpy(::std:: addressof(_Expected), &_Prev_bytes, sizeof(_TVal));
                    return false;
                }
                _Expected_bytes = (_Expected_bytes & _Mask_val) | (_Prev_bytes & ~_Mask_val);
            }
        }
#line 1096 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        _Check_memory_order(_Order); _Prev_bytes = _InterlockedCompareExchange64(_Atomic_address_as<long long>(_Storage), _Atomic_reinterpret_as<long long>(_Desired), _Expected_bytes);
#line 1098 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        if (_Prev_bytes == _Expected_bytes) {
            return true;
        }

        :: memcpy(::std:: addressof(_Expected), &_Prev_bytes, sizeof(_TVal));
        return false;
    }


    void wait(const _TVal _Expected, const memory_order _Order = memory_order_seq_cst) const noexcept {
        _Atomic_wait_direct(this, _Atomic_reinterpret_as<long long>(_Expected), _Order);
    }

    void notify_one() noexcept {
        __std_atomic_notify_one_direct(::std:: addressof(_Storage));
    }

    void notify_all() noexcept {
        __std_atomic_notify_all_direct(::std:: addressof(_Storage));
    }
#line 1119 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"

    typename _Atomic_storage_types<_Ty>::_TStorage _Storage;
};


template <class _Ty, size_t = sizeof(_Ty)>
struct _Atomic_integral; 

template <class _Ty>
struct _Atomic_integral<_Ty, 1> : _Atomic_storage<_Ty> { 
    using _Base = _Atomic_storage<_Ty>;
    using typename _Base::_TVal;

    using _Base::_Base;

    _TVal fetch_add(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
        char _Result;
        _Check_memory_order(_Order); _Result = _InterlockedExchangeAdd8(_Atomic_address_as<char>(this->_Storage), static_cast<char>(_Operand));
#line 1315 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        return static_cast<_TVal>(_Result);
    }

    _TVal fetch_and(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
        char _Result;
        _Check_memory_order(_Order); _Result = _InterlockedAnd8(_Atomic_address_as<char>(this->_Storage), static_cast<char>(_Operand));
#line 1322 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        return static_cast<_TVal>(_Result);
    }

    _TVal fetch_or(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
        char _Result;
        _Check_memory_order(_Order); _Result = _InterlockedOr8(_Atomic_address_as<char>(this->_Storage), static_cast<char>(_Operand));
#line 1329 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        return static_cast<_TVal>(_Result);
    }

    _TVal fetch_xor(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
        char _Result;
        _Check_memory_order(_Order); _Result = _InterlockedXor8(_Atomic_address_as<char>(this->_Storage), static_cast<char>(_Operand));
#line 1336 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        return static_cast<_TVal>(_Result);
    }

    _TVal operator++(int) noexcept {
        return static_cast<_TVal>(_InterlockedExchangeAdd8(_Atomic_address_as<char>(this->_Storage), 1));
    }

    _TVal operator++() noexcept {
        unsigned char _Before =
            static_cast<unsigned char>(_InterlockedExchangeAdd8(_Atomic_address_as<char>(this->_Storage), 1));
        ++_Before;
        return static_cast<_TVal>(_Before);
    }

    _TVal operator--(int) noexcept {
        return static_cast<_TVal>(_InterlockedExchangeAdd8(_Atomic_address_as<char>(this->_Storage), -1));
    }

    _TVal operator--() noexcept {
        unsigned char _Before =
            static_cast<unsigned char>(_InterlockedExchangeAdd8(_Atomic_address_as<char>(this->_Storage), -1));
        --_Before;
        return static_cast<_TVal>(_Before);
    }
};

template <class _Ty>
struct _Atomic_integral<_Ty, 2> : _Atomic_storage<_Ty> { 
    using _Base = _Atomic_storage<_Ty>;
    using typename _Base::_TVal;

    using _Base::_Base;

    _TVal fetch_add(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
        short _Result;
        _Check_memory_order(_Order); _Result = _InterlockedExchangeAdd16(_Atomic_address_as<short>(this->_Storage), static_cast<short>(_Operand));
#line 1373 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        return static_cast<_TVal>(_Result);
    }

    _TVal fetch_and(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
        short _Result;
        _Check_memory_order(_Order); _Result = _InterlockedAnd16(_Atomic_address_as<short>(this->_Storage), static_cast<short>(_Operand));
#line 1380 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        return static_cast<_TVal>(_Result);
    }

    _TVal fetch_or(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
        short _Result;
        _Check_memory_order(_Order); _Result = _InterlockedOr16(_Atomic_address_as<short>(this->_Storage), static_cast<short>(_Operand));
#line 1387 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        return static_cast<_TVal>(_Result);
    }

    _TVal fetch_xor(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
        short _Result;
        _Check_memory_order(_Order); _Result = _InterlockedXor16(_Atomic_address_as<short>(this->_Storage), static_cast<short>(_Operand));
#line 1394 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        return static_cast<_TVal>(_Result);
    }

    _TVal operator++(int) noexcept {
        unsigned short _After =
            static_cast<unsigned short>(_InterlockedIncrement16(_Atomic_address_as<short>(this->_Storage)));
        --_After;
        return static_cast<_TVal>(_After);
    }

    _TVal operator++() noexcept {
        return static_cast<_TVal>(_InterlockedIncrement16(_Atomic_address_as<short>(this->_Storage)));
    }

    _TVal operator--(int) noexcept {
        unsigned short _After =
            static_cast<unsigned short>(_InterlockedDecrement16(_Atomic_address_as<short>(this->_Storage)));
        ++_After;
        return static_cast<_TVal>(_After);
    }

    _TVal operator--() noexcept {
        return static_cast<_TVal>(_InterlockedDecrement16(_Atomic_address_as<short>(this->_Storage)));
    }
};

template <class _Ty>
struct _Atomic_integral<_Ty, 4> : _Atomic_storage<_Ty> { 
    using _Base = _Atomic_storage<_Ty>;
    using typename _Base::_TVal;

    using _Base::_Base;

    _TVal fetch_add(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
        long _Result;
        _Check_memory_order(_Order); _Result = _InterlockedExchangeAdd(_Atomic_address_as<long>(this->_Storage), static_cast<long>(_Operand));
#line 1431 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        return static_cast<_TVal>(_Result);
    }

    _TVal fetch_and(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
        long _Result;
        _Check_memory_order(_Order); _Result = _InterlockedAnd(_Atomic_address_as<long>(this->_Storage), static_cast<long>(_Operand));
#line 1438 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        return static_cast<_TVal>(_Result);
    }

    _TVal fetch_or(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
        long _Result;
        _Check_memory_order(_Order); _Result = _InterlockedOr(_Atomic_address_as<long>(this->_Storage), static_cast<long>(_Operand));
#line 1445 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        return static_cast<_TVal>(_Result);
    }

    _TVal fetch_xor(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
        long _Result;
        _Check_memory_order(_Order); _Result = _InterlockedXor(_Atomic_address_as<long>(this->_Storage), static_cast<long>(_Operand));
#line 1452 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        return static_cast<_TVal>(_Result);
    }

    _TVal operator++(int) noexcept {
        unsigned long _After =
            static_cast<unsigned long>(_InterlockedIncrement(_Atomic_address_as<long>(this->_Storage)));
        --_After;
        return static_cast<_TVal>(_After);
    }

    _TVal operator++() noexcept {
        return static_cast<_TVal>(_InterlockedIncrement(_Atomic_address_as<long>(this->_Storage)));
    }

    _TVal operator--(int) noexcept {
        unsigned long _After =
            static_cast<unsigned long>(_InterlockedDecrement(_Atomic_address_as<long>(this->_Storage)));
        ++_After;
        return static_cast<_TVal>(_After);
    }

    _TVal operator--() noexcept {
        return static_cast<_TVal>(_InterlockedDecrement(_Atomic_address_as<long>(this->_Storage)));
    }
};

template <class _Ty>
struct _Atomic_integral<_Ty, 8> : _Atomic_storage<_Ty> { 
    using _Base = _Atomic_storage<_Ty>;
    using typename _Base::_TVal;

    using _Base::_Base;


    _TVal fetch_add(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
        
        _TVal _Temp{this->load()};
        while (!this->compare_exchange_strong(_Temp, _Temp + _Operand, _Order)) { 
        }

        return _Temp;
    }

    _TVal fetch_and(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
        
        _TVal _Temp{this->load()};
        while (!this->compare_exchange_strong(_Temp, _Temp & _Operand, _Order)) { 
        }

        return _Temp;
    }

    _TVal fetch_or(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
        
        _TVal _Temp{this->load()};
        while (!this->compare_exchange_strong(_Temp, _Temp | _Operand, _Order)) { 
        }

        return _Temp;
    }

    _TVal fetch_xor(const _TVal _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
        
        _TVal _Temp{this->load()};
        while (!this->compare_exchange_strong(_Temp, _Temp ^ _Operand, _Order)) { 
        }

        return _Temp;
    }

    _TVal operator++(int) noexcept {
        return fetch_add(static_cast<_TVal>(1));
    }

    _TVal operator++() noexcept {
        return fetch_add(static_cast<_TVal>(1)) + static_cast<_TVal>(1);
    }

    _TVal operator--(int) noexcept {
        return fetch_add(static_cast<_TVal>(-1));
    }

    _TVal operator--() noexcept {
        return fetch_add(static_cast<_TVal>(-1)) - static_cast<_TVal>(1);
    }


#line 1589 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
};


template <size_t _TypeSize>
inline constexpr bool _Is_always_lock_free = _TypeSize <= 8 && (_TypeSize & (_TypeSize - 1)) == 0;


#line 1603 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"

template <class _Ty, bool _Is_lock_free = _Is_always_lock_free<sizeof(_Ty)>>
inline constexpr bool _Deprecate_non_lock_free_volatile = true;

template <class _Ty>
[[deprecated("warning STL4030: " "Some operations on volatile-qualified types in the STL are deprecated in C++20. " "You can define _SILENCE_CXX20_VOLATILE_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] inline constexpr bool _Deprecate_non_lock_free_volatile<_Ty, false> = true;

template <class _Ty>
struct _Atomic_integral_facade : _Atomic_integral<_Ty> {
    
    using _Base           = _Atomic_integral<_Ty>;
    using difference_type = _Ty;

    using _Base::_Base;

    
    using _Base::fetch_add;
    _Ty fetch_add(const _Ty _Operand) volatile noexcept {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_add(_Operand);
    }

    _Ty fetch_add(const _Ty _Operand, const memory_order _Order) volatile noexcept {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_add(_Operand, _Order);
    }

    [[nodiscard]] static _Ty _Negate(const _Ty _Value) noexcept { 
        return static_cast<_Ty>(0U - static_cast<make_unsigned_t<_Ty>>(_Value));
    }

    _Ty fetch_sub(const _Ty _Operand) noexcept {
        return fetch_add(_Negate(_Operand));
    }

    _Ty fetch_sub(const _Ty _Operand) volatile noexcept {
        return fetch_add(_Negate(_Operand));
    }

    _Ty fetch_sub(const _Ty _Operand, const memory_order _Order) noexcept {
        return fetch_add(_Negate(_Operand), _Order);
    }

    _Ty fetch_sub(const _Ty _Operand, const memory_order _Order) volatile noexcept {
        return fetch_add(_Negate(_Operand), _Order);
    }

    using _Base::fetch_and;
    _Ty fetch_and(const _Ty _Operand) volatile noexcept {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_and(_Operand);
    }

    _Ty fetch_and(const _Ty _Operand, const memory_order _Order) volatile noexcept {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_and(_Operand, _Order);
    }

    using _Base::fetch_or;
    _Ty fetch_or(const _Ty _Operand) volatile noexcept {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_or(_Operand);
    }

    _Ty fetch_or(const _Ty _Operand, const memory_order _Order) volatile noexcept {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_or(_Operand, _Order);
    }

    using _Base::fetch_xor;
    _Ty fetch_xor(const _Ty _Operand) volatile noexcept {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_xor(_Operand);
    }

    _Ty fetch_xor(const _Ty _Operand, const memory_order _Order) volatile noexcept {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_xor(_Operand, _Order);
    }

    using _Base::operator++;
    _Ty operator++(int) volatile noexcept {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::operator++(0);
    }

    _Ty operator++() volatile noexcept {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::operator++();
    }

    using _Base::operator--;
    _Ty operator--(int) volatile noexcept {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::operator--(0);
    }

    _Ty operator--() volatile noexcept {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::operator--();
    }

    _Ty operator+=(const _Ty _Operand) noexcept {
        return static_cast<_Ty>(this->_Base::fetch_add(_Operand) + _Operand);
    }

    _Ty operator+=(const _Ty _Operand) volatile noexcept {
        return static_cast<_Ty>(const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_add(_Operand) + _Operand);
    }

    _Ty operator-=(const _Ty _Operand) noexcept {
        return static_cast<_Ty>(fetch_sub(_Operand) - _Operand);
    }

    _Ty operator-=(const _Ty _Operand) volatile noexcept {
        return static_cast<_Ty>(const_cast<_Atomic_integral_facade*>(this)->fetch_sub(_Operand) - _Operand);
    }

    _Ty operator&=(const _Ty _Operand) noexcept {
        return static_cast<_Ty>(this->_Base::fetch_and(_Operand) & _Operand);
    }

    _Ty operator&=(const _Ty _Operand) volatile noexcept {
        return static_cast<_Ty>(const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_and(_Operand) & _Operand);
    }

    _Ty operator|=(const _Ty _Operand) noexcept {
        return static_cast<_Ty>(this->_Base::fetch_or(_Operand) | _Operand);
    }

    _Ty operator|=(const _Ty _Operand) volatile noexcept {
        return static_cast<_Ty>(const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_or(_Operand) | _Operand);
    }

    _Ty operator^=(const _Ty _Operand) noexcept {
        return static_cast<_Ty>(this->_Base::fetch_xor(_Operand) ^ _Operand);
    }

    _Ty operator^=(const _Ty _Operand) volatile noexcept {
        return static_cast<_Ty>(const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_xor(_Operand) ^ _Operand);
    }
};

template <class _Ty>
struct _Atomic_integral_facade<_Ty&> : _Atomic_integral<_Ty&> {
    
    using _Base           = _Atomic_integral<_Ty&>;
    using difference_type = _Ty;

    using _Base::_Base;

    [[nodiscard]] static _Ty _Negate(const _Ty _Value) noexcept { 
        return static_cast<_Ty>(0U - static_cast<make_unsigned_t<_Ty>>(_Value));
    }

    _Ty fetch_add(const _Ty _Operand) const noexcept {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_add(_Operand);
    }

    _Ty fetch_add(const _Ty _Operand, const memory_order _Order) const noexcept {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_add(_Operand, _Order);
    }

    _Ty fetch_sub(const _Ty _Operand) const noexcept {
        return fetch_add(_Negate(_Operand));
    }

    _Ty fetch_sub(const _Ty _Operand, const memory_order _Order) const noexcept {
        return fetch_add(_Negate(_Operand), _Order);
    }

    _Ty operator++(int) const noexcept {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::operator++(0);
    }

    _Ty operator++() const noexcept {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::operator++();
    }

    _Ty operator--(int) const noexcept {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::operator--(0);
    }

    _Ty operator--() const noexcept {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::operator--();
    }

    _Ty operator+=(const _Ty _Operand) const noexcept {
        return static_cast<_Ty>(fetch_add(_Operand) + _Operand);
    }

    _Ty operator-=(const _Ty _Operand) const noexcept {
        return static_cast<_Ty>(fetch_sub(_Operand) - _Operand);
    }

    _Ty fetch_and(const _Ty _Operand) const noexcept {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_and(_Operand);
    }

    _Ty fetch_and(const _Ty _Operand, const memory_order _Order) const noexcept {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_and(_Operand, _Order);
    }

    _Ty fetch_or(const _Ty _Operand) const noexcept {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_or(_Operand);
    }

    _Ty fetch_or(const _Ty _Operand, const memory_order _Order) const noexcept {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_or(_Operand, _Order);
    }

    _Ty fetch_xor(const _Ty _Operand) const noexcept {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_xor(_Operand);
    }

    _Ty fetch_xor(const _Ty _Operand, const memory_order _Order) const noexcept {
        return const_cast<_Atomic_integral_facade*>(this)->_Base::fetch_xor(_Operand, _Order);
    }

    _Ty operator&=(const _Ty _Operand) const noexcept {
        return static_cast<_Ty>(fetch_and(_Operand) & _Operand);
    }

    _Ty operator|=(const _Ty _Operand) const noexcept {
        return static_cast<_Ty>(fetch_or(_Operand) | _Operand);
    }

    _Ty operator^=(const _Ty _Operand) const noexcept {
        return static_cast<_Ty>(fetch_xor(_Operand) ^ _Operand);
    }
};


template <class _Ty>
struct _Atomic_floating : _Atomic_storage<_Ty> {
    
    using _Base           = _Atomic_storage<_Ty>;
    using difference_type = _Ty;

    using _Base::_Base;

    _Ty fetch_add(const _Ty _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
        _Ty _Temp{this->load(memory_order_relaxed)};
        while (!this->compare_exchange_strong(_Temp, _Temp + _Operand, _Order)) { 
        }

        return _Temp;
    }

    
    _Ty fetch_add(const _Ty _Operand, const memory_order _Order = memory_order_seq_cst) volatile noexcept {
        return const_cast<_Atomic_floating*>(this)->fetch_add(_Operand, _Order);
    }

    _Ty fetch_sub(const _Ty _Operand, const memory_order _Order = memory_order_seq_cst) noexcept {
        _Ty _Temp{this->load(memory_order_relaxed)};
        while (!this->compare_exchange_strong(_Temp, _Temp - _Operand, _Order)) { 
        }

        return _Temp;
    }

    _Ty fetch_sub(const _Ty _Operand, const memory_order _Order = memory_order_seq_cst) volatile noexcept {
        return const_cast<_Atomic_floating*>(this)->fetch_sub(_Operand, _Order);
    }

    _Ty operator+=(const _Ty _Operand) noexcept {
        return fetch_add(_Operand) + _Operand;
    }

    _Ty operator+=(const _Ty _Operand) volatile noexcept {
        return const_cast<_Atomic_floating*>(this)->fetch_add(_Operand) + _Operand;
    }

    _Ty operator-=(const _Ty _Operand) noexcept {
        return fetch_sub(_Operand) - _Operand;
    }

    _Ty operator-=(const _Ty _Operand) volatile noexcept {
        return const_cast<_Atomic_floating*>(this)->fetch_sub(_Operand) - _Operand;
    }
};

template <class _Ty>
struct _Atomic_floating<_Ty&> : _Atomic_storage<_Ty&> {
    
    using _Base           = _Atomic_storage<_Ty&>;
    using difference_type = _Ty;

    using _Base::_Base;

    _Ty fetch_add(const _Ty _Operand, const memory_order _Order = memory_order_seq_cst) const noexcept {
        _Ty _Temp{this->load(memory_order_relaxed)};
        while (!const_cast<_Atomic_floating*>(this)->_Base::compare_exchange_strong(
            _Temp, _Temp + _Operand, _Order)) { 
        }

        return _Temp;
    }

    _Ty fetch_sub(const _Ty _Operand, const memory_order _Order = memory_order_seq_cst) const noexcept {
        _Ty _Temp{this->load(memory_order_relaxed)};
        while (!const_cast<_Atomic_floating*>(this)->_Base::compare_exchange_strong(
            _Temp, _Temp - _Operand, _Order)) { 
        }

        return _Temp;
    }

    _Ty operator+=(const _Ty _Operand) const noexcept {
        return fetch_add(_Operand) + _Operand;
    }

    _Ty operator-=(const _Ty _Operand) const noexcept {
        return fetch_sub(_Operand) - _Operand;
    }
};
#line 1917 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"

template <class _Ty>
struct _Atomic_pointer : _Atomic_storage<_Ty> {
    using _Base           = _Atomic_storage<_Ty>;
    using difference_type = ptrdiff_t;

    using _Base::_Base;

    _Ty fetch_add(const ptrdiff_t _Diff, const memory_order _Order = memory_order_seq_cst) noexcept {
        const ptrdiff_t _Shift_bytes =
            static_cast<ptrdiff_t>(static_cast<size_t>(_Diff) * sizeof(remove_pointer_t<_Ty>));
        ptrdiff_t _Result;

        _Check_memory_order(_Order); _Result = _InterlockedExchangeAdd(_Atomic_address_as<long>(this->_Storage), _Shift_bytes);
#line 1932 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"


#line 1936 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        return reinterpret_cast<_Ty>(_Result);
    }

    
    _Ty fetch_add(const ptrdiff_t _Diff) volatile noexcept {
        return const_cast<_Atomic_pointer*>(this)->fetch_add(_Diff);
    }

    _Ty fetch_add(const ptrdiff_t _Diff, const memory_order _Order) volatile noexcept {
        return const_cast<_Atomic_pointer*>(this)->fetch_add(_Diff, _Order);
    }

    _Ty fetch_sub(const ptrdiff_t _Diff) volatile noexcept {
        return fetch_add(static_cast<ptrdiff_t>(0 - static_cast<size_t>(_Diff)));
    }

    _Ty fetch_sub(const ptrdiff_t _Diff) noexcept {
        return fetch_add(static_cast<ptrdiff_t>(0 - static_cast<size_t>(_Diff)));
    }

    _Ty fetch_sub(const ptrdiff_t _Diff, const memory_order _Order) volatile noexcept {
        return fetch_add(static_cast<ptrdiff_t>(0 - static_cast<size_t>(_Diff)), _Order);
    }

    _Ty fetch_sub(const ptrdiff_t _Diff, const memory_order _Order) noexcept {
        return fetch_add(static_cast<ptrdiff_t>(0 - static_cast<size_t>(_Diff)), _Order);
    }

    _Ty operator++(int) volatile noexcept {
        return fetch_add(1);
    }

    _Ty operator++(int) noexcept {
        return fetch_add(1);
    }

    _Ty operator++() volatile noexcept {
        return fetch_add(1) + 1;
    }

    _Ty operator++() noexcept {
        return fetch_add(1) + 1;
    }

    _Ty operator--(int) volatile noexcept {
        return fetch_add(-1);
    }

    _Ty operator--(int) noexcept {
        return fetch_add(-1);
    }

    _Ty operator--() volatile noexcept {
        return fetch_add(-1) - 1;
    }

    _Ty operator--() noexcept {
        return fetch_add(-1) - 1;
    }

    _Ty operator+=(const ptrdiff_t _Diff) volatile noexcept {
        return fetch_add(_Diff) + _Diff;
    }

    _Ty operator+=(const ptrdiff_t _Diff) noexcept {
        return fetch_add(_Diff) + _Diff;
    }

    _Ty operator-=(const ptrdiff_t _Diff) volatile noexcept {
        return fetch_add(static_cast<ptrdiff_t>(0 - static_cast<size_t>(_Diff))) - _Diff;
    }

    _Ty operator-=(const ptrdiff_t _Diff) noexcept {
        return fetch_add(static_cast<ptrdiff_t>(0 - static_cast<size_t>(_Diff))) - _Diff;
    }
};


template <class _Ty>
struct _Atomic_pointer<_Ty&> : _Atomic_storage<_Ty&> {
    using _Base           = _Atomic_storage<_Ty&>;
    using difference_type = ptrdiff_t;

    using _Base::_Base;

    _Ty fetch_add(const ptrdiff_t _Diff, const memory_order _Order = memory_order_seq_cst) const noexcept {
        const ptrdiff_t _Shift_bytes =
            static_cast<ptrdiff_t>(static_cast<size_t>(_Diff) * sizeof(remove_pointer_t<_Ty>));
        ptrdiff_t _Result;

        _Check_memory_order(_Order); _Result = _InterlockedExchangeAdd(_Atomic_address_as<long>(this->_Storage), _Shift_bytes);
#line 2029 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"


#line 2033 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
        return reinterpret_cast<_Ty>(_Result);
    }

    _Ty fetch_sub(const ptrdiff_t _Diff) const noexcept {
        return fetch_add(static_cast<ptrdiff_t>(0 - static_cast<size_t>(_Diff)));
    }

    _Ty fetch_sub(const ptrdiff_t _Diff, const memory_order _Order) const noexcept {
        return fetch_add(static_cast<ptrdiff_t>(0 - static_cast<size_t>(_Diff)), _Order);
    }

    _Ty operator++(int) const noexcept {
        return fetch_add(1);
    }

    _Ty operator++() const noexcept {
        return fetch_add(1) + 1;
    }

    _Ty operator--(int) const noexcept {
        return fetch_add(-1);
    }

    _Ty operator--() const noexcept {
        return fetch_add(-1) - 1;
    }

    _Ty operator+=(const ptrdiff_t _Diff) const noexcept {
        return fetch_add(_Diff) + _Diff;
    }

    _Ty operator-=(const ptrdiff_t _Diff) const noexcept {
        return fetch_add(static_cast<ptrdiff_t>(0 - static_cast<size_t>(_Diff))) - _Diff;
    }
};


template <class _TVal, class _Ty = _TVal>
using _Choose_atomic_base2_t =
    typename _Select<is_integral_v<_TVal> && !is_same_v<bool, _TVal>>::template _Apply<_Atomic_integral_facade<_Ty>,
        typename _Select<is_pointer_v<_TVal> && is_object_v<remove_pointer_t<_TVal>>>::template _Apply<
            _Atomic_pointer<_Ty>, _Atomic_storage<_Ty>>>;


template <class _TVal, class _Ty = _TVal>
using _Choose_atomic_base_t = typename _Select<is_floating_point_v<_TVal>>::template _Apply<_Atomic_floating<_Ty>,
    _Choose_atomic_base2_t<_TVal, _Ty>>;


#line 2087 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"

template <class _Ty>
struct atomic : _Choose_atomic_base_t<_Ty> { 
private:
    using _Base = _Choose_atomic_base_t<_Ty>;

public:
    static_assert(is_trivially_copyable_v<_Ty> && is_copy_constructible_v<_Ty> && is_move_constructible_v<_Ty> 
                      && is_copy_assignable_v<_Ty> && is_move_assignable_v<_Ty>,
        "atomic<T> requires T to be trivially copyable, copy constructible, move constructible, copy assignable, "
        "and move assignable.");

    using value_type = _Ty;

    using _Base::_Base;

    constexpr atomic() noexcept(is_nothrow_default_constructible_v<_Ty>) : _Base() {}

    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;


    static constexpr bool is_always_lock_free = _Is_always_lock_free<sizeof(_Ty)>;
#line 2111 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"


    [[nodiscard]] bool is_lock_free() const volatile noexcept {
        constexpr bool _Result = sizeof(_Ty) <= 8 && (sizeof(_Ty) & sizeof(_Ty) - 1) == 0;
        return _Result;
    }


#line 2128 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"

    [[nodiscard]] bool is_lock_free() const noexcept {
        return static_cast<const volatile atomic*>(this)->is_lock_free();
    }

    _Ty operator=(const _Ty _Value) volatile noexcept {
        static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
        this->store(_Value);
        return _Value;
    }

    _Ty operator=(const _Ty _Value) noexcept {
        this->store(_Value);
        return _Value;
    }

    
    using _Base::store;
    void store(const _Ty _Value) volatile noexcept {
        static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
        const_cast<atomic*>(this)->_Base::store(_Value);
    }

    void store(const _Ty _Value, const memory_order _Order) volatile noexcept {
        static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
        const_cast<atomic*>(this)->_Base::store(_Value, _Order);
    }

    using _Base::load;
    [[nodiscard]] _Ty load() const volatile noexcept {
        static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
        return const_cast<const atomic*>(this)->_Base::load();
    }

    [[nodiscard]] _Ty load(const memory_order _Order) const volatile noexcept {
        static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
        return const_cast<const atomic*>(this)->_Base::load(_Order);
    }

    using _Base::exchange;
    _Ty exchange(const _Ty _Value) volatile noexcept {
        static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
        return const_cast<atomic*>(this)->_Base::exchange(_Value);
    }

    _Ty exchange(const _Ty _Value, const memory_order _Order) volatile noexcept {
        static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
        return const_cast<atomic*>(this)->_Base::exchange(_Value, _Order);
    }

    using _Base::compare_exchange_strong;
    bool compare_exchange_strong(_Ty& _Expected, const _Ty _Desired) volatile noexcept {
        static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
        return const_cast<atomic*>(this)->_Base::compare_exchange_strong(_Expected, _Desired);
    }

    bool compare_exchange_strong(_Ty& _Expected, const _Ty _Desired, const memory_order _Order) volatile noexcept {
        static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
        return const_cast<atomic*>(this)->_Base::compare_exchange_strong(_Expected, _Desired, _Order);
    }

    bool compare_exchange_strong(_Ty& _Expected, const _Ty _Desired, const memory_order _Success,
        const memory_order _Failure) volatile noexcept {
        static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
        return this->compare_exchange_strong(_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
    }

    bool compare_exchange_strong(
        _Ty& _Expected, const _Ty _Desired, const memory_order _Success, const memory_order _Failure) noexcept {
        return this->compare_exchange_strong(_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
    }

    bool compare_exchange_weak(_Ty& _Expected, const _Ty _Desired) volatile noexcept {
        
        static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
        return this->compare_exchange_strong(_Expected, _Desired);
    }

    bool compare_exchange_weak(_Ty& _Expected, const _Ty _Desired) noexcept {
        return this->compare_exchange_strong(_Expected, _Desired);
    }

    bool compare_exchange_weak(_Ty& _Expected, const _Ty _Desired, const memory_order _Order) volatile noexcept {
        static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
        return this->compare_exchange_strong(_Expected, _Desired, _Order);
    }

    bool compare_exchange_weak(_Ty& _Expected, const _Ty _Desired, const memory_order _Order) noexcept {
        return this->compare_exchange_strong(_Expected, _Desired, _Order);
    }

    bool compare_exchange_weak(_Ty& _Expected, const _Ty _Desired, const memory_order _Success,
        const memory_order _Failure) volatile noexcept {
        static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
        return this->compare_exchange_strong(_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
    }

    bool compare_exchange_weak(
        _Ty& _Expected, const _Ty _Desired, const memory_order _Success, const memory_order _Failure) noexcept {
        return this->compare_exchange_strong(_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
    }


    using _Base::wait;
    void wait(const _Ty _Expected, const memory_order _Order = memory_order_seq_cst) const volatile noexcept {
        const_cast<const atomic*>(this)->_Base::wait(_Expected, _Order);
    }

    using _Base::notify_one;
    void notify_one() volatile noexcept {
        const_cast<atomic*>(this)->_Base::notify_one();
    }

    using _Base::notify_all;
    void notify_all() volatile noexcept {
        const_cast<atomic*>(this)->_Base::notify_all();
    }
#line 2250 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"

    operator _Ty() const volatile noexcept {
        static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
        return this->load();
    }

    operator _Ty() const noexcept {
        return this->load();
    }
};


template <class _Ty>
atomic(_Ty) -> atomic<_Ty>;
#line 2265 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"


template <class _Ty>
struct atomic_ref : _Choose_atomic_base_t<_Ty, _Ty&> { 
private:
    using _Base = _Choose_atomic_base_t<_Ty, _Ty&>;

public:
    static_assert(is_trivially_copyable_v<_Ty>, "atomic_ref<T> requires T to be trivially copyable.");

    using value_type = _Ty;

    explicit atomic_ref(_Ty& _Value) noexcept  : _Base(_Value) {
        if constexpr (_Is_potentially_lock_free) {
            _Check_alignment(_Value);
        } else {
            this->_Init_spinlock_for_ref();
        }
    }

    atomic_ref(const atomic_ref&) noexcept = default;

    atomic_ref& operator=(const atomic_ref&) = delete;

    static constexpr bool is_always_lock_free = _Is_always_lock_free<sizeof(_Ty)>;

    static constexpr bool _Is_potentially_lock_free =
        sizeof(_Ty) <= 2 * sizeof(void*) && (sizeof(_Ty) & (sizeof(_Ty) - 1)) == 0;

    static constexpr size_t required_alignment = _Is_potentially_lock_free ? sizeof(_Ty) : alignof(_Ty);

    [[nodiscard]] bool is_lock_free() const noexcept {

        return is_always_lock_free;


#line 2306 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
    }

    void store(const _Ty _Value) const noexcept {
        const_cast<atomic_ref*>(this)->_Base::store(_Value);
    }

    void store(const _Ty _Value, const memory_order _Order) const noexcept {
        const_cast<atomic_ref*>(this)->_Base::store(_Value, _Order);
    }

    _Ty operator=(const _Ty _Value) const noexcept {
        store(_Value);
        return _Value;
    }

    _Ty exchange(const _Ty _Value) const noexcept {
        return const_cast<atomic_ref*>(this)->_Base::exchange(_Value);
    }

    _Ty exchange(const _Ty _Value, const memory_order _Order) const noexcept {
        return const_cast<atomic_ref*>(this)->_Base::exchange(_Value, _Order);
    }

    bool compare_exchange_strong(_Ty& _Expected, const _Ty _Desired) const noexcept {
        return const_cast<atomic_ref*>(this)->_Base::compare_exchange_strong(_Expected, _Desired);
    }

    bool compare_exchange_strong(_Ty& _Expected, const _Ty _Desired, const memory_order _Order) const noexcept {
        return const_cast<atomic_ref*>(this)->_Base::compare_exchange_strong(_Expected, _Desired, _Order);
    }

    bool compare_exchange_strong(
        _Ty& _Expected, const _Ty _Desired, const memory_order _Success, const memory_order _Failure) const noexcept {
        return compare_exchange_strong(_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
    }

    bool compare_exchange_weak(_Ty& _Expected, const _Ty _Desired) const noexcept {
        return compare_exchange_strong(_Expected, _Desired);
    }

    bool compare_exchange_weak(_Ty& _Expected, const _Ty _Desired, const memory_order _Order) const noexcept {
        return compare_exchange_strong(_Expected, _Desired, _Order);
    }

    bool compare_exchange_weak(
        _Ty& _Expected, const _Ty _Desired, const memory_order _Success, const memory_order _Failure) const noexcept {
        return compare_exchange_strong(_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
    }

    operator _Ty() const noexcept {
        return this->load();
    }

    void notify_one() const noexcept {
        const_cast<atomic_ref*>(this)->_Base::notify_one();
    }

    void notify_all() const noexcept {
        const_cast<atomic_ref*>(this)->_Base::notify_all();
    }

private:
    static void _Check_alignment([[maybe_unused]] const _Ty& _Value) {
        ;
#line 2372 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
    }
};
#line 2375 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"

template <class _Ty>
[[nodiscard]] bool atomic_is_lock_free(const volatile atomic<_Ty>* _Mem) noexcept {
    return _Mem->is_lock_free();
}

template <class _Ty>
[[nodiscard]] bool atomic_is_lock_free(const atomic<_Ty>* _Mem) noexcept {
    return _Mem->is_lock_free();
}

template <class _Ty>
void atomic_store(volatile atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value) noexcept {
    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
    _Mem->store(_Value);
}

template <class _Ty>
void atomic_store(atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value) noexcept {
    _Mem->store(_Value);
}

template <class _Ty>
void atomic_store_explicit(
    volatile atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value, const memory_order _Order) noexcept {
    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
    _Mem->store(_Value, _Order);
}

template <class _Ty>
void atomic_store_explicit(atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value, const memory_order _Order) noexcept {
    _Mem->store(_Value, _Order);
}

template <class _Ty>
[[deprecated("warning STL4028: " "std::atomic_init() overloads are deprecated in C++20. " "The constructors of std::atomic provide equivalent functionality. " "You can define _SILENCE_CXX20_ATOMIC_INIT_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] void atomic_init(
    volatile atomic<_Ty>* const _Mem, const typename atomic<_Ty>::value_type _Value) noexcept {
    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
    ::std:: atomic_store_explicit(_Mem, _Value, memory_order_relaxed);
}

template <class _Ty>
[[deprecated("warning STL4028: " "std::atomic_init() overloads are deprecated in C++20. " "The constructors of std::atomic provide equivalent functionality. " "You can define _SILENCE_CXX20_ATOMIC_INIT_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] void atomic_init(
    atomic<_Ty>* const _Mem, const typename atomic<_Ty>::value_type _Value) noexcept {
    ::std:: atomic_store_explicit(_Mem, _Value, memory_order_relaxed);
}

template <class _Ty>
[[nodiscard]] _Ty atomic_load(const volatile atomic<_Ty>* const _Mem) noexcept {
    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
    return _Mem->load();
}

template <class _Ty>
[[nodiscard]] _Ty atomic_load(const atomic<_Ty>* const _Mem) noexcept {
    return _Mem->load();
}

template <class _Ty>
[[nodiscard]] _Ty atomic_load_explicit(const volatile atomic<_Ty>* const _Mem, const memory_order _Order) noexcept {
    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
    return _Mem->load(_Order);
}

template <class _Ty>
[[nodiscard]] _Ty atomic_load_explicit(const atomic<_Ty>* const _Mem, const memory_order _Order) noexcept {
    return _Mem->load(_Order);
}

template <class _Ty>
_Ty atomic_exchange(volatile atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value) noexcept {
    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
    return _Mem->exchange(_Value);
}

template <class _Ty>
_Ty atomic_exchange(atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value) noexcept {
    return _Mem->exchange(_Value);
}

template <class _Ty>
_Ty atomic_exchange_explicit(
    volatile atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value, const memory_order _Order) noexcept {
    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
    return _Mem->exchange(_Value, _Order);
}

template <class _Ty>
_Ty atomic_exchange_explicit(
    atomic<_Ty>* const _Mem, const _Identity_t<_Ty> _Value, const memory_order _Order) noexcept {
    return _Mem->exchange(_Value, _Order);
}

template <class _Ty>
bool atomic_compare_exchange_strong(
    volatile atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected, const _Identity_t<_Ty> _Desired) noexcept {
    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
    return _Mem->compare_exchange_strong(*_Expected, _Desired);
}

template <class _Ty>
bool atomic_compare_exchange_strong(
    atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected, const _Identity_t<_Ty> _Desired) noexcept {
    return _Mem->compare_exchange_strong(*_Expected, _Desired);
}

template <class _Ty>
bool atomic_compare_exchange_strong_explicit(volatile atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected,
    const _Identity_t<_Ty> _Desired, const memory_order _Success, const memory_order _Failure) noexcept {
    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
    return _Mem->compare_exchange_strong(*_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
}

template <class _Ty>
bool atomic_compare_exchange_strong_explicit(atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected,
    const _Identity_t<_Ty> _Desired, const memory_order _Success, const memory_order _Failure) noexcept {
    return _Mem->compare_exchange_strong(*_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
}

template <class _Ty>
bool atomic_compare_exchange_weak(
    volatile atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected, const _Identity_t<_Ty> _Desired) noexcept {
    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
    return _Mem->compare_exchange_strong(*_Expected, _Desired);
}

template <class _Ty>
bool atomic_compare_exchange_weak(
    atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected, const _Identity_t<_Ty> _Desired) noexcept {
    return _Mem->compare_exchange_strong(*_Expected, _Desired);
}

template <class _Ty>
bool atomic_compare_exchange_weak_explicit(volatile atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected,
    const _Identity_t<_Ty> _Desired, const memory_order _Success, const memory_order _Failure) noexcept {
    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
    return _Mem->compare_exchange_strong(*_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
}

template <class _Ty>
bool atomic_compare_exchange_weak_explicit(atomic<_Ty>* const _Mem, _Identity_t<_Ty>* const _Expected,
    const _Identity_t<_Ty> _Desired, const memory_order _Success, const memory_order _Failure) noexcept {
    return _Mem->compare_exchange_strong(*_Expected, _Desired, _Combine_cas_memory_orders(_Success, _Failure));
}

template <class _Ty>
_Ty atomic_fetch_add(volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value) noexcept {
    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
    return _Mem->fetch_add(_Value);
}

template <class _Ty>
_Ty atomic_fetch_add(atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value) noexcept {
    return _Mem->fetch_add(_Value);
}

template <class _Ty>
_Ty atomic_fetch_add_explicit(volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value,
    const memory_order _Order) noexcept {
    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
    return _Mem->fetch_add(_Value, _Order);
}

template <class _Ty>
_Ty atomic_fetch_add_explicit(
    atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value, const memory_order _Order) noexcept {
    return _Mem->fetch_add(_Value, _Order);
}

template <class _Ty>
_Ty atomic_fetch_sub(volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value) noexcept {
    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
    return _Mem->fetch_sub(_Value);
}

template <class _Ty>
_Ty atomic_fetch_sub(atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value) noexcept {
    return _Mem->fetch_sub(_Value);
}

template <class _Ty>
_Ty atomic_fetch_sub_explicit(volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value,
    const memory_order _Order) noexcept {
    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
    return _Mem->fetch_sub(_Value, _Order);
}

template <class _Ty>
_Ty atomic_fetch_sub_explicit(
    atomic<_Ty>* _Mem, const typename atomic<_Ty>::difference_type _Value, const memory_order _Order) noexcept {
    return _Mem->fetch_sub(_Value, _Order);
}

template <class _Ty>
_Ty atomic_fetch_and(volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value) noexcept {
    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
    return _Mem->fetch_and(_Value);
}

template <class _Ty>
_Ty atomic_fetch_and(atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value) noexcept {
    return _Mem->fetch_and(_Value);
}

template <class _Ty>
_Ty atomic_fetch_and_explicit(
    volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value, const memory_order _Order) noexcept {
    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
    return _Mem->fetch_and(_Value, _Order);
}

template <class _Ty>
_Ty atomic_fetch_and_explicit(
    atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value, const memory_order _Order) noexcept {
    return _Mem->fetch_and(_Value, _Order);
}

template <class _Ty>
_Ty atomic_fetch_or(volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value) noexcept {
    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
    return _Mem->fetch_or(_Value);
}

template <class _Ty>
_Ty atomic_fetch_or(atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value) noexcept {
    return _Mem->fetch_or(_Value);
}

template <class _Ty>
_Ty atomic_fetch_or_explicit(
    volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value, const memory_order _Order) noexcept {
    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
    return _Mem->fetch_or(_Value, _Order);
}

template <class _Ty>
_Ty atomic_fetch_or_explicit(
    atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value, const memory_order _Order) noexcept {
    return _Mem->fetch_or(_Value, _Order);
}

template <class _Ty>
_Ty atomic_fetch_xor(volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value) noexcept {
    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
    return _Mem->fetch_xor(_Value);
}

template <class _Ty>
_Ty atomic_fetch_xor(atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value) noexcept {
    return _Mem->fetch_xor(_Value);
}

template <class _Ty>
_Ty atomic_fetch_xor_explicit(
    volatile atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value, const memory_order _Order) noexcept {
    static_assert(_Deprecate_non_lock_free_volatile<_Ty>, "Never fails");
    return _Mem->fetch_xor(_Value, _Order);
}

template <class _Ty>
_Ty atomic_fetch_xor_explicit(
    atomic<_Ty>* _Mem, const typename atomic<_Ty>::value_type _Value, const memory_order _Order) noexcept {
    return _Mem->fetch_xor(_Value, _Order);
}


template <class _Ty>
void atomic_wait(const volatile atomic<_Ty>* const _Mem, const typename atomic<_Ty>::value_type _Expected) noexcept
 {
    _Mem->wait(_Expected);
}

template <class _Ty>
void atomic_wait(const atomic<_Ty>* const _Mem, const typename atomic<_Ty>::value_type _Expected) noexcept
 {
    _Mem->wait(_Expected);
}

template <class _Ty>
void atomic_wait_explicit(const volatile atomic<_Ty>* const _Mem, const typename atomic<_Ty>::value_type _Expected,
    const memory_order _Order) noexcept  {
    _Mem->wait(_Expected, _Order);
}

template <class _Ty>
void atomic_wait_explicit(const atomic<_Ty>* const _Mem, const typename atomic<_Ty>::value_type _Expected,
    const memory_order _Order) noexcept  {
    _Mem->wait(_Expected, _Order);
}

template <class _Ty>
void atomic_notify_one(volatile atomic<_Ty>* const _Mem) noexcept  {
    _Mem->notify_one();
}

template <class _Ty>
void atomic_notify_one(atomic<_Ty>* const _Mem) noexcept  {
    _Mem->notify_one();
}

template <class _Ty>
void atomic_notify_all(volatile atomic<_Ty>* const _Mem) noexcept  {
    _Mem->notify_all();
}

template <class _Ty>
void atomic_notify_all(atomic<_Ty>* const _Mem) noexcept  {
    _Mem->notify_all();
}
#line 2685 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"

using atomic_bool = atomic<bool>;

using atomic_char   = atomic<char>;
using atomic_schar  = atomic<signed char>;
using atomic_uchar  = atomic<unsigned char>;
using atomic_short  = atomic<short>;
using atomic_ushort = atomic<unsigned short>;
using atomic_int    = atomic<int>;
using atomic_uint   = atomic<unsigned int>;
using atomic_long   = atomic<long>;
using atomic_ulong  = atomic<unsigned long>;
using atomic_llong  = atomic<long long>;
using atomic_ullong = atomic<unsigned long long>;


using atomic_char8_t = atomic<char8_t>;
#line 2703 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
using atomic_char16_t = atomic<char16_t>;
using atomic_char32_t = atomic<char32_t>;
using atomic_wchar_t  = atomic<wchar_t>;

using atomic_int8_t   = atomic<int8_t>;
using atomic_uint8_t  = atomic<uint8_t>;
using atomic_int16_t  = atomic<int16_t>;
using atomic_uint16_t = atomic<uint16_t>;
using atomic_int32_t  = atomic<int32_t>;
using atomic_uint32_t = atomic<uint32_t>;
using atomic_int64_t  = atomic<int64_t>;
using atomic_uint64_t = atomic<uint64_t>;

using atomic_int_least8_t   = atomic<int_least8_t>;
using atomic_uint_least8_t  = atomic<uint_least8_t>;
using atomic_int_least16_t  = atomic<int_least16_t>;
using atomic_uint_least16_t = atomic<uint_least16_t>;
using atomic_int_least32_t  = atomic<int_least32_t>;
using atomic_uint_least32_t = atomic<uint_least32_t>;
using atomic_int_least64_t  = atomic<int_least64_t>;
using atomic_uint_least64_t = atomic<uint_least64_t>;

using atomic_int_fast8_t   = atomic<int_fast8_t>;
using atomic_uint_fast8_t  = atomic<uint_fast8_t>;
using atomic_int_fast16_t  = atomic<int_fast16_t>;
using atomic_uint_fast16_t = atomic<uint_fast16_t>;
using atomic_int_fast32_t  = atomic<int_fast32_t>;
using atomic_uint_fast32_t = atomic<uint_fast32_t>;
using atomic_int_fast64_t  = atomic<int_fast64_t>;
using atomic_uint_fast64_t = atomic<uint_fast64_t>;

using atomic_intptr_t  = atomic<intptr_t>;
using atomic_uintptr_t = atomic<uintptr_t>;
using atomic_size_t    = atomic<size_t>;
using atomic_ptrdiff_t = atomic<ptrdiff_t>;
using atomic_intmax_t  = atomic<intmax_t>;
using atomic_uintmax_t = atomic<uintmax_t>;


using atomic_signed_lock_free   = atomic_intptr_t;
using atomic_unsigned_lock_free = atomic_uintptr_t;
#line 2747 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"


struct atomic_flag { 

    [[nodiscard]] bool test(const memory_order _Order = memory_order_seq_cst) const noexcept {
        return _Storage.load(_Order) != 0;
    }

    [[nodiscard]] bool test(const memory_order _Order = memory_order_seq_cst) const volatile noexcept {
        return _Storage.load(_Order) != 0;
    }
#line 2760 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"

    bool test_and_set(const memory_order _Order = memory_order_seq_cst) noexcept {
        return _Storage.exchange(true, _Order) != 0;
    }

    bool test_and_set(const memory_order _Order = memory_order_seq_cst) volatile noexcept {
        return _Storage.exchange(true, _Order) != 0;
    }

    void clear(const memory_order _Order = memory_order_seq_cst) noexcept {
        _Storage.store(false, _Order);
    }

    void clear(const memory_order _Order = memory_order_seq_cst) volatile noexcept {
        _Storage.store(false, _Order);
    }

    constexpr atomic_flag() noexcept = default;


    void wait(const bool _Expected, const memory_order _Order = memory_order_seq_cst) const noexcept {
        _Storage.wait(static_cast<decltype(_Storage)::value_type>(_Expected), _Order);
    }

    void wait(const bool _Expected, const memory_order _Order = memory_order_seq_cst) const volatile noexcept {
        _Storage.wait(static_cast<decltype(_Storage)::value_type>(_Expected), _Order);
    }

    void notify_one() noexcept {
        _Storage.notify_one();
    }

    void notify_one() volatile noexcept {
        _Storage.notify_one();
    }

    void notify_all() noexcept {
        _Storage.notify_all();
    }

    void notify_all() volatile noexcept {
        _Storage.notify_all();
    }
#line 2804 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"


    atomic<long> _Storage;


#line 2810 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
};


[[nodiscard]] inline bool atomic_flag_test(const volatile atomic_flag* const _Flag) noexcept {
    return _Flag->test();
}

[[nodiscard]] inline bool atomic_flag_test(const atomic_flag* const _Flag) noexcept {
    return _Flag->test();
}

[[nodiscard]] inline bool atomic_flag_test_explicit(
    const volatile atomic_flag* const _Flag, const memory_order _Order) noexcept {
    return _Flag->test(_Order);
}

[[nodiscard]] inline bool atomic_flag_test_explicit(const atomic_flag* const _Flag, const memory_order _Order) noexcept {
    return _Flag->test(_Order);
}
#line 2831 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"

inline bool atomic_flag_test_and_set(atomic_flag* const _Flag) noexcept {
    return _Flag->test_and_set();
}

inline bool atomic_flag_test_and_set(volatile atomic_flag* const _Flag) noexcept {
    return _Flag->test_and_set();
}

inline bool atomic_flag_test_and_set_explicit(atomic_flag* const _Flag, const memory_order _Order) noexcept {
    return _Flag->test_and_set(_Order);
}

inline bool atomic_flag_test_and_set_explicit(volatile atomic_flag* const _Flag, const memory_order _Order) noexcept {
    return _Flag->test_and_set(_Order);
}

inline void atomic_flag_clear(atomic_flag* const _Flag) noexcept {
    _Flag->clear();
}

inline void atomic_flag_clear(volatile atomic_flag* const _Flag) noexcept {
    _Flag->clear();
}

inline void atomic_flag_clear_explicit(atomic_flag* const _Flag, const memory_order _Order) noexcept {
    _Flag->clear(_Order);
}

inline void atomic_flag_clear_explicit(volatile atomic_flag* const _Flag, const memory_order _Order) noexcept {
    _Flag->clear(_Order);
}


inline void atomic_flag_wait(const volatile atomic_flag* const _Flag, const bool _Expected) noexcept {
    return _Flag->wait(_Expected);
}

inline void atomic_flag_wait(const atomic_flag* const _Flag, const bool _Expected) noexcept {
    return _Flag->wait(_Expected);
}

inline void atomic_flag_wait_explicit(
    const volatile atomic_flag* const _Flag, const bool _Expected, const memory_order _Order) noexcept {
    return _Flag->wait(_Expected, _Order);
}

inline void atomic_flag_wait_explicit(
    const atomic_flag* const _Flag, const bool _Expected, const memory_order _Order) noexcept {
    return _Flag->wait(_Expected, _Order);
}

inline void atomic_flag_notify_one(volatile atomic_flag* const _Flag) noexcept {
    return _Flag->notify_one();
}

inline void atomic_flag_notify_one(atomic_flag* const _Flag) noexcept {
    return _Flag->notify_one();
}

inline void atomic_flag_notify_all(volatile atomic_flag* const _Flag) noexcept {
    return _Flag->notify_all();
}

inline void atomic_flag_notify_all(atomic_flag* const _Flag) noexcept {
    return _Flag->notify_all();
}

template <class _Ty>
class _Locked_pointer {
public:
    static_assert(alignof(_Ty) >= (1 << 2), "2 low order bits are needed by _Locked_pointer");
    static constexpr uintptr_t _Lock_mask                = 3;
    static constexpr uintptr_t _Not_locked               = 0;
    static constexpr uintptr_t _Locked_notify_not_needed = 1;
    static constexpr uintptr_t _Locked_notify_needed     = 2;
    static constexpr uintptr_t _Ptr_value_mask           = ~_Lock_mask;

    constexpr _Locked_pointer() noexcept : _Storage{} {}
    explicit _Locked_pointer(_Ty* const _Ptr) noexcept : _Storage{reinterpret_cast<uintptr_t>(_Ptr)} {}

    _Locked_pointer(const _Locked_pointer&) = delete;
    _Locked_pointer& operator=(const _Locked_pointer&) = delete;

    [[nodiscard]] _Ty* _Lock_and_load() noexcept {
        uintptr_t _Rep = _Storage.load(memory_order_relaxed);
        for (;;) {
            switch (_Rep & _Lock_mask) {
            case _Not_locked: 
                if (_Storage.compare_exchange_weak(_Rep, _Rep | _Locked_notify_not_needed)) {
                    return reinterpret_cast<_Ty*>(_Rep);
                }
                _mm_pause();
                break;

            case _Locked_notify_not_needed: 
                if (!_Storage.compare_exchange_weak(_Rep, (_Rep & _Ptr_value_mask) | _Locked_notify_needed)) {
                    
                    _mm_pause();
                    break;
                }
                _Rep = (_Rep & _Ptr_value_mask) | _Locked_notify_needed;
                [[fallthrough]];

            case _Locked_notify_needed: 
                _Storage.wait(_Rep, memory_order_relaxed);
                _Rep = _Storage.load(memory_order_relaxed);
                break;

            default: 
                :: abort();
            }
        }
    }

    void _Store_and_unlock(_Ty* const _Value) noexcept {
        const auto _Rep = _Storage.exchange(reinterpret_cast<uintptr_t>(_Value));
        if ((_Rep & _Lock_mask) == _Locked_notify_needed) {
            
            _Storage.notify_all();
        }
    }

    [[nodiscard]] _Ty* _Unsafe_load_relaxed() const noexcept {
        return reinterpret_cast<_Ty*>(_Storage.load(memory_order_relaxed));
    }

private:
    atomic<uintptr_t> _Storage;
};
#line 2962 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"

}


#pragma warning(pop)
#pragma pack(pop)
#line 2981 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
#line 2982 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\atomic"
#line 22 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cmath"


#pragma once


#line 20 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cmath"


#line 24 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cmath"


#line 28 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cmath"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


[[nodiscard]]   inline float acos(  float _Xx) noexcept  {
    return :: acosf(_Xx);
}

[[nodiscard]]   inline float acosh(  float _Xx) noexcept  {
    return :: acoshf(_Xx);
}

[[nodiscard]]   inline float asin(  float _Xx) noexcept  {
    return :: asinf(_Xx);
}

[[nodiscard]]   inline float asinh(  float _Xx) noexcept  {
    return :: asinhf(_Xx);
}

[[nodiscard]]   inline float atan(  float _Xx) noexcept  {
    return :: atanf(_Xx);
}

[[nodiscard]]   inline float atanh(  float _Xx) noexcept  {
    return :: atanhf(_Xx);
}

[[nodiscard]]   inline float atan2(  float _Yx,   float _Xx) noexcept  {
    return :: atan2f(_Yx, _Xx);
}

[[nodiscard]]   inline float cbrt(  float _Xx) noexcept  {
    return :: cbrtf(_Xx);
}

[[nodiscard]]   inline float ceil(  float _Xx) noexcept  {

    return __ceilf(_Xx);


#line 76 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cmath"
}

[[nodiscard]]   inline float copysign(  float _Number,   float _Sign) noexcept  {

    return __copysignf(_Number, _Sign);


#line 86 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cmath"
}

[[nodiscard]]   inline float cos(  float _Xx) noexcept  {
    return :: cosf(_Xx);
}

[[nodiscard]]   inline float cosh(  float _Xx) noexcept  {
    return :: coshf(_Xx);
}

[[nodiscard]]   inline float erf(  float _Xx) noexcept  {
    return :: erff(_Xx);
}

[[nodiscard]]   inline float erfc(  float _Xx) noexcept  {
    return :: erfcf(_Xx);
}

[[nodiscard]]   inline float exp(  float _Xx) noexcept  {
    return :: expf(_Xx);
}

[[nodiscard]]   inline float exp2(  float _Xx) noexcept  {
    return :: exp2f(_Xx);
}

[[nodiscard]]   inline float expm1(  float _Xx) noexcept  {
    return :: expm1f(_Xx);
}

[[nodiscard]]   inline float fabs(  float _Xx) noexcept  {
    return :: fabsf(_Xx);
}

[[nodiscard]]   inline float fdim(  float _Xx,   float _Yx) noexcept  {
    return :: fdimf(_Xx, _Yx);
}

[[nodiscard]]   inline float floor(  float _Xx) noexcept  {

    return __floorf(_Xx);


#line 132 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cmath"
}

[[nodiscard]]   inline float fma(  float _Xx,   float _Yx,   float _Zx) noexcept  {
    return :: fmaf(_Xx, _Yx, _Zx);
}

[[nodiscard]]   inline float fmax(  float _Xx,   float _Yx) noexcept  {
    return :: fmaxf(_Xx, _Yx);
}

[[nodiscard]]   inline float fmin(  float _Xx,   float _Yx) noexcept  {
    return :: fminf(_Xx, _Yx);
}

[[nodiscard]]   inline float fmod(  float _Xx,   float _Yx) noexcept  {
    return :: fmodf(_Xx, _Yx);
}

inline float frexp(  float _Xx,   int* _Yx) noexcept  {
    return :: frexpf(_Xx, _Yx);
}

[[nodiscard]]   inline float hypot(  float _Xx,   float _Yx) noexcept  {
    return :: hypotf(_Xx, _Yx);
}

[[nodiscard]]   inline int ilogb(  float _Xx) noexcept  {
    return :: ilogbf(_Xx);
}

[[nodiscard]]   inline float ldexp(  float _Xx,   int _Yx) noexcept  {
    return :: ldexpf(_Xx, _Yx);
}

[[nodiscard]]   inline float lgamma(  float _Xx) noexcept  {
    return :: lgammaf(_Xx);
}

[[nodiscard]]   inline long long llrint(  float _Xx) noexcept  {
    return :: llrintf(_Xx);
}

[[nodiscard]]   inline long long llround(  float _Xx) noexcept  {
    return :: llroundf(_Xx);
}

[[nodiscard]]   inline float log(  float _Xx) noexcept  {
    return :: logf(_Xx);
}

[[nodiscard]]   inline float log10(  float _Xx) noexcept  {
    return :: log10f(_Xx);
}

[[nodiscard]]   inline float log1p(  float _Xx) noexcept  {
    return :: log1pf(_Xx);
}

[[nodiscard]]   inline float log2(  float _Xx) noexcept  {
    return :: log2f(_Xx);
}

[[nodiscard]]   inline float logb(  float _Xx) noexcept  {
    return :: logbf(_Xx);
}

[[nodiscard]]   inline long lrint(  float _Xx) noexcept  {
    return :: lrintf(_Xx);
}

[[nodiscard]]   inline long lround(  float _Xx) noexcept  {
    return :: lroundf(_Xx);
}

inline float modf(  float _Xx,   float* _Yx) noexcept  {
    return :: modff(_Xx, _Yx);
}

[[nodiscard]]   inline float nearbyint(  float _Xx) noexcept  {
    return :: nearbyintf(_Xx);
}

[[nodiscard]]   inline float nextafter(  float _Xx,   float _Yx) noexcept  {
    return :: nextafterf(_Xx, _Yx);
}

[[nodiscard]]   inline float nexttoward(  float _Xx,   long double _Yx) noexcept  {
    return :: nexttowardf(_Xx, _Yx);
}

[[nodiscard]]   inline float pow(  float _Xx,   float _Yx) noexcept  {
    return :: powf(_Xx, _Yx);
}

[[nodiscard]]   inline float remainder(  float _Xx,   float _Yx) noexcept  {
    return :: remainderf(_Xx, _Yx);
}

inline float remquo(  float _Xx,   float _Yx,   int* _Zx) noexcept  {
    return :: remquof(_Xx, _Yx, _Zx);
}

[[nodiscard]]   inline float rint(  float _Xx) noexcept  {
    return :: rintf(_Xx);
}

[[nodiscard]]   inline float round(  float _Xx) noexcept  {

    return __roundf(_Xx);


#line 246 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cmath"
}

[[nodiscard]]   inline float scalbln(  float _Xx,   long _Yx) noexcept  {
    return :: scalblnf(_Xx, _Yx);
}

[[nodiscard]]   inline float scalbn(  float _Xx,   int _Yx) noexcept  {
    return :: scalbnf(_Xx, _Yx);
}

[[nodiscard]]   inline float sin(  float _Xx) noexcept  {
    return :: sinf(_Xx);
}

[[nodiscard]]   inline float sinh(  float _Xx) noexcept  {
    return :: sinhf(_Xx);
}

[[nodiscard]]   inline float sqrt(  float _Xx) noexcept  {
    return :: sqrtf(_Xx);
}

[[nodiscard]]   inline float tan(  float _Xx) noexcept  {
    return :: tanf(_Xx);
}

[[nodiscard]]   inline float tanh(  float _Xx) noexcept  {
    return :: tanhf(_Xx);
}

[[nodiscard]]   inline float tgamma(  float _Xx) noexcept  {
    return :: tgammaf(_Xx);
}

[[nodiscard]]   inline float trunc(  float _Xx) noexcept  {

    return __truncf(_Xx);


#line 288 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cmath"
}

[[nodiscard]]   inline long double acos(  long double _Xx) noexcept  {
    return :: acosl(_Xx);
}

[[nodiscard]]   inline long double acosh(  long double _Xx) noexcept  {
    return :: acoshl(_Xx);
}

[[nodiscard]]   inline long double asin(  long double _Xx) noexcept  {
    return :: asinl(_Xx);
}

[[nodiscard]]   inline long double asinh(  long double _Xx) noexcept  {
    return :: asinhl(_Xx);
}

[[nodiscard]]   inline long double atan(  long double _Xx) noexcept  {
    return :: atanl(_Xx);
}

[[nodiscard]]   inline long double atanh(  long double _Xx) noexcept  {
    return :: atanhl(_Xx);
}

[[nodiscard]]   inline long double atan2(  long double _Yx,   long double _Xx) noexcept
 {
    return :: atan2l(_Yx, _Xx);
}

[[nodiscard]]   inline long double cbrt(  long double _Xx) noexcept  {
    return :: cbrtl(_Xx);
}

[[nodiscard]]   inline long double ceil(  long double _Xx) noexcept  {

    return __ceil(static_cast<double>(_Xx));


#line 331 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cmath"
}

[[nodiscard]]   inline long double copysign(  long double _Number,   long double _Sign) noexcept
 {

    return __copysign(static_cast<double>(_Number), static_cast<double>(_Sign));


#line 342 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cmath"
}

[[nodiscard]]   inline long double cos(  long double _Xx) noexcept  {
    return :: cosl(_Xx);
}

[[nodiscard]]   inline long double cosh(  long double _Xx) noexcept  {
    return :: coshl(_Xx);
}

[[nodiscard]]   inline long double erf(  long double _Xx) noexcept  {
    return :: erfl(_Xx);
}

[[nodiscard]]   inline long double erfc(  long double _Xx) noexcept  {
    return :: erfcl(_Xx);
}

[[nodiscard]]   inline long double exp(  long double _Xx) noexcept  {
    return :: expl(_Xx);
}

[[nodiscard]]   inline long double exp2(  long double _Xx) noexcept  {
    return :: exp2l(_Xx);
}

[[nodiscard]]   inline long double expm1(  long double _Xx) noexcept  {
    return :: expm1l(_Xx);
}

[[nodiscard]]   inline long double fabs(  long double _Xx) noexcept  {
    return :: fabsl(_Xx);
}

[[nodiscard]]   inline long double fdim(  long double _Xx,   long double _Yx) noexcept
 {
    return :: fdiml(_Xx, _Yx);
}

[[nodiscard]]   inline long double floor(  long double _Xx) noexcept  {

    return __floor(static_cast<double>(_Xx));


#line 389 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cmath"
}

[[nodiscard]]   inline long double fma(
      long double _Xx,   long double _Yx,   long double _Zx) noexcept  {
    return :: fmal(_Xx, _Yx, _Zx);
}

[[nodiscard]]   inline long double fmax(  long double _Xx,   long double _Yx) noexcept
 {
    return :: fmaxl(_Xx, _Yx);
}

[[nodiscard]]   inline long double fmin(  long double _Xx,   long double _Yx) noexcept
 {
    return :: fminl(_Xx, _Yx);
}

[[nodiscard]]   inline long double fmod(  long double _Xx,   long double _Yx) noexcept
 {
    return :: fmodl(_Xx, _Yx);
}

inline long double frexp(  long double _Xx,   int* _Yx) noexcept  {
    return :: frexpl(_Xx, _Yx);
}

[[nodiscard]]   inline long double hypot(  long double _Xx,   long double _Yx) noexcept
 {
    return :: hypotl(_Xx, _Yx);
}

[[nodiscard]]   inline int ilogb(  long double _Xx) noexcept  {
    return :: ilogbl(_Xx);
}

[[nodiscard]]   inline long double ldexp(  long double _Xx,   int _Yx) noexcept  {
    return :: ldexpl(_Xx, _Yx);
}

[[nodiscard]]   inline long double lgamma(  long double _Xx) noexcept  {
    return :: lgammal(_Xx);
}

[[nodiscard]]   inline long long llrint(  long double _Xx) noexcept  {
    return :: llrintl(_Xx);
}

[[nodiscard]]   inline long long llround(  long double _Xx) noexcept  {
    return :: llroundl(_Xx);
}

[[nodiscard]]   inline long double log(  long double _Xx) noexcept  {
    return :: logl(_Xx);
}

[[nodiscard]]   inline long double log10(  long double _Xx) noexcept  {
    return :: log10l(_Xx);
}

[[nodiscard]]   inline long double log1p(  long double _Xx) noexcept  {
    return :: log1pl(_Xx);
}

[[nodiscard]]   inline long double log2(  long double _Xx) noexcept  {
    return :: log2l(_Xx);
}

[[nodiscard]]   inline long double logb(  long double _Xx) noexcept  {
    return :: logbl(_Xx);
}

[[nodiscard]]   inline long lrint(  long double _Xx) noexcept  {
    return :: lrintl(_Xx);
}

[[nodiscard]]   inline long lround(  long double _Xx) noexcept  {
    return :: lroundl(_Xx);
}

inline long double modf(  long double _Xx,   long double* _Yx) noexcept  {
    return :: modfl(_Xx, _Yx);
}

[[nodiscard]]   inline long double nearbyint(  long double _Xx) noexcept  {
    return :: nearbyintl(_Xx);
}

[[nodiscard]]   inline long double nextafter(  long double _Xx,   long double _Yx) noexcept
 {
    return :: nextafterl(_Xx, _Yx);
}

[[nodiscard]]   inline long double nexttoward(  long double _Xx,   long double _Yx) noexcept
 {
    return :: nexttowardl(_Xx, _Yx);
}

[[nodiscard]]   inline long double pow(  long double _Xx,   long double _Yx) noexcept
 {
    return :: powl(_Xx, _Yx);
}

[[nodiscard]]   inline long double remainder(  long double _Xx,   long double _Yx) noexcept
 {
    return :: remainderl(_Xx, _Yx);
}

inline long double remquo(  long double _Xx,   long double _Yx,   int* _Zx) noexcept  {
    return :: remquol(_Xx, _Yx, _Zx);
}

[[nodiscard]]   inline long double rint(  long double _Xx) noexcept  {
    return :: rintl(_Xx);
}

[[nodiscard]]   inline long double round(  long double _Xx) noexcept  {

    return __round(static_cast<double>(_Xx));


#line 512 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cmath"
}

[[nodiscard]]   inline long double scalbln(  long double _Xx,   long _Yx) noexcept  {
    return :: scalblnl(_Xx, _Yx);
}

[[nodiscard]]   inline long double scalbn(  long double _Xx,   int _Yx) noexcept  {
    return :: scalbnl(_Xx, _Yx);
}

[[nodiscard]]   inline long double sin(  long double _Xx) noexcept  {
    return :: sinl(_Xx);
}

[[nodiscard]]   inline long double sinh(  long double _Xx) noexcept  {
    return :: sinhl(_Xx);
}

[[nodiscard]]   inline long double sqrt(  long double _Xx) noexcept  {
    return :: sqrtl(_Xx);
}

[[nodiscard]]   inline long double tan(  long double _Xx) noexcept  {
    return :: tanl(_Xx);
}

[[nodiscard]]   inline long double tanh(  long double _Xx) noexcept  {
    return :: tanhl(_Xx);
}

[[nodiscard]]   inline long double tgamma(  long double _Xx) noexcept  {
    return :: tgammal(_Xx);
}

[[nodiscard]]   inline long double trunc(  long double _Xx) noexcept  {

    return __trunc(static_cast<double>(_Xx));


#line 554 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cmath"
}


namespace std {
template <class _Ty1, class _Ty2>
using _Common_float_type_t = conditional_t<is_same_v<_Ty1, long double> || is_same_v<_Ty2, long double>, long double,
    conditional_t<is_same_v<_Ty1, float> && is_same_v<_Ty2, float>, float,
        double>>; 
}

template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0>
double frexp(_Ty _Value,   int* const _Exp) noexcept  {
    return :: frexp(static_cast<double>(_Value), _Exp);
}

template <class _Ty1, class _Ty2, class _Ty3,
    ::std:: enable_if_t<::std:: is_arithmetic_v<_Ty1> && ::std:: is_arithmetic_v<_Ty2> && ::std:: is_arithmetic_v<_Ty3>, int> = 0>
[[nodiscard]] ::std:: _Common_float_type_t<_Ty1, ::std:: _Common_float_type_t<_Ty2, _Ty3>> fma(
    _Ty1 _Left, _Ty2 _Middle, _Ty3 _Right) noexcept  {
    using _Common = ::std:: _Common_float_type_t<_Ty1, ::std:: _Common_float_type_t<_Ty2, _Ty3>>;
    if constexpr (::std:: is_same_v<_Common, float>) {
        return :: fmaf(static_cast<_Common>(_Left), static_cast<_Common>(_Middle), static_cast<_Common>(_Right));
    } else if constexpr (::std:: is_same_v<_Common, double>) {
        return :: fma(static_cast<_Common>(_Left), static_cast<_Common>(_Middle), static_cast<_Common>(_Right));
    } else {
        return :: fmal(static_cast<_Common>(_Left), static_cast<_Common>(_Middle), static_cast<_Common>(_Right));
    }
}

template <class _Ty1, class _Ty2, ::std:: enable_if_t<::std:: is_arithmetic_v<_Ty1> && ::std:: is_arithmetic_v<_Ty2>, int> = 0>
::std:: _Common_float_type_t<_Ty1, _Ty2> remquo(_Ty1 _Left, _Ty2 _Right, int* _Pquo) noexcept  {
    using _Common = ::std:: _Common_float_type_t<_Ty1, _Ty2>;
    if constexpr (::std:: is_same_v<_Common, float>) {
        return :: remquof(static_cast<_Common>(_Left), static_cast<_Common>(_Right), _Pquo);
    } else if constexpr (::std:: is_same_v<_Common, double>) {
        return :: remquo(static_cast<_Common>(_Left), static_cast<_Common>(_Right), _Pquo);
    } else {
        return :: remquol(static_cast<_Common>(_Left), static_cast<_Common>(_Right), _Pquo);
    }
}


#line 611 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cmath"


#line 635 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cmath"


template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double acos(_Ty _Left) noexcept { return :: acos(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double asin(_Ty _Left) noexcept { return :: asin(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double atan(_Ty _Left) noexcept { return :: atan(static_cast<double>(_Left)); }
template <class _Ty1, class _Ty2, ::std:: enable_if_t<::std:: is_arithmetic_v<_Ty1> && ::std:: is_arithmetic_v<_Ty2>, int> = 0> [[nodiscard]] ::std:: _Common_float_type_t<_Ty1, _Ty2> atan2(_Ty1 _Left, _Ty2 _Right) noexcept { using _Common = ::std:: _Common_float_type_t<_Ty1, _Ty2>; return :: atan2(static_cast<_Common>(_Left), static_cast<_Common>(_Right)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double cos(_Ty _Left) noexcept { return :: cos(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double sin(_Ty _Left) noexcept { return :: sin(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double tan(_Ty _Left) noexcept { return :: tan(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double acosh(_Ty _Left) noexcept { return :: acosh(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double asinh(_Ty _Left) noexcept { return :: asinh(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double atanh(_Ty _Left) noexcept { return :: atanh(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double cosh(_Ty _Left) noexcept { return :: cosh(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double sinh(_Ty _Left) noexcept { return :: sinh(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double tanh(_Ty _Left) noexcept { return :: tanh(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double exp(_Ty _Left) noexcept { return :: exp(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double exp2(_Ty _Left) noexcept { return :: exp2(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double expm1(_Ty _Left) noexcept { return :: expm1(static_cast<double>(_Left)); }

template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] int ilogb(_Ty _Left) noexcept { return :: ilogb(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double ldexp(_Ty _Left, int _Arg2) noexcept { return :: ldexp(static_cast<double>(_Left), _Arg2); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double log(_Ty _Left) noexcept { return :: log(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double log10(_Ty _Left) noexcept { return :: log10(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double log1p(_Ty _Left) noexcept { return :: log1p(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double log2(_Ty _Left) noexcept { return :: log2(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double logb(_Ty _Left) noexcept { return :: logb(static_cast<double>(_Left)); }

template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double scalbn(_Ty _Left, int _Arg2) noexcept { return :: scalbn(static_cast<double>(_Left), _Arg2); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double scalbln(_Ty _Left, long _Arg2) noexcept { return :: scalbln(static_cast<double>(_Left), _Arg2); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double cbrt(_Ty _Left) noexcept { return :: cbrt(static_cast<double>(_Left)); }

template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double fabs(_Ty _Left) noexcept { return :: fabs(static_cast<double>(_Left)); }
template <class _Ty1, class _Ty2, ::std:: enable_if_t<::std:: is_arithmetic_v<_Ty1> && ::std:: is_arithmetic_v<_Ty2>, int> = 0> [[nodiscard]] ::std:: _Common_float_type_t<_Ty1, _Ty2> hypot(_Ty1 _Left, _Ty2 _Right) noexcept { using _Common = ::std:: _Common_float_type_t<_Ty1, _Ty2>; return :: hypot(static_cast<_Common>(_Left), static_cast<_Common>(_Right)); }

template <class _Ty1, class _Ty2, ::std:: enable_if_t<::std:: is_arithmetic_v<_Ty1> && ::std:: is_arithmetic_v<_Ty2>, int> = 0> [[nodiscard]] ::std:: _Common_float_type_t<_Ty1, _Ty2> pow(_Ty1 _Left, _Ty2 _Right) noexcept { using _Common = ::std:: _Common_float_type_t<_Ty1, _Ty2>; return :: pow(static_cast<_Common>(_Left), static_cast<_Common>(_Right)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double sqrt(_Ty _Left) noexcept { return :: sqrt(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double erf(_Ty _Left) noexcept { return :: erf(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double erfc(_Ty _Left) noexcept { return :: erfc(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double lgamma(_Ty _Left) noexcept { return :: lgamma(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double tgamma(_Ty _Left) noexcept { return :: tgamma(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double ceil(_Ty _Left) noexcept { return __ceil(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double floor(_Ty _Left) noexcept { return __floor(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double nearbyint(_Ty _Left) noexcept { return :: nearbyint(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double rint(_Ty _Left) noexcept { return :: rint(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] long lrint(_Ty _Left) noexcept { return :: lrint(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] long long llrint(_Ty _Left) noexcept { return :: llrint(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double round(_Ty _Left) noexcept { return __round(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] long lround(_Ty _Left) noexcept { return :: lround(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] long long llround(_Ty _Left) noexcept { return :: llround(static_cast<double>(_Left)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double trunc(_Ty _Left) noexcept { return __trunc(static_cast<double>(_Left)); }
template <class _Ty1, class _Ty2, ::std:: enable_if_t<::std:: is_arithmetic_v<_Ty1> && ::std:: is_arithmetic_v<_Ty2>, int> = 0> [[nodiscard]] ::std:: _Common_float_type_t<_Ty1, _Ty2> fmod(_Ty1 _Left, _Ty2 _Right) noexcept { using _Common = ::std:: _Common_float_type_t<_Ty1, _Ty2>; return :: fmod(static_cast<_Common>(_Left), static_cast<_Common>(_Right)); }
template <class _Ty1, class _Ty2, ::std:: enable_if_t<::std:: is_arithmetic_v<_Ty1> && ::std:: is_arithmetic_v<_Ty2>, int> = 0> [[nodiscard]] ::std:: _Common_float_type_t<_Ty1, _Ty2> remainder(_Ty1 _Left, _Ty2 _Right) noexcept { using _Common = ::std:: _Common_float_type_t<_Ty1, _Ty2>; return :: remainder(static_cast<_Common>(_Left), static_cast<_Common>(_Right)); }

template <class _Ty1, class _Ty2, ::std:: enable_if_t<::std:: is_arithmetic_v<_Ty1> && ::std:: is_arithmetic_v<_Ty2>, int> = 0> [[nodiscard]] ::std:: _Common_float_type_t<_Ty1, _Ty2> copysign(_Ty1 _Left, _Ty2 _Right) noexcept { using _Common = ::std:: _Common_float_type_t<_Ty1, _Ty2>; return __copysign(static_cast<_Common>(_Left), static_cast<_Common>(_Right)); }

template <class _Ty1, class _Ty2, ::std:: enable_if_t<::std:: is_arithmetic_v<_Ty1> && ::std:: is_arithmetic_v<_Ty2>, int> = 0> [[nodiscard]] ::std:: _Common_float_type_t<_Ty1, _Ty2> nextafter(_Ty1 _Left, _Ty2 _Right) noexcept { using _Common = ::std:: _Common_float_type_t<_Ty1, _Ty2>; return :: nextafter(static_cast<_Common>(_Left), static_cast<_Common>(_Right)); }
template <class _Ty, ::std:: enable_if_t<::std:: is_integral_v<_Ty>, int> = 0> [[nodiscard]] double nexttoward(_Ty _Left, long double _Arg2) noexcept { return :: nexttoward(static_cast<double>(_Left), _Arg2); }
template <class _Ty1, class _Ty2, ::std:: enable_if_t<::std:: is_arithmetic_v<_Ty1> && ::std:: is_arithmetic_v<_Ty2>, int> = 0> [[nodiscard]] ::std:: _Common_float_type_t<_Ty1, _Ty2> fdim(_Ty1 _Left, _Ty2 _Right) noexcept { using _Common = ::std:: _Common_float_type_t<_Ty1, _Ty2>; return :: fdim(static_cast<_Common>(_Left), static_cast<_Common>(_Right)); }
template <class _Ty1, class _Ty2, ::std:: enable_if_t<::std:: is_arithmetic_v<_Ty1> && ::std:: is_arithmetic_v<_Ty2>, int> = 0> [[nodiscard]] ::std:: _Common_float_type_t<_Ty1, _Ty2> fmax(_Ty1 _Left, _Ty2 _Right) noexcept { using _Common = ::std:: _Common_float_type_t<_Ty1, _Ty2>; return :: fmax(static_cast<_Common>(_Left), static_cast<_Common>(_Right)); }
template <class _Ty1, class _Ty2, ::std:: enable_if_t<::std:: is_arithmetic_v<_Ty1> && ::std:: is_arithmetic_v<_Ty2>, int> = 0> [[nodiscard]] ::std:: _Common_float_type_t<_Ty1, _Ty2> fmin(_Ty1 _Left, _Ty2 _Right) noexcept { using _Common = ::std:: _Common_float_type_t<_Ty1, _Ty2>; return :: fmin(static_cast<_Common>(_Left), static_cast<_Common>(_Right)); }


namespace std {
using :: abs;
using :: acos;
using :: asin;
using :: atan;
using :: atan2;
using :: ceil;
using :: cos;
using :: cosh;
using :: exp;
using :: fabs;
using :: floor;
using :: fmod;
using :: frexp;
using :: ldexp;
using :: log;
using :: log10;
using :: modf;
using :: pow;
using :: sin;
using :: sinh;
using :: sqrt;
using :: tan;
using :: tanh;

using :: acosf;
using :: asinf;
using :: atanf;
using :: atan2f;
using :: ceilf;
using :: cosf;
using :: coshf;
using :: expf;
using :: fabsf;
using :: floorf;
using :: fmodf;
using :: frexpf;
using :: ldexpf;
using :: logf;
using :: log10f;
using :: modff;
using :: powf;
using :: sinf;
using :: sinhf;
using :: sqrtf;
using :: tanf;
using :: tanhf;

using :: acosl;
using :: asinl;
using :: atanl;
using :: atan2l;
using :: ceill;
using :: cosl;
using :: coshl;
using :: expl;
using :: fabsl;
using :: floorl;
using :: fmodl;
using :: frexpl;
using :: ldexpl;
using :: logl;
using :: log10l;
using :: modfl;
using :: powl;
using :: sinl;
using :: sinhl;
using :: sqrtl;
using :: tanl;
using :: tanhl;

using :: float_t;
using :: double_t;

using :: acosh;
using :: asinh;
using :: atanh;
using :: cbrt;
using :: erf;
using :: erfc;
using :: expm1;
using :: exp2;
using :: hypot;
using :: ilogb;
using :: lgamma;
using :: log1p;
using :: log2;
using :: logb;
using :: llrint;
using :: lrint;
using :: nearbyint;
using :: rint;
using :: llround;
using :: lround;
using :: fdim;
using :: fma;
using :: fmax;
using :: fmin;
using :: round;
using :: trunc;
using :: remainder;
using :: remquo;
using :: copysign;
using :: nan;
using :: nextafter;
using :: scalbn;
using :: scalbln;
using :: nexttoward;
using :: tgamma;

using :: acoshf;
using :: asinhf;
using :: atanhf;
using :: cbrtf;
using :: erff;
using :: erfcf;
using :: expm1f;
using :: exp2f;
using :: hypotf;
using :: ilogbf;
using :: lgammaf;
using :: log1pf;
using :: log2f;
using :: logbf;
using :: llrintf;
using :: lrintf;
using :: nearbyintf;
using :: rintf;
using :: llroundf;
using :: lroundf;
using :: fdimf;
using :: fmaf;
using :: fmaxf;
using :: fminf;
using :: roundf;
using :: truncf;
using :: remainderf;
using :: remquof;
using :: copysignf;
using :: nanf;
using :: nextafterf;
using :: scalbnf;
using :: scalblnf;
using :: nexttowardf;
using :: tgammaf;

using :: acoshl;
using :: asinhl;
using :: atanhl;
using :: cbrtl;
using :: erfl;
using :: erfcl;
using :: expm1l;
using :: exp2l;
using :: hypotl;
using :: ilogbl;
using :: lgammal;
using :: log1pl;
using :: log2l;
using :: logbl;
using :: llrintl;
using :: lrintl;
using :: nearbyintl;
using :: rintl;
using :: llroundl;
using :: lroundl;
using :: fdiml;
using :: fmal;
using :: fmaxl;
using :: fminl;
using :: roundl;
using :: truncl;
using :: remainderl;
using :: remquol;
using :: copysignl;
using :: nanl;
using :: nextafterl;
using :: scalbnl;
using :: scalblnl;
using :: nexttowardl;
using :: tgammal;

using :: fpclassify;
using :: signbit;
using :: isfinite;
using :: isinf;
using :: isnan;
using :: isnormal;
using :: isgreater;
using :: isgreaterequal;
using :: isless;
using :: islessequal;
using :: islessgreater;
using :: isunordered;
}


extern "C" {
[[nodiscard]]  double __stdcall __std_smf_assoc_laguerre(unsigned int, unsigned int, double) noexcept;
[[nodiscard]]  float __stdcall __std_smf_assoc_laguerref(unsigned int, unsigned int, float) noexcept;
[[nodiscard]]  double __stdcall __std_smf_assoc_legendre(unsigned int, unsigned int, double) noexcept;
[[nodiscard]]  float __stdcall __std_smf_assoc_legendref(unsigned int, unsigned int, float) noexcept;
[[nodiscard]]  double __stdcall __std_smf_beta(double, double) noexcept;
[[nodiscard]]  float __stdcall __std_smf_betaf(float, float) noexcept;
[[nodiscard]]  double __stdcall __std_smf_comp_ellint_1(double) noexcept;
[[nodiscard]]  float __stdcall __std_smf_comp_ellint_1f(float) noexcept;
[[nodiscard]]  double __stdcall __std_smf_comp_ellint_2(double) noexcept;
[[nodiscard]]  float __stdcall __std_smf_comp_ellint_2f(float) noexcept;
[[nodiscard]]  double __stdcall __std_smf_comp_ellint_3(double, double) noexcept;
[[nodiscard]]  float __stdcall __std_smf_comp_ellint_3f(float, float) noexcept;
[[nodiscard]]  double __stdcall __std_smf_cyl_bessel_i(double, double) noexcept;
[[nodiscard]]  float __stdcall __std_smf_cyl_bessel_if(float, float) noexcept;
[[nodiscard]]  double __stdcall __std_smf_cyl_bessel_j(double, double) noexcept;
[[nodiscard]]  float __stdcall __std_smf_cyl_bessel_jf(float, float) noexcept;
[[nodiscard]]  double __stdcall __std_smf_cyl_bessel_k(double, double) noexcept;
[[nodiscard]]  float __stdcall __std_smf_cyl_bessel_kf(float, float) noexcept;
[[nodiscard]]  double __stdcall __std_smf_cyl_neumann(double, double) noexcept;
[[nodiscard]]  float __stdcall __std_smf_cyl_neumannf(float, float) noexcept;
[[nodiscard]]  double __stdcall __std_smf_ellint_1(double, double) noexcept;
[[nodiscard]]  float __stdcall __std_smf_ellint_1f(float, float) noexcept;
[[nodiscard]]  double __stdcall __std_smf_ellint_2(double, double) noexcept;
[[nodiscard]]  float __stdcall __std_smf_ellint_2f(float, float) noexcept;
[[nodiscard]]  double __stdcall __std_smf_ellint_3(double, double, double) noexcept;
[[nodiscard]]  float __stdcall __std_smf_ellint_3f(float, float, float) noexcept;
[[nodiscard]]  double __stdcall __std_smf_expint(double) noexcept;
[[nodiscard]]  float __stdcall __std_smf_expintf(float) noexcept;
[[nodiscard]]  double __stdcall __std_smf_hermite(unsigned int, double) noexcept;
[[nodiscard]]  float __stdcall __std_smf_hermitef(unsigned int, float) noexcept;
[[nodiscard]]  double __stdcall __std_smf_laguerre(unsigned int, double) noexcept;
[[nodiscard]]  float __stdcall __std_smf_laguerref(unsigned int, float) noexcept;
[[nodiscard]]  double __stdcall __std_smf_legendre(unsigned int, double) noexcept;
[[nodiscard]]  float __stdcall __std_smf_legendref(unsigned int, float) noexcept;
[[nodiscard]]  double __stdcall __std_smf_riemann_zeta(double) noexcept;
[[nodiscard]]  float __stdcall __std_smf_riemann_zetaf(float) noexcept;
[[nodiscard]]  double __stdcall __std_smf_sph_bessel(unsigned int, double) noexcept;
[[nodiscard]]  float __stdcall __std_smf_sph_besself(unsigned int, float) noexcept;
[[nodiscard]]  double __stdcall __std_smf_sph_legendre(unsigned int, unsigned int, double) noexcept;
[[nodiscard]]  float __stdcall __std_smf_sph_legendref(unsigned int, unsigned int, float) noexcept;
[[nodiscard]]  double __stdcall __std_smf_sph_neumann(unsigned int, double) noexcept;
[[nodiscard]]  float __stdcall __std_smf_sph_neumannf(unsigned int, float) noexcept;
[[nodiscard]]  double __stdcall __std_smf_hypot3(double, double, double) noexcept;
[[nodiscard]]  float __stdcall __std_smf_hypot3f(float, float, float) noexcept;
}

namespace std {
[[nodiscard]] inline double assoc_laguerre(const unsigned int _Degree, const unsigned int _Order, const double _Value) {
    return __std_smf_assoc_laguerre(_Degree, _Order, _Value);
}

[[nodiscard]] inline float assoc_laguerref(const unsigned int _Degree, const unsigned int _Order, const float _Value) {
    return __std_smf_assoc_laguerref(_Degree, _Order, _Value);
}

[[nodiscard]] inline long double assoc_laguerrel(
    const unsigned int _Degree, const unsigned int _Order, const long double _Value) {
    return __std_smf_assoc_laguerre(_Degree, _Order, static_cast<double>(_Value));
}

[[nodiscard]] inline double assoc_legendre(const unsigned int _Degree, const unsigned int _Order, const double _Value) {
    return __std_smf_assoc_legendre(_Degree, _Order, _Value);
}

[[nodiscard]] inline float assoc_legendref(const unsigned int _Degree, const unsigned int _Order, const float _Value) {
    return __std_smf_assoc_legendref(_Degree, _Order, _Value);
}

[[nodiscard]] inline long double assoc_legendrel(
    const unsigned int _Degree, const unsigned int _Order, const long double _Value) {
    return __std_smf_assoc_legendre(_Degree, _Order, static_cast<double>(_Value));
}

[[nodiscard]] inline double beta(const double _Arg1, const double _Arg2) {
    return __std_smf_beta(_Arg1, _Arg2);
}

[[nodiscard]] inline float betaf(const float _Arg1, const float _Arg2) {
    return __std_smf_betaf(_Arg1, _Arg2);
}

[[nodiscard]] inline long double betal(const long double _Arg1, const long double _Arg2) {
    return __std_smf_beta(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
}

[[nodiscard]] inline double comp_ellint_1(const double _Arg) {
    return __std_smf_comp_ellint_1(_Arg);
}

[[nodiscard]] inline float comp_ellint_1f(const float _Arg) {
    return __std_smf_comp_ellint_1f(_Arg);
}

[[nodiscard]] inline long double comp_ellint_1l(const long double _Arg) {
    return __std_smf_comp_ellint_1(static_cast<double>(_Arg));
}

[[nodiscard]] inline double comp_ellint_2(const double _Arg) {
    return __std_smf_comp_ellint_2(_Arg);
}

[[nodiscard]] inline float comp_ellint_2f(const float _Arg) {
    return __std_smf_comp_ellint_2f(_Arg);
}

[[nodiscard]] inline long double comp_ellint_2l(const long double _Arg) {
    return __std_smf_comp_ellint_2(static_cast<double>(_Arg));
}

[[nodiscard]] inline double comp_ellint_3(const double _Arg1, const double _Arg2) {
    return __std_smf_comp_ellint_3(_Arg1, _Arg2);
}

[[nodiscard]] inline float comp_ellint_3f(const float _Arg1, const float _Arg2) {
    return __std_smf_comp_ellint_3f(_Arg1, _Arg2);
}

[[nodiscard]] inline long double comp_ellint_3l(const long double _Arg1, const long double _Arg2) {
    return __std_smf_comp_ellint_3(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
}

[[nodiscard]] inline double cyl_bessel_i(const double _Arg1, const double _Arg2) {
    return __std_smf_cyl_bessel_i(_Arg1, _Arg2);
}

[[nodiscard]] inline float cyl_bessel_if(const float _Arg1, const float _Arg2) {
    return __std_smf_cyl_bessel_if(_Arg1, _Arg2);
}

[[nodiscard]] inline long double cyl_bessel_il(const long double _Arg1, const long double _Arg2) {
    return __std_smf_cyl_bessel_i(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
}

[[nodiscard]] inline double cyl_bessel_j(const double _Arg1, const double _Arg2) {
    return __std_smf_cyl_bessel_j(_Arg1, _Arg2);
}

[[nodiscard]] inline float cyl_bessel_jf(const float _Arg1, const float _Arg2) {
    return __std_smf_cyl_bessel_jf(_Arg1, _Arg2);
}

[[nodiscard]] inline long double cyl_bessel_jl(const long double _Arg1, const long double _Arg2) {
    return __std_smf_cyl_bessel_j(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
}

[[nodiscard]] inline double cyl_bessel_k(const double _Arg1, const double _Arg2) {
    return __std_smf_cyl_bessel_k(_Arg1, _Arg2);
}

[[nodiscard]] inline float cyl_bessel_kf(const float _Arg1, const float _Arg2) {
    return __std_smf_cyl_bessel_kf(_Arg1, _Arg2);
}

[[nodiscard]] inline long double cyl_bessel_kl(const long double _Arg1, const long double _Arg2) {
    return __std_smf_cyl_bessel_k(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
}

[[nodiscard]] inline double cyl_neumann(const double _Arg1, const double _Arg2) {
    return __std_smf_cyl_neumann(_Arg1, _Arg2);
}

[[nodiscard]] inline float cyl_neumannf(const float _Arg1, const float _Arg2) {
    return __std_smf_cyl_neumannf(_Arg1, _Arg2);
}

[[nodiscard]] inline long double cyl_neumannl(const long double _Arg1, const long double _Arg2) {
    return __std_smf_cyl_neumann(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
}

[[nodiscard]] inline double ellint_1(const double _Arg1, const double _Arg2) {
    return __std_smf_ellint_1(_Arg1, _Arg2);
}

[[nodiscard]] inline float ellint_1f(const float _Arg1, const float _Arg2) {
    return __std_smf_ellint_1f(_Arg1, _Arg2);
}

[[nodiscard]] inline long double ellint_1l(const long double _Arg1, const long double _Arg2) {
    return __std_smf_ellint_1(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
}

[[nodiscard]] inline double ellint_2(const double _Arg1, const double _Arg2) {
    return __std_smf_ellint_2(_Arg1, _Arg2);
}

[[nodiscard]] inline float ellint_2f(const float _Arg1, const float _Arg2) {
    return __std_smf_ellint_2f(_Arg1, _Arg2);
}

[[nodiscard]] inline long double ellint_2l(const long double _Arg1, const long double _Arg2) {
    return __std_smf_ellint_2(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
}

[[nodiscard]] inline double ellint_3(const double _Arg1, const double _Arg2, const double _Arg3) {
    return __std_smf_ellint_3(_Arg1, _Arg2, _Arg3);
}

[[nodiscard]] inline float ellint_3f(const float _Arg1, const float _Arg2, const float _Arg3) {
    return __std_smf_ellint_3f(_Arg1, _Arg2, _Arg3);
}

[[nodiscard]] inline long double ellint_3l(const long double _Arg1, const long double _Arg2, const long double _Arg3) {
    return __std_smf_ellint_3(static_cast<double>(_Arg1), static_cast<double>(_Arg2), static_cast<double>(_Arg3));
}

[[nodiscard]] inline double expint(const double _Arg) {
    return __std_smf_expint(_Arg);
}

[[nodiscard]] inline float expintf(const float _Arg) {
    return __std_smf_expintf(_Arg);
}

[[nodiscard]] inline long double expintl(const long double _Arg) {
    return __std_smf_expint(static_cast<double>(_Arg));
}

[[nodiscard]] inline double hermite(const unsigned int _Arg1, const double _Arg2) {
    return __std_smf_hermite(_Arg1, _Arg2);
}

[[nodiscard]] inline float hermitef(const unsigned int _Arg1, const float _Arg2) {
    return __std_smf_hermitef(_Arg1, _Arg2);
}

[[nodiscard]] inline long double hermitel(const unsigned int _Arg1, const long double _Arg2) {
    return __std_smf_hermite(_Arg1, static_cast<double>(_Arg2));
}

[[nodiscard]] inline double laguerre(const unsigned int _Arg1, const double _Arg2) {
    return __std_smf_laguerre(_Arg1, _Arg2);
}

[[nodiscard]] inline float laguerref(const unsigned int _Arg1, const float _Arg2) {
    return __std_smf_laguerref(_Arg1, _Arg2);
}

[[nodiscard]] inline long double laguerrel(const unsigned int _Arg1, const long double _Arg2) {
    return __std_smf_laguerre(_Arg1, static_cast<double>(_Arg2));
}

[[nodiscard]] inline double legendre(const unsigned int _Degree, const double _Value) {
    return __std_smf_legendre(_Degree, _Value);
}

[[nodiscard]] inline float legendref(const unsigned int _Degree, const float _Value) {
    return __std_smf_legendref(_Degree, _Value);
}

[[nodiscard]] inline long double legendrel(const unsigned int _Degree, const long double _Value) {
    return __std_smf_legendre(_Degree, static_cast<double>(_Value));
}

[[nodiscard]] inline double riemann_zeta(const double _Arg) {
    return __std_smf_riemann_zeta(_Arg);
}

[[nodiscard]] inline float riemann_zetaf(const float _Arg) {
    return __std_smf_riemann_zetaf(_Arg);
}

[[nodiscard]] inline long double riemann_zetal(const long double _Arg) {
    return __std_smf_riemann_zeta(static_cast<double>(_Arg));
}

[[nodiscard]] inline double sph_bessel(const unsigned int _Arg1, const double _Arg2) {
    return __std_smf_sph_bessel(_Arg1, _Arg2);
}

[[nodiscard]] inline float sph_besself(const unsigned int _Arg1, const float _Arg2) {
    return __std_smf_sph_besself(_Arg1, _Arg2);
}

[[nodiscard]] inline long double sph_bessell(const unsigned int _Arg1, const long double _Arg2) {
    return __std_smf_sph_bessel(_Arg1, static_cast<double>(_Arg2));
}

[[nodiscard]] inline double sph_legendre(const unsigned int _Arg1, const unsigned int _Arg2, const double _Theta) {
    return __std_smf_sph_legendre(_Arg1, _Arg2, _Theta);
}

[[nodiscard]] inline float sph_legendref(const unsigned int _Arg1, const unsigned int _Arg2, const float _Theta) {
    return __std_smf_sph_legendref(_Arg1, _Arg2, _Theta);
}

[[nodiscard]] inline long double sph_legendrel(
    const unsigned int _Arg1, const unsigned int _Arg2, const long double _Theta) {
    return __std_smf_sph_legendre(_Arg1, _Arg2, static_cast<double>(_Theta));
}

[[nodiscard]] inline double sph_neumann(const unsigned int _Arg1, const double _Arg2) {
    return __std_smf_sph_neumann(_Arg1, _Arg2);
}

[[nodiscard]] inline float sph_neumannf(const unsigned int _Arg1, const float _Arg2) {
    return __std_smf_sph_neumannf(_Arg1, _Arg2);
}

[[nodiscard]] inline long double sph_neumannl(const unsigned int _Arg1, const long double _Arg2) {
    return __std_smf_sph_neumann(_Arg1, static_cast<double>(_Arg2));
}

[[nodiscard]] inline double hypot(const double _Dx, const double _Dy, const double _Dz) {
    return __std_smf_hypot3(_Dx, _Dy, _Dz);
}

[[nodiscard]] inline float hypot(const float _Dx, const float _Dy, const float _Dz) {
    return __std_smf_hypot3f(_Dx, _Dy, _Dz);
}

[[nodiscard]] inline long double hypot(const long double _Dx, const long double _Dy, const long double _Dz) {
    return __std_smf_hypot3(static_cast<double>(_Dx), static_cast<double>(_Dy), static_cast<double>(_Dz));
}

template <class _Ty1, class _Ty2, class _Ty3,
    enable_if_t<is_arithmetic_v<_Ty1> && is_arithmetic_v<_Ty2> && is_arithmetic_v<_Ty3>, int> = 0>
[[nodiscard]] auto hypot(const _Ty1 _Dx, const _Ty2 _Dy, const _Ty3 _Dz) {
    
    
    using _Common      = _Common_float_type_t<_Ty1, _Common_float_type_t<_Ty2, _Ty3>>; 
    const auto _Result = __std_smf_hypot3(static_cast<double>(_Dx), static_cast<double>(_Dy), static_cast<double>(_Dz));
    return static_cast<_Common>(_Result);
}


template <class _Ty>
[[nodiscard]] constexpr _Ty _Common_lerp(const _Ty _ArgA, const _Ty _ArgB, const _Ty _ArgT) noexcept {
    

    const bool _T_is_finite = _Is_finite(_ArgT);
    if (_T_is_finite && _Is_finite(_ArgA) && _Is_finite(_ArgB)) {
        
        if ((_ArgA <= 0 && _ArgB >= 0) || (_ArgA >= 0 && _ArgB <= 0)) {
            
            return _ArgT * _ArgB + (1 - _ArgT) * _ArgA;
        }

        if (_ArgT == 1) {
            
            return _ArgB;
        }

        
        const auto _Candidate = _ArgA + _ArgT * (_ArgB - _ArgA);
        
        if ((_ArgT > 1) == (_ArgB > _ArgA)) {
            if (_ArgB > _Candidate) {
                return _ArgB;
            }
        } else {
            if (_Candidate > _ArgB) {
                return _ArgB;
            }
        }

        return _Candidate;
    }

    if (::std:: is_constant_evaluated()) {
        if (_Is_nan(_ArgA)) {
            return _ArgA;
        }

        if (_Is_nan(_ArgB)) {
            return _ArgB;
        }

        if (_Is_nan(_ArgT)) {
            return _ArgT;
        }
    } else {
        
        if (_Is_nan(_ArgA) || _Is_nan(_ArgB)) {
            return (_ArgA + _ArgB) + _ArgT;
        }

        if (_Is_nan(_ArgT)) {
            return _ArgT + _ArgT;
        }
    }

    if (_T_is_finite) {
        
        if (_ArgT < 0) {
            
            return _ArgA - _ArgB;
        } else if (_ArgT <= 1) {
            
            
            return _ArgT * _ArgB + (1 - _ArgT) * _ArgA;
        } else {
            
            return _ArgB - _ArgA;
        }
    } else {
        
        return _ArgT * (_ArgB - _ArgA);
    }
}


[[nodiscard]] constexpr inline float lerp(const float _ArgA, const float _ArgB, const float _ArgT) noexcept {
    return _Common_lerp(_ArgA, _ArgB, _ArgT);
}

[[nodiscard]] constexpr inline double lerp(const double _ArgA, const double _ArgB, const double _ArgT) noexcept {
    return _Common_lerp(_ArgA, _ArgB, _ArgT);
}

[[nodiscard]] constexpr inline long double lerp(
    const long double _ArgA, const long double _ArgB, const long double _ArgT) noexcept {
    return _Common_lerp(_ArgA, _ArgB, _ArgT);
}
#line 1327 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cmath"
}
#line 1329 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cmath"


#pragma warning(pop)
#pragma pack(pop)

#line 1336 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cmath"
#line 1337 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cmath"
#line 23 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"


#pragma once


#line 16 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
template <class _Mylist, class _Base = _Iterator_base0>
class _Flist_unchecked_const_iterator : public _Base {
public:
    using iterator_category = forward_iterator_tag;

    using _Nodeptr        = typename _Mylist::_Nodeptr;
    using value_type      = typename _Mylist::value_type;
    using difference_type = typename _Mylist::difference_type;
    using pointer         = typename _Mylist::const_pointer;
    using reference       = const value_type&;

    _Flist_unchecked_const_iterator() noexcept : _Ptr() {}

    _Flist_unchecked_const_iterator(_Nodeptr _Pnode, const _Mylist* _Plist) noexcept : _Ptr(_Pnode) {
        this->_Adopt(_Plist);
    }

    [[nodiscard]] reference operator*() const noexcept {
        return _Ptr->_Myval;
    }

    [[nodiscard]] pointer operator->() const noexcept {
        return pointer_traits<pointer>::pointer_to(**this);
    }

    _Flist_unchecked_const_iterator& operator++() noexcept {
        _Ptr = _Ptr->_Next;
        return *this;
    }

    _Flist_unchecked_const_iterator operator++(int) noexcept {
        _Flist_unchecked_const_iterator _Tmp = *this;
        _Ptr                                 = _Ptr->_Next;
        return _Tmp;
    }

    [[nodiscard]] bool operator==(const _Flist_unchecked_const_iterator& _Right) const noexcept {
        return _Ptr == _Right._Ptr;
    }


#line 70 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"

    [[nodiscard]] bool operator==(_Default_sentinel) const noexcept {
        return _Ptr == nullptr;
    }


#line 80 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"

    _Nodeptr _Ptr; 
};

template <class _Mylist>
class _Flist_unchecked_iterator : public _Flist_unchecked_const_iterator<_Mylist> {
public:
    using _Mybase           = _Flist_unchecked_const_iterator<_Mylist>;
    using iterator_category = forward_iterator_tag;

    using _Nodeptr        = typename _Mylist::_Nodeptr;
    using value_type      = typename _Mylist::value_type;
    using difference_type = typename _Mylist::difference_type;
    using pointer         = typename _Mylist::pointer;
    using reference       = value_type&;

    using _Mybase::_Mybase;

    [[nodiscard]] reference operator*() const noexcept {
        return const_cast<reference>(_Mybase::operator*());
    }

    [[nodiscard]] pointer operator->() const noexcept {
        return pointer_traits<pointer>::pointer_to(**this);
    }

    _Flist_unchecked_iterator& operator++() noexcept {
        _Mybase::operator++();
        return *this;
    }

    _Flist_unchecked_iterator operator++(int) noexcept {
        _Flist_unchecked_iterator _Tmp = *this;
        _Mybase::operator++();
        return _Tmp;
    }
};

template <class _Mylist>
class _Flist_const_iterator : public _Flist_unchecked_const_iterator<_Mylist, _Iterator_base> {
public:
    using _Mybase           = _Flist_unchecked_const_iterator<_Mylist, _Iterator_base>;
    using iterator_category = forward_iterator_tag;

    using _Nodeptr        = typename _Mylist::_Nodeptr;
    using value_type      = typename _Mylist::value_type;
    using difference_type = typename _Mylist::difference_type;
    using pointer         = typename _Mylist::const_pointer;
    using reference       = const value_type&;

    using _Mybase::_Mybase;

    [[nodiscard]] reference operator*() const noexcept {


#line 138 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"

        return this->_Ptr->_Myval;
    }

    _Flist_const_iterator& operator++() noexcept {


#line 146 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"

        this->_Ptr = this->_Ptr->_Next;
        return *this;
    }

    _Flist_const_iterator operator++(int) noexcept {
        _Flist_const_iterator _Tmp = *this;
        this->_Ptr                 = this->_Ptr->_Next;
        return _Tmp;
    }

    [[nodiscard]] bool operator==(const _Flist_const_iterator& _Right) const noexcept {


#line 161 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"

        return this->_Ptr == _Right._Ptr;
    }


#line 170 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"


#line 177 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"

    using _Prevent_inheriting_unwrap = _Flist_const_iterator;

    [[nodiscard]] _Flist_unchecked_const_iterator<_Mylist> _Unwrapped() const noexcept {
        return _Flist_unchecked_const_iterator<_Mylist>(this->_Ptr, static_cast<const _Mylist*>(this->_Getcont()));
    }

    void _Seek_to(const _Flist_unchecked_const_iterator<_Mylist> _It) noexcept {
        this->_Ptr = _It._Ptr;
    }
};

template <class _Mylist>
class _Flist_iterator : public _Flist_const_iterator<_Mylist> {
public:
    using _Mybase           = _Flist_const_iterator<_Mylist>;
    using iterator_category = forward_iterator_tag;

    using _Nodeptr        = typename _Mylist::_Nodeptr;
    using value_type      = typename _Mylist::value_type;
    using difference_type = typename _Mylist::difference_type;
    using pointer         = typename _Mylist::pointer;
    using reference       = value_type&;

    using _Mybase::_Mybase;

    [[nodiscard]] reference operator*() const noexcept {
        return const_cast<reference>(_Mybase::operator*());
    }

    [[nodiscard]] pointer operator->() const noexcept {
        return pointer_traits<pointer>::pointer_to(**this);
    }

    _Flist_iterator& operator++() noexcept {
        _Mybase::operator++();
        return *this;
    }

    _Flist_iterator operator++(int) noexcept {
        _Flist_iterator _Tmp = *this;
        _Mybase::operator++();
        return _Tmp;
    }

    using _Prevent_inheriting_unwrap = _Flist_iterator;

    [[nodiscard]] _Flist_unchecked_iterator<_Mylist> _Unwrapped() const noexcept {
        return _Flist_unchecked_iterator<_Mylist>(this->_Ptr, static_cast<const _Mylist*>(this->_Getcont()));
    }
};

template <class _Value_type, class _Size_type, class _Difference_type, class _Pointer, class _Const_pointer,
    class _Reference, class _Const_reference, class _Nodeptr_type>
struct _Flist_iter_types {
    using value_type      = _Value_type;
    using size_type       = _Size_type;
    using difference_type = _Difference_type;
    using pointer         = _Pointer;
    using const_pointer   = _Const_pointer;
    using _Nodeptr        = _Nodeptr_type;
};

template <class _Value_type, class _Voidptr>
struct _Flist_node { 
    using _Nodeptr = _Rebind_pointer_t<_Voidptr, _Flist_node>;

    _Nodeptr _Next; 
    _Value_type _Myval; 

    _Flist_node(const _Flist_node&) = delete;
    _Flist_node& operator=(const _Flist_node&) = delete;

    template <class _Alnode>
    static void _Freenode(_Alnode& _Al, _Nodeptr _Pnode) noexcept {
        _Destroy_in_place(_Pnode->_Next);
        allocator_traits<_Alnode>::destroy(_Al, ::std:: addressof(_Pnode->_Myval));
        _Al.deallocate(_Pnode, 1);
    }
};

template <class _Ty>
struct _Flist_simple_types : _Simple_types<_Ty> {
    using _Node    = _Flist_node<_Ty, void*>;
    using _Nodeptr = _Node*;
};

template <class _Val_types>
class _Flist_val : public _Container_base {
public:
    using _Nodeptr = typename _Val_types::_Nodeptr;
    using _Node    = typename pointer_traits<_Nodeptr>::element_type;

    using value_type      = typename _Val_types::value_type;
    using size_type       = typename _Val_types::size_type;
    using difference_type = typename _Val_types::difference_type;
    using pointer         = typename _Val_types::pointer;
    using const_pointer   = typename _Val_types::const_pointer;
    using reference       = value_type&;
    using const_reference = const value_type&;

    _Flist_val() noexcept : _Myhead() {} 

    _Nodeptr _Before_head() const noexcept { 
        return pointer_traits<_Nodeptr>::pointer_to(reinterpret_cast<_Node&>(const_cast<_Nodeptr&>(_Myhead)));
    }


#line 300 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"

    template <class _Pr2>
    static _Nodeptr _Inplace_merge(_Nodeptr _BFirst1, const _Nodeptr _BMid, const _Nodeptr _BLast, _Pr2 _Pred) {
        
        
        auto _First2 = _BMid->_Next;
        for (;;) { 
            _Nodeptr _First1;
            for (;;) { 
                if (_BFirst1 == _BMid) {
                    return _BLast;
                }

                _First1 = _BFirst1->_Next;
                if (static_cast<bool>(_Pred(_First2->_Myval, _First1->_Myval))) {
                    
                    break;
                }

                
                _BFirst1 = _First1;
            }

            
            auto _BRun_end = _First2;
            _Nodeptr _Run_end;
            for (;;) {
                _Run_end = _BRun_end->_Next;
                if (_BRun_end == _BLast) {
                    break;
                }

                if (!static_cast<bool>(_Pred(_Run_end->_Myval, _First1->_Myval))) {
                    
                    
                    break;
                }

                _BRun_end = _Run_end;
            }

            _BMid->_Next     = _Run_end; 
            _BFirst1->_Next  = _First2; 
            _BRun_end->_Next = _First1;
            if (_BRun_end == _BLast) {
                return _BMid;
            }

            _BFirst1 = _First1;
            _First2  = _Run_end;
        }
    }

    template <class _Pr2>
    static _Nodeptr _Sort2(const _Nodeptr _BFirst, _Pr2 _Pred) {
        
        
        const auto _First1 = _BFirst->_Next;
        if (!_First1) {
            return _BFirst;
        }

        auto _First2 = _First1->_Next;
        if (!_First2 || !static_cast<bool>(_Pred(_First2->_Myval, _First1->_Myval))) {
            return _First1;
        }

        
        _First1->_Next = _First2->_Next; 
        _BFirst->_Next = _First2; 
        _First2->_Next = _First1;
        return _First2;
    }

    template <class _Pr2>
    static _Nodeptr _Sort(const _Nodeptr _BFirst, size_type _Bound, _Pr2 _Pred) {
        
        
        if (_Bound <= 2) {
            return _Sort2(_BFirst, _Pred);
        }

        const auto _Half_bound = _Bound / 2;
        const auto _BMid       = _Sort(_BFirst, _Half_bound, _Pred);
        if (!_BMid->_Next) {
            return _BMid;
        }

        const auto _BLast = _Sort(_BMid, _Half_bound, _Pred);
        return _Inplace_merge(_BFirst, _BMid, _BLast, _Pred);
    }

    template <class _Pr2>
    static void _Sort(_Nodeptr _BFirst, _Pr2 _Pred) {
        auto _BMid       = _Sort2(_BFirst, _Pred);
        size_type _Bound = 2;
        do {
            if (!_BMid->_Next) {
                return;
            }

            const auto _BLast = _Sort(_BMid, _Bound, _Pred);
            _BMid             = _Inplace_merge(_BFirst, _BMid, _BLast, _Pred);
            _Bound <<= 1;
        } while (_Bound != 0);
    }

    _Nodeptr _Myhead; 
};

template <class _Alnode>
struct _Flist_insert_after_op2 {
    
    using _Alnode_traits = allocator_traits<_Alnode>;
    using pointer        = typename _Alnode_traits::pointer;
    using value_type     = typename _Alnode_traits::value_type;

    explicit _Flist_insert_after_op2(_Alnode& _Al_) : _Al(_Al_), _Tail() {}

    _Flist_insert_after_op2(const _Flist_insert_after_op2&) = delete;
    _Flist_insert_after_op2& operator=(const _Flist_insert_after_op2&) = delete;

    template <class... _CArgT>
    void _Append_n(typename _Alnode_traits::size_type _Count, const _CArgT&... _Carg) {
        
        if (_Count <= 0) {
            return;
        }

        _Alloc_construct_ptr<_Alnode> _Newnode(_Al);
        if (_Tail == pointer{}) {
            _Newnode._Allocate(); 
            _Alnode_traits::construct(_Al, ::std:: addressof(_Newnode._Ptr->_Myval), _Carg...); 
            _Head = _Newnode._Ptr;
            _Tail = _Newnode._Ptr;
            --_Count;
        }

        for (; 0 < _Count; --_Count) {
            _Newnode._Allocate(); 
            _Alnode_traits::construct(_Al, ::std:: addressof(_Newnode._Ptr->_Myval), _Carg...); 
            _Construct_in_place(_Tail->_Next, _Newnode._Ptr);
            _Tail = _Newnode._Ptr;
        }

        (void) _Newnode._Release();
    }

    template <class _InIt, class _Sentinel>
    void _Append_range_unchecked(_InIt _First, const _Sentinel _Last) {
        
        if (_First == _Last) { 
            return;
        }

        _Alloc_construct_ptr<_Alnode> _Newnode(_Al);
        if (_Tail == pointer{}) {
            _Newnode._Allocate(); 
            _Alnode_traits::construct(_Al, ::std:: addressof(_Newnode._Ptr->_Myval), *_First); 
            const auto _Newhead = _Newnode._Release();
            _Head               = _Newhead;
            _Tail               = _Newhead;
            ++_First; 
        }

        while (_First != _Last) { 
            _Newnode._Allocate(); 
            _Alnode_traits::construct(_Al, ::std:: addressof(_Newnode._Ptr->_Myval), *_First); 
            const auto _Newtail = _Newnode._Release();
            _Construct_in_place(_Tail->_Next, _Newtail);
            _Tail = _Newtail;
            ++_First; 
        }
    }

    pointer _Attach_after(pointer _After) noexcept {
        
        const auto _Local_tail = _Tail;
        if (_Local_tail == pointer{}) {
            return _After;
        }

        _Construct_in_place(_Local_tail->_Next, _After->_Next);
        _After->_Next = _Head;
        _Tail         = pointer{};

        return _Local_tail;
    }

    ~_Flist_insert_after_op2() {
        if (_Tail == pointer{}) {
            return;
        }

        _Construct_in_place(_Tail->_Next, pointer{});
        pointer _Subject = _Head;
        while (_Subject) {
            value_type::_Freenode(_Al, ::std:: exchange(_Subject, _Subject->_Next));
        }
    }

private:
    _Alnode& _Al;
    pointer _Tail; 
                   
    pointer _Head; 
};

template <class _Ty, class _Alloc = allocator<_Ty>>
class forward_list { 
private:
    using _Alty          = _Rebind_alloc_t<_Alloc, _Ty>;
    using _Alty_traits   = allocator_traits<_Alty>;
    using _Node          = _Flist_node<_Ty, typename _Alty_traits::void_pointer>;
    using _Alnode        = _Rebind_alloc_t<_Alloc, _Node>;
    using _Alnode_traits = allocator_traits<_Alnode>;
    using _Nodeptr       = typename _Alnode_traits::pointer;

    static_assert(!1 || is_same_v<_Ty, typename _Alloc::value_type>,
        "forward_list<T, Allocator>" " requires that Allocator's value_type match " "T" " (See N4659 26.2.1 [container.requirements.general]/16 allocator_type)" " Either fix the allocator value_type or define _ENFORCE_MATCHING_ALLOCATORS=0" " to suppress this diagnostic.");

    using _Scary_val = _Flist_val<conditional_t<_Is_simple_alloc_v<_Alnode>, _Flist_simple_types<_Ty>,
        _Flist_iter_types<_Ty, typename _Alty_traits::size_type, typename _Alty_traits::difference_type,
            typename _Alty_traits::pointer, typename _Alty_traits::const_pointer, _Ty&, const _Ty&, _Nodeptr>>>;

public:
    using value_type      = _Ty;
    using allocator_type  = _Alloc;
    using size_type       = typename _Alty_traits::size_type;
    using difference_type = typename _Alty_traits::difference_type;
    using pointer         = typename _Alty_traits::pointer;
    using const_pointer   = typename _Alty_traits::const_pointer;
    using reference       = value_type&;
    using const_reference = const value_type&;

    using iterator                  = _Flist_iterator<_Scary_val>;
    using const_iterator            = _Flist_const_iterator<_Scary_val>;
    using _Unchecked_iterator       = _Flist_unchecked_iterator<_Scary_val>;
    using _Unchecked_const_iterator = _Flist_unchecked_const_iterator<_Scary_val>;

    forward_list() noexcept(is_nothrow_default_constructible_v<_Alnode>) 
        : _Mypair(_Zero_then_variadic_args_t{}) {
        _Alloc_proxy();
    }

    explicit forward_list( size_type _Count, const _Alloc& _Al = _Alloc())
        : _Mypair(_One_then_variadic_args_t{}, _Al) { 
        _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
        _Insert_op._Append_n(_Count);
        _Alloc_proxy();
        _Insert_op._Attach_after(_Mypair._Myval2._Before_head());
    }

    forward_list( size_type _Count, const _Ty& _Val)
        : _Mypair(_Zero_then_variadic_args_t{}) { 
        _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
        _Insert_op._Append_n(_Count, _Val);
        _Alloc_proxy();
        _Insert_op._Attach_after(_Mypair._Myval2._Before_head());
    }

    forward_list( size_type _Count, const _Ty& _Val, const _Alloc& _Al)
        : _Mypair(_One_then_variadic_args_t{}, _Al) { 
        _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
        _Insert_op._Append_n(_Count, _Val);
        _Alloc_proxy();
        _Insert_op._Attach_after(_Mypair._Myval2._Before_head());
    }

    explicit forward_list(const _Alloc& _Al) noexcept 
        : _Mypair(_One_then_variadic_args_t{}, _Al) {
        _Alloc_proxy();
    }

    forward_list(const forward_list& _Right)
        : _Mypair(_One_then_variadic_args_t{}, _Alnode_traits::select_on_container_copy_construction(_Right._Getal())) {
        _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
        _Insert_op._Append_range_unchecked(_Right._Unchecked_begin(), _Right._Unchecked_end());
        _Alloc_proxy();
        _Insert_op._Attach_after(_Mypair._Myval2._Before_head());
    }

    forward_list(const forward_list& _Right, const _Identity_t<_Alloc>& _Al)
        : _Mypair(_One_then_variadic_args_t{}, _Al) {
        _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
        _Insert_op._Append_range_unchecked(_Right._Unchecked_begin(), _Right._Unchecked_end());
        _Alloc_proxy();
        _Insert_op._Attach_after(_Mypair._Myval2._Before_head());
    }

    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
    forward_list(_Iter _First, _Iter _Last) : _Mypair(_Zero_then_variadic_args_t{}) {
        _Adl_verify_range(_First, _Last);
        _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
        _Insert_op._Append_range_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last));
        _Alloc_proxy();
        _Insert_op._Attach_after(_Mypair._Myval2._Before_head());
    }

    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
    forward_list(_Iter _First, _Iter _Last, const _Alloc& _Al) : _Mypair(_One_then_variadic_args_t{}, _Al) {
        _Adl_verify_range(_First, _Last);
        _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
        _Insert_op._Append_range_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last));
        _Alloc_proxy();
        _Insert_op._Attach_after(_Mypair._Myval2._Before_head());
    }

    forward_list(forward_list&& _Right) noexcept 
        : _Mypair(_One_then_variadic_args_t{}, ::std:: move(_Right._Getal())) {
        _Alloc_proxy();
        _Take_head(_Right);
    }

    forward_list(forward_list&& _Right, const _Identity_t<_Alloc>& _Al) noexcept(
        _Alnode_traits::is_always_equal::value) 
        : _Mypair(_One_then_variadic_args_t{}, _Al) {
        if constexpr (!_Alty_traits::is_always_equal::value) {
            if (_Getal() != _Right._Getal()) {
                _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
                _Insert_op._Append_range_unchecked(
                    ::std:: make_move_iterator(_Right._Unchecked_begin()), _Default_sentinel{});
                _Alloc_proxy();
                _Insert_op._Attach_after(_Mypair._Myval2._Before_head());
                return;
            }
        }

        _Alloc_proxy();
        _Take_head(_Right);
    }

public:
    forward_list& operator=(forward_list&& _Right) noexcept(
        _Choose_pocma_v<_Alnode> != _Pocma_values::_No_propagate_allocators)  {
        if (this == ::std:: addressof(_Right)) {
            return *this;
        }

        auto& _Al                 = _Getal();
        auto& _Right_al           = _Right._Getal();
        constexpr auto _Pocma_val = _Choose_pocma_v<_Alnode>;
        if constexpr (_Pocma_val == _Pocma_values::_Propagate_allocators) {
            if (_Al != _Right_al) {
                _Mypair._Myval2._Orphan_all();
                clear();
                _Mypair._Myval2._Reload_proxy(_Fake_alloc, _Fake_alloc);
                _Pocma(_Al, _Right_al);
                _Take_head(_Right);
                return *this;
            }
        } else if constexpr (_Pocma_val == _Pocma_values::_No_propagate_allocators) {
            if (_Al != _Right_al) {
                _Assign_unchecked(::std:: make_move_iterator(_Right._Unchecked_begin()), _Right._Unchecked_end());
                return *this;
            }
        }

        clear();
        _Pocma(_Al, _Right_al);
        _Take_head(_Right);
        return *this;
    }

private:
    void _Take_head(forward_list& _Right) noexcept { 
        _Swap_proxy_and_iterators(_Right);
        _Mypair._Myval2._Myhead = ::std:: exchange(_Right._Mypair._Myval2._Myhead, nullptr);
    }

public:
    void push_front(_Ty&& _Val) { 
        _Insert_after(_Mypair._Myval2._Before_head(), ::std:: move(_Val));
    }

    iterator insert_after(const_iterator _Where, _Ty&& _Val) { 
        return emplace_after(_Where, ::std:: move(_Val));
    }

    template <class... _Valty>
    decltype(auto) emplace_front(_Valty&&... _Val) { 
        _Insert_after(_Mypair._Myval2._Before_head(), ::std:: forward<_Valty>(_Val)...);


        return front();
#line 687 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"
    }

    template <class... _Valty>
    iterator emplace_after(const_iterator _Where, _Valty&&... _Val) { 


#line 695 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"
        _Insert_after(_Where._Ptr, ::std:: forward<_Valty>(_Val)...);
        return _Make_iter(_Where._Ptr->_Next);
    }

private:
    template <class... _Valty>
    void _Insert_after(_Nodeptr _Pnode, _Valty&&... _Val) { 
        _Alloc_construct_ptr<_Alnode> _Newnode(_Getal());
        _Newnode._Allocate(); 
        _Alnode_traits::construct(
            _Newnode._Al, ::std:: addressof(_Newnode._Ptr->_Myval), ::std:: forward<_Valty>(_Val)...); 
        _Construct_in_place(_Newnode._Ptr->_Next, _Pnode->_Next);
        _Pnode->_Next = _Newnode._Release();
    }

public:
    forward_list(initializer_list<_Ty> _Ilist, const _Alloc& _Al = allocator_type())
        : _Mypair(_One_then_variadic_args_t{}, _Al) {
        auto&& _Alproxy = _Fake_alloc;
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
        insert_after(before_begin(), _Ilist.begin(), _Ilist.end());
        _Proxy._Release();
    }

    forward_list& operator=(initializer_list<_Ty> _Ilist) {
        assign(_Ilist.begin(), _Ilist.end());
        return *this;
    }

    void assign(initializer_list<_Ty> _Ilist) {
        assign(_Ilist.begin(), _Ilist.end());
    }

    iterator insert_after(const_iterator _Where,
        initializer_list<_Ty> _Ilist) { 
        return insert_after(_Where, _Ilist.begin(), _Ilist.end());
    }

    ~forward_list() noexcept {
        clear();


#line 739 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"
    }

public:
    forward_list& operator=(const forward_list& _Right) {
        if (this == ::std:: addressof(_Right)) {
            return *this;
        }

        auto& _Al       = _Getal();
        auto& _Right_al = _Right._Getal();
        if constexpr (_Choose_pocca_v<_Alnode>) {
            if (_Al != _Right_al) {
                _Mypair._Myval2._Orphan_all();
                clear();
                _Mypair._Myval2._Reload_proxy(
                    _Fake_alloc, _Fake_alloc);
            }
        }

        _Pocca(_Al, _Right_al);
        _Assign_unchecked(_Right._Unchecked_begin(), _Right._Unchecked_end());

        return *this;
    }

    [[nodiscard]] iterator before_begin() noexcept {
        return iterator(_Mypair._Myval2._Before_head(), ::std:: addressof(_Mypair._Myval2));
    }

    [[nodiscard]] const_iterator before_begin() const noexcept {
        return const_iterator(_Mypair._Myval2._Before_head(), ::std:: addressof(_Mypair._Myval2));
    }

    [[nodiscard]] const_iterator cbefore_begin() const noexcept {
        return before_begin();
    }

    [[nodiscard]] iterator begin() noexcept {
        return iterator(_Mypair._Myval2._Myhead, ::std:: addressof(_Mypair._Myval2));
    }

    [[nodiscard]] const_iterator begin() const noexcept {
        return const_iterator(_Mypair._Myval2._Myhead, ::std:: addressof(_Mypair._Myval2));
    }

    [[nodiscard]] iterator end() noexcept {
        return iterator(nullptr, ::std:: addressof(_Mypair._Myval2));
    }

    [[nodiscard]] const_iterator end() const noexcept {
        return const_iterator(nullptr, ::std:: addressof(_Mypair._Myval2));
    }

    _Unchecked_iterator _Unchecked_before_begin() noexcept {
        return _Unchecked_iterator(_Mypair._Myval2._Before_head(), nullptr);
    }

    _Unchecked_iterator _Unchecked_begin() noexcept {
        return _Unchecked_iterator(_Mypair._Myval2._Myhead, nullptr);
    }

    _Unchecked_const_iterator _Unchecked_begin() const noexcept {
        return _Unchecked_const_iterator(_Mypair._Myval2._Myhead, nullptr);
    }

    _Default_sentinel _Unchecked_end() const noexcept {
        return {};
    }

    _Unchecked_const_iterator _Unchecked_end_iter() const noexcept {
        return _Unchecked_const_iterator(nullptr, nullptr);
    }

    iterator _Make_iter(_Nodeptr _Where) const noexcept {
        return iterator(_Where, ::std:: addressof(_Mypair._Myval2));
    }

    [[nodiscard]] const_iterator cbegin() const noexcept {
        return begin();
    }

    [[nodiscard]] const_iterator cend() const noexcept {
        return end();
    }

private:
    template <class... _Args>
    void _Resize( size_type _Newsize, const _Args&... _Vals) {
        auto& _Al = _Getal();
        auto _Ptr = _Mypair._Myval2._Before_head();
        for (;;) {
            auto _Next = _Ptr->_Next;
            if (!_Next) {
                
                _Flist_insert_after_op2<_Alnode> _Insert_op(_Al);
                _Insert_op._Append_n(_Newsize, _Vals...);
                _Insert_op._Attach_after(_Ptr);
                return;
            }

            if (_Newsize == 0) {
                
                _Ptr->_Next = nullptr;
                do {
                    const auto _Nextafter = _Next->_Next;


#line 847 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"
                    _Node::_Freenode(_Al, _Next);
                    _Next = _Nextafter;
                } while (_Next);

                return;
            }

            _Ptr = _Next;
            --_Newsize;
        }
    }

public:
    void resize( size_type _Newsize) {
        _Resize(_Newsize);
    }

    void resize( size_type _Newsize, const _Ty& _Val) {
        _Resize(_Newsize, _Val);
    }

    [[nodiscard]] size_type max_size() const noexcept {
        return (::std:: min)(
            static_cast<size_type>((numeric_limits<difference_type>::max)()), _Alnode_traits::max_size(_Getal()));
    }

    [[nodiscard]] bool empty() const noexcept {
        return _Mypair._Myval2._Myhead == nullptr;
    }

    [[nodiscard]] allocator_type get_allocator() const noexcept {
        return static_cast<allocator_type>(_Getal());
    }

    [[nodiscard]] reference front() noexcept  {


#line 885 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"

        return _Mypair._Myval2._Myhead->_Myval;
    }

    [[nodiscard]] const_reference front() const noexcept  {


#line 893 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"

        return _Mypair._Myval2._Myhead->_Myval;
    }

    void push_front(const _Ty& _Val) {
        _Insert_after(_Mypair._Myval2._Before_head(), _Val);
    }

    void pop_front() noexcept  {
        _Erase_after(_Mypair._Myval2._Before_head());
    }

private:
    template <class _UIter, class _Sentinel>
    void _Assign_unchecked(_UIter _UFirst, _Sentinel _ULast) {
        auto _Myfirst = _Mypair._Myval2._Before_head();
        for (; _UFirst != _ULast; ++_UFirst) {
            auto _Next = _Myfirst->_Next;
            if (!_Myfirst->_Next) {
                _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
                _Insert_op._Append_range_unchecked(_UFirst, _ULast);
                _Insert_op._Attach_after(_Myfirst);
                return;
            }

            _Next->_Myval = *_UFirst;
            _Myfirst      = _Next;
        }

        for (auto _To_delete = ::std:: exchange(_Myfirst->_Next, nullptr); _To_delete;) {
            auto _Next = _To_delete->_Next;


#line 927 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"
            _Node::_Freenode(_Getal(), _To_delete);
            _To_delete = _Next;
        }
    }

public:
    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
    void assign(_Iter _First, _Iter _Last) {
        _Adl_verify_range(_First, _Last);
        _Assign_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last));
    }

    void assign( size_type _Count, const _Ty& _Val) {
        clear();
        insert_after(before_begin(), _Count, _Val);
    }

    iterator insert_after(const_iterator _Where, const _Ty& _Val) { 


#line 948 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"
        _Insert_after(_Where._Ptr, _Val);
        return _Make_iter(_Where._Ptr->_Next);
    }

    iterator insert_after(const_iterator _Where,  size_type _Count, const _Ty& _Val) {
        

#line 958 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"

        if (_Count != 0) {
            _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
            _Insert_op._Append_n(_Count, _Val);
            _Where._Ptr = _Insert_op._Attach_after(_Where._Ptr);
        }

        return _Make_iter(_Where._Ptr);
    }

    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
    iterator insert_after(const_iterator _Where, _Iter _First, _Iter _Last) {
        

#line 975 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"

        _Adl_verify_range(_First, _Last);
        const auto _UFirst = _Get_unwrapped(_First);
        const auto _ULast  = _Get_unwrapped(_Last);
        if (_UFirst == _ULast) {
            return _Make_iter(_Where._Ptr);
        }

        _Flist_insert_after_op2<_Alnode> _Insert_op(_Getal());
        _Insert_op._Append_range_unchecked(_UFirst, _ULast);
        return _Make_iter(_Insert_op._Attach_after(_Where._Ptr));
    }

private:
    void _Erase_after(_Nodeptr _Pnode) noexcept { 
        auto _Subject = _Pnode->_Next;


#line 994 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"
        _Pnode->_Next = _Subject->_Next;
        _Node::_Freenode(_Getal(), _Subject);
    }

public:
    iterator erase_after(const_iterator _Where) noexcept  {


#line 1004 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"
        _Erase_after(_Where._Ptr);
        return _Make_iter(_Where._Ptr->_Next);
    }

    iterator erase_after(const_iterator _First, const_iterator _Last) noexcept  {


#line 1014 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"
        auto _Before = _First._Ptr;
        if (_Before != _Last._Ptr) {
            auto& _Al = _Getal();
            for (;;) {
                const auto _Subject = _Before->_Next;
                if (_Subject == _Last._Ptr) {
                    break;
                }


#line 1026 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"
                _Before->_Next = _Subject->_Next;
                _Node::_Freenode(_Al, _Subject);
            }
        }

        return _Make_iter(_Last._Ptr);
    }

    void clear() noexcept { 


#line 1038 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"

        _Nodeptr _Pnext;
        _Nodeptr _Pnode = ::std:: exchange(_Mypair._Myval2._Myhead, nullptr);

        auto& _Al = _Getal();
        for (; _Pnode; _Pnode = _Pnext) { 
            _Pnext = _Pnode->_Next;
            _Node::_Freenode(_Al, _Pnode);
        }
    }

    void swap(forward_list& _Right) noexcept  {
        if (this != ::std:: addressof(_Right)) {
            _Pocs(_Getal(), _Right._Getal());
            _Swap_proxy_and_iterators(_Right);
            _Swap_adl(_Mypair._Myval2._Myhead, _Right._Mypair._Myval2._Myhead);
        }
    }

    void splice_after(const_iterator _Where, forward_list& _Right) noexcept  {
        

#line 1063 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"

        if (this != ::std:: addressof(_Right) && !_Right.empty()) { 
            _Splice_after(_Where._Unwrapped(), _Right, _Right._Unchecked_before_begin(), _Default_sentinel{});
        }
    }

    void splice_after(const_iterator _Where, forward_list&& _Right) noexcept  {
        
        splice_after(_Where, _Right);
    }

    void splice_after(const_iterator _Where, forward_list& _Right, const_iterator _First) noexcept  {
        

#line 1083 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"

        _Splice_after(_Where._Ptr, _Right, _First._Ptr);
    }

    void splice_after(const_iterator _Where, forward_list&& _Right, const_iterator _First) noexcept  {
        
        splice_after(_Where, _Right, _First);
    }

    void splice_after(const_iterator _Where, forward_list& _Right, const_iterator _First, const_iterator _Last) noexcept
     {
        

#line 1102 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"

        _Splice_after(_Where._Unwrapped(), _Right, _First._Unwrapped(), _Last._Unwrapped());
    }

    void splice_after(const_iterator _Where, forward_list&& _Right, const_iterator _First,
        const_iterator _Last) noexcept  {
        
        splice_after(_Where, _Right, _First, _Last);
    }

    struct _Flist_node_remove_op {
        
        
        explicit _Flist_node_remove_op(forward_list& _List_) noexcept
            : _List(_List_), _Head(), _Tail(::std:: addressof(_Head)) {}

        _Flist_node_remove_op(const _Flist_node_remove_op&) = delete;
        _Flist_node_remove_op& operator=(const _Flist_node_remove_op&) = delete;

        _Nodeptr _Transfer_back(const _Nodeptr _Predecessor) noexcept {
            
            
            const auto _Removed = _Predecessor->_Next;
            const auto _Next    = _Removed->_Next;
            _Removed->_Next     = _Nodeptr();
            _Predecessor->_Next = _Next;

            *_Tail = _Removed;
            _Tail  = ::std:: addressof(_Removed->_Next);

            return _Next;
        }

        ~_Flist_node_remove_op() {
            auto& _Al    = _List._Getal();
            auto _Target = _Head;
            while (_Target) {
                auto _Next = _Target->_Next;


#line 1146 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"
                _Alnode_traits::destroy(_Al, ::std:: addressof(_Target->_Next));
                _Alnode_traits::destroy(_Al, ::std:: addressof(_Target->_Myval));
                _Al.deallocate(_Target, 1);
                _Target = _Next;
            }
        }

        forward_list& _List;
        _Nodeptr _Head;
        _Nodeptr* _Tail;
    };

    auto remove(const _Ty& _Val) { 
        return remove_if([&](const _Ty& _Other) { return _Other == _Val; });
    }

    template <class _Pr1>
    auto remove_if(_Pr1 _Pred) { 
        _Flist_node_remove_op _Op(*this);
        auto _Firstb       = _Unchecked_before_begin();
        size_type _Removed = 0;

        for (auto _First = _Unchecked_begin(); _First._Ptr;) {
            if (_Pred(*_First)) {
                _First._Ptr = _Op._Transfer_back(_Firstb._Ptr);
                ++_Removed;
            } else { 
                _Firstb = _First;
                ++_First;
            }
        }


        return _Removed;


#line 1183 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"
    }

    auto unique() { 
        return unique(equal_to<>{});
    }

    template <class _Pr2>
    auto unique(_Pr2 _Pred) { 
        _Flist_node_remove_op _Op(*this);
        auto _First        = _Unchecked_begin();
        size_type _Removed = 0;
        if (_First._Ptr) { 
            auto _After = _First;
            ++_After;
            while (_After._Ptr) {
                if (_Pred(*_First, *_After)) {
                    _After._Ptr = _Op._Transfer_back(_First._Ptr);
                    ++_Removed;
                } else {
                    _First = _After;
                    ++_After;
                }
            }
        }


        return _Removed;


#line 1213 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"
    }

    void merge(forward_list& _Right) { 
        _Merge1(_Right, less<>{});
    }

    void merge(forward_list&& _Right) { 
        _Merge1(_Right, less<>{});
    }

    template <class _Pr2>
    void merge(forward_list& _Right, _Pr2 _Pred) { 
        _Merge1(_Right, _Pass_fn(_Pred));
    }

    template <class _Pr2>
    void merge(forward_list&& _Right, _Pr2 _Pred) { 
        _Merge1(_Right, _Pass_fn(_Pred));
    }

private:
    template <class _Pr2>
    void _Merge1(forward_list& _Right, _Pr2 _Pred) { 


#line 1239 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"
        if (this == ::std:: addressof(_Right)) {
            return;
        }

        auto& _My_data    = _Mypair._Myval2;
        auto& _Right_data = _Right._Mypair._Myval2;


#line 1251 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"

        if (!_My_data._Myhead) {
            

#line 1260 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"
            _My_data._Myhead    = _Right_data._Myhead;
            _Right_data._Myhead = nullptr;
            return;
        }


#line 1275 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"

        if (!_Right_data._Myhead) {
            return;
        }

        auto _BFirst1 = _My_data._Before_head();
        auto _First2  = _Right_data._Myhead;
        for (;;) { 
            _Nodeptr _First1;
            for (;;) { 
                _First1 = _BFirst1->_Next;
                if (!_First1) { 
                    _BFirst1->_Next     = _First2;
                    _Right_data._Myhead = nullptr;
                    return;
                }

                if (static_cast<bool>(_Pred(_First2->_Myval, _First1->_Myval))) {
                    
                    break;
                }

                
                _BFirst1 = _First1;
            }

            
            auto _BRun_end = _First2;
            _Nodeptr _Run_end;
            for (;;) {
                _Run_end = _BRun_end->_Next;
                if (!_Run_end) {
                    break;
                }

                if (!static_cast<bool>(_Pred(_Run_end->_Myval, _First1->_Myval))) {
                    
                    
                    break;
                }

                _BRun_end = _Run_end;
            }


#line 1327 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"

            _Right_data._Myhead = _Run_end; 
            _BFirst1->_Next     = _First2; 
            _BRun_end->_Next    = _First1;
            if (!_Run_end) {
                return;
            }

            _BFirst1 = _First1;
            _First2  = _Run_end;
        }
    }

public:
    void sort() { 
        _Scary_val::_Sort(_Mypair._Myval2._Before_head(), less<>{});
    }

    template <class _Pr2>
    void sort(_Pr2 _Pred) { 
        _Scary_val::_Sort(_Mypair._Myval2._Before_head(), _Pass_fn(_Pred));
    }

    void reverse() noexcept { 
        auto _Current = _Mypair._Myval2._Myhead;
        if (!_Current) {
            
            return;
        }

        _Nodeptr _Prev{};
        for (;;) {
            const auto _Next = _Current->_Next;
            _Current->_Next  = _Prev;
            if (!_Next) {
                _Mypair._Myval2._Myhead = _Current;
                return;
            }

            _Prev    = _Current;
            _Current = _Next;
        }
    }

private:


#line 1412 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"

    void _Splice_after(_Nodeptr _Where, forward_list& _Right, _Nodeptr _Prev) noexcept {
        

        (void) _Right;


#line 1422 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"


#line 1429 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"

        if (_Where != _Prev) {
            const auto _First = _Prev->_Next;
            if (_Where != _First) {
                _Prev->_Next  = _First->_Next;
                _First->_Next = _Where->_Next;
                _Where->_Next = _First;
            }
        }
    }

    template <class _Sentinel>
    void _Splice_after(_Unchecked_const_iterator _Where, forward_list& _Right, _Unchecked_const_iterator _First,
        _Sentinel _Last) noexcept {
        

        (void) _Right;


#line 1451 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"

        if (_First == _Last) {
            return;
        }


#line 1465 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"

        
        _Unchecked_const_iterator _After = _First;
        ++_After;
        if (_After == _Last) {
            return;
        }

        _Unchecked_const_iterator _Prev_last = _First;
        do {
            _Prev_last = _After;
            ++_After;
        } while (_After != _Last);

        const auto _Extracted_head = _First._Ptr->_Next;
        _First._Ptr->_Next         = _After._Ptr;
        _Prev_last._Ptr->_Next     = _Where._Ptr->_Next;
        _Where._Ptr->_Next         = _Extracted_head;
    }

    void _Alloc_proxy() {
        _Mypair._Myval2._Alloc_proxy(_Fake_alloc);
    }

    void _Swap_proxy_and_iterators(forward_list& _Right) noexcept {
        _Mypair._Myval2._Swap_proxy_and_iterators(_Right._Mypair._Myval2);
    }

    _Alnode& _Getal() noexcept {
        return _Mypair._Get_first();
    }

    const _Alnode& _Getal() const noexcept {
        return _Mypair._Get_first();
    }

    _Compressed_pair<_Alnode, _Scary_val> _Mypair;
};


template <class _Iter, class _Alloc = allocator<_Iter_value_t<_Iter>>,
    enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
forward_list(_Iter, _Iter, _Alloc = _Alloc()) -> forward_list<_Iter_value_t<_Iter>, _Alloc>;
#line 1509 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"

template <class _Ty, class _Alloc>
void swap(forward_list<_Ty, _Alloc>& _Left, forward_list<_Ty, _Alloc>& _Right) noexcept  {
    _Left.swap(_Right);
}

template <class _Ty, class _Alloc>
[[nodiscard]] bool operator==(const forward_list<_Ty, _Alloc>& _Left, const forward_list<_Ty, _Alloc>& _Right) {
    return ::std:: equal(
        _Left._Unchecked_begin(), _Left._Unchecked_end_iter(), _Right._Unchecked_begin(), _Right._Unchecked_end_iter());
}


#line 1527 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"


template <class _Ty, class _Alloc>
[[nodiscard]] _Synth_three_way_result<_Ty> operator<=>(
    const forward_list<_Ty, _Alloc>& _Left, const forward_list<_Ty, _Alloc>& _Right) {
    return ::std:: lexicographical_compare_three_way(_Left._Unchecked_begin(), _Left._Unchecked_end_iter(),
        _Right._Unchecked_begin(), _Right._Unchecked_end_iter(), _Synth_three_way{});
}


#line 1557 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"


template <class _Ty, class _Alloc, class _Uty>
typename forward_list<_Ty, _Alloc>::size_type erase(forward_list<_Ty, _Alloc>& _Cont, const _Uty& _Val) {
    return _Cont.remove_if([&](_Ty& _Elem) { return _Elem == _Val; });
}

template <class _Ty, class _Alloc, class _Pr>
typename forward_list<_Ty, _Alloc>::size_type erase_if(forward_list<_Ty, _Alloc>& _Cont, _Pr _Pred) {
    return _Cont.remove_if(_Pass_fn(_Pred));
}
#line 1569 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"


namespace pmr {
    template <class _Ty>
    using forward_list = ::std:: forward_list<_Ty, polymorphic_allocator<_Ty>>;
} 
#line 1576 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"
}


#pragma warning(pop)
#pragma pack(pop)
#line 1582 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"
#line 1583 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\forward_list"
#line 25 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\istream"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ostream"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ios"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocnum"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
template <class _Container>
class back_insert_iterator { 
public:
    using iterator_category = output_iterator_tag;
    using value_type        = void;
    using pointer           = void;
    using reference         = void;

    using container_type = _Container;


    using difference_type = ptrdiff_t;


#line 37 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"

    constexpr explicit back_insert_iterator(_Container& _Cont) noexcept 
        : container(::std:: addressof(_Cont)) {}

    constexpr back_insert_iterator& operator=(const typename _Container::value_type& _Val) {
        container->push_back(_Val);
        return *this;
    }

    constexpr back_insert_iterator& operator=(typename _Container::value_type&& _Val) {
        container->push_back(::std:: move(_Val));
        return *this;
    }

    [[nodiscard]] constexpr back_insert_iterator& operator*() noexcept  {
        return *this;
    }

    constexpr back_insert_iterator& operator++() noexcept  {
        return *this;
    }

    constexpr back_insert_iterator operator++(int) noexcept  {
        return *this;
    }

protected:
    _Container* container;
};

template <class _Container>
[[nodiscard]] constexpr back_insert_iterator<_Container> back_inserter(_Container& _Cont) noexcept  {
    
    return back_insert_iterator<_Container>(_Cont);
}

template <class _Container>
class front_insert_iterator { 
public:
    using iterator_category = output_iterator_tag;
    using value_type        = void;
    using pointer           = void;
    using reference         = void;

    using container_type = _Container;


    using difference_type = ptrdiff_t;


#line 88 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"

    constexpr explicit front_insert_iterator(_Container& _Cont) : container(::std:: addressof(_Cont)) {}

    constexpr front_insert_iterator& operator=(const typename _Container::value_type& _Val) {
        
        container->push_front(_Val);
        return *this;
    }

    constexpr front_insert_iterator& operator=(typename _Container::value_type&& _Val) { 
        container->push_front(::std:: move(_Val));
        return *this;
    }

    [[nodiscard]] constexpr front_insert_iterator& operator*() { 
        return *this;
    }

    constexpr front_insert_iterator& operator++() { 
        return *this;
    }

    constexpr front_insert_iterator operator++(int) { 
        return *this;
    }

protected:
    _Container* container;
};

template <class _Container>
[[nodiscard]] constexpr front_insert_iterator<_Container> front_inserter(_Container& _Cont) {
    return front_insert_iterator<_Container>(_Cont);
}

template <class _Container>
class insert_iterator { 
public:
    using iterator_category = output_iterator_tag;
    using value_type        = void;
    using pointer           = void;
    using reference         = void;

    using container_type = _Container;

    using difference_type = ptrdiff_t;
    using _Wrapped_iter   = ranges::iterator_t<_Container>;


#line 139 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"

    constexpr insert_iterator(_Container& _Cont, _Wrapped_iter _Where)
        : container(::std:: addressof(_Cont)), iter(::std:: move(_Where)) {}

    constexpr insert_iterator& operator=(const typename _Container::value_type& _Val) {
        
        iter = container->insert(iter, _Val);
        ++iter;
        return *this;
    }

    constexpr insert_iterator& operator=(typename _Container::value_type&& _Val) { 
        iter = container->insert(iter, ::std:: move(_Val));
        ++iter;
        return *this;
    }

    [[nodiscard]] constexpr insert_iterator& operator*() { 
        return *this;
    }

    constexpr insert_iterator& operator++() { 
        return *this;
    }

    constexpr insert_iterator& operator++(int) { 
        return *this;
    }

protected:
    _Container* container;
    _Wrapped_iter iter;
};


template <class _Container>
[[nodiscard]] constexpr insert_iterator<_Container> inserter(_Container& _Cont, ::std::ranges:: iterator_t<_Container> _Where) {
    return insert_iterator<_Container>(_Cont, _Where);
}

template <semiregular _Se>
class move_sentinel {
public:
    constexpr move_sentinel() = default;

    constexpr explicit move_sentinel(_Se _Val) noexcept(is_nothrow_move_constructible_v<_Se>) 
        : _Last{::std:: move(_Val)} {}

    
    template <class _Se2>
        requires convertible_to<const _Se2&, _Se>
    constexpr move_sentinel(const move_sentinel<_Se2>& _Val)
        noexcept(is_nothrow_constructible_v<_Se, const _Se2&>) 
        : _Last{_Val._Get_last()} {}

    template <class _Se2>
        requires assignable_from<_Se&, const _Se2&>
    constexpr move_sentinel& operator=(const move_sentinel<_Se2>& _Val)
        noexcept(is_nothrow_assignable_v<_Se&, const _Se2&>)  {
        _Last = _Val._Get_last();
        return *this;
    }
    

    [[nodiscard]] constexpr _Se base() const noexcept(is_nothrow_copy_constructible_v<_Se>)  {
        return _Last;
    }

    [[nodiscard]] constexpr const _Se& _Get_last() const noexcept {
        return _Last;
    }

private:
    _Se _Last{};
};
#line 220 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"

template <class _Ty, class _Elem = char, class _Traits = char_traits<_Elem>, class _Diff = ptrdiff_t>
class istream_iterator {
public:
    using iterator_category = input_iterator_tag;
    using value_type        = _Ty;
    using difference_type   = _Diff;
    using pointer           = const _Ty*;
    using reference         = const _Ty&;
    using char_type         = _Elem;
    using traits_type       = _Traits;
    using istream_type      = basic_istream<_Elem, _Traits>;

    static_assert(conjunction_v<is_default_constructible<_Ty>, is_copy_constructible<_Ty>, is_copy_assignable<_Ty>>,
        "istream_iterator<T> requires T to be default constructible, copy constructible, and copy assignable. "
        "(N4835 [istream.iterator]/2)");

    constexpr istream_iterator() noexcept(is_nothrow_default_constructible_v<_Ty>)  {}


    constexpr istream_iterator(default_sentinel_t) noexcept(is_nothrow_default_constructible_v<_Ty>) 
    {}
#line 243 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"

    istream_iterator(istream_type& _Istr) : _Myistr(::std:: addressof(_Istr)) {
        _Getval();
    }

    [[nodiscard]] const _Ty& operator*() const noexcept  {
        ;
        return _Myval;
    }

    [[nodiscard]] const _Ty* operator->() const noexcept  {
        ;
        return ::std:: addressof(_Myval);
    }

    istream_iterator& operator++() {
        _Getval();
        return *this;
    }

    istream_iterator operator++(int) {
        istream_iterator _Tmp = *this;
        _Getval();
        return _Tmp;
    }

    [[nodiscard]] bool _Equal(const istream_iterator& _Right) const noexcept {
        return _Myistr == _Right._Myistr;
    }


    [[nodiscard]] friend bool operator==(const istream_iterator& _Left, default_sentinel_t) noexcept  {
        return !_Left._Myistr;
    }
#line 278 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"

private:
    void _Getval() { 
        ;
        if (!(*_Myistr >> _Myval)) {
            _Myistr = nullptr;
        }
    }

    istream_type* _Myistr{nullptr}; 
    _Ty _Myval{}; 
};

template <class _Ty, class _Elem, class _Traits, class _Diff>
[[nodiscard]] bool operator==(const istream_iterator<_Ty, _Elem, _Traits, _Diff>& _Left,
    const istream_iterator<_Ty, _Elem, _Traits, _Diff>& _Right) noexcept  {
    return _Left._Equal(_Right);
}


#line 304 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"

template <class _Ty, class _Elem = char, class _Traits = char_traits<_Elem>>
class ostream_iterator {
public:
    using iterator_category = output_iterator_tag;
    using value_type        = void;

    using difference_type = ptrdiff_t;


#line 315 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
    using pointer      = void;
    using reference    = void;
    using char_type    = _Elem;
    using traits_type  = _Traits;
    using ostream_type = basic_ostream<_Elem, _Traits>;

    ostream_iterator(ostream_type& _Ostr, const _Elem* const _Delim = nullptr) noexcept 
        : _Mydelim(_Delim), _Myostr(::std:: addressof(_Ostr)) {}

    ostream_iterator& operator=(const _Ty& _Val) { 
        *_Myostr << _Val;
        if (_Mydelim) {
            *_Myostr << _Mydelim;
        }

        return *this;
    }

    [[nodiscard]] ostream_iterator& operator*() noexcept  {
        return *this;
    }

    ostream_iterator& operator++() noexcept  {
        return *this;
    }

    ostream_iterator& operator++(int) noexcept  {
        return *this;
    }

private:
    const _Elem* _Mydelim; 
    ostream_type* _Myostr; 
};

template <class _Elem, class _Traits>
class istreambuf_iterator {
public:
    using iterator_category = input_iterator_tag;
    using value_type        = _Elem;
    using difference_type   = typename _Traits::off_type;
    using pointer           = const _Elem*;
    using reference         = _Elem;
    using char_type         = _Elem;
    using traits_type       = _Traits;
    using int_type          = typename traits_type::int_type;
    using streambuf_type    = basic_streambuf<_Elem, _Traits>;
    using istream_type      = basic_istream<_Elem, _Traits>;

    constexpr istreambuf_iterator() noexcept : _Strbuf(nullptr), _Got(true), _Val() {}

    constexpr istreambuf_iterator(default_sentinel_t) noexcept : _Strbuf(nullptr), _Got(true), _Val() {}
#line 368 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"

    istreambuf_iterator(istream_type& _Istr) noexcept : _Strbuf(_Istr.rdbuf()), _Got(!_Strbuf), _Val() {}

    istreambuf_iterator(streambuf_type* _Sb) noexcept : _Strbuf(_Sb), _Got(!_Sb), _Val() {}

private:
    class _Istreambuf_proxy {
    public:
        [[nodiscard]] _Elem operator*() const noexcept(is_nothrow_copy_constructible_v<_Elem>)  {
            return _Keep;
        }

    private:
        friend istreambuf_iterator;
        _Istreambuf_proxy(streambuf_type* _Strbuf_, _Elem _Keep_) noexcept(
            is_nothrow_copy_constructible_v<_Elem>) 
            : _Strbuf(_Strbuf_), _Keep(_Keep_) {}

        streambuf_type* _Strbuf;
        _Elem _Keep;
    };

public:
    istreambuf_iterator(const _Istreambuf_proxy& _Px) noexcept : _Strbuf(_Px._Strbuf), _Got(!_Strbuf), _Val() {}

    [[nodiscard]] _Elem operator*() const {
        if (!_Got) {
            _Peek();
        }


#line 401 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"

        return _Val;
    }

    istreambuf_iterator& operator++() {


#line 409 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"

        _Inc();
        return *this;
    }

    _Istreambuf_proxy operator++(int) {
        if (!_Got) {
            _Peek();
        }

        _Istreambuf_proxy _Tmp{_Strbuf, _Val};
        ++*this;
        return _Tmp;
    }

    [[nodiscard]] bool equal(const istreambuf_iterator& _Right) const {
        if (!_Got) {
            _Peek();
        }

        if (!_Right._Got) {
            _Right._Peek();
        }

        return (!_Strbuf && !_Right._Strbuf) || (_Strbuf && _Right._Strbuf);
    }


    [[nodiscard]] friend bool operator==(const istreambuf_iterator& _Left, default_sentinel_t) {
        if (!_Left._Got) {
            _Left._Peek();
        }

        return !_Left._Strbuf;
    }
#line 445 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"

private:
    void _Inc() { 
        if (!_Strbuf || traits_type::eq_int_type(traits_type::eof(), _Strbuf->sbumpc())) {
            _Strbuf = nullptr;
            _Got    = true;
        } else {
            _Got = false;
        }
    }

    _Elem _Peek() const { 
        int_type _Meta;
        if (!_Strbuf || traits_type::eq_int_type(traits_type::eof(), _Meta = _Strbuf->sgetc())) {
            _Strbuf = nullptr;
        } else {
            _Val = traits_type::to_char_type(_Meta);
        }

        _Got = true;
        return _Val;
    }

    mutable streambuf_type* _Strbuf; 
    mutable bool _Got; 
    mutable _Elem _Val; 
};

template <class _Elem, class _Traits>
[[nodiscard]] bool operator==(
    const istreambuf_iterator<_Elem, _Traits>& _Left, const istreambuf_iterator<_Elem, _Traits>& _Right) {
    return _Left.equal(_Right);
}


#line 486 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"

template <class _Elem, class _Traits>
class ostreambuf_iterator {
public:
    using iterator_category = output_iterator_tag;
    using value_type        = void;

    using difference_type = ptrdiff_t;


#line 497 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
    using pointer        = void;
    using reference      = void;
    using char_type      = _Elem;
    using traits_type    = _Traits;
    using streambuf_type = basic_streambuf<_Elem, _Traits>;
    using ostream_type   = basic_ostream<_Elem, _Traits>;

    ostreambuf_iterator(streambuf_type* _Sb) noexcept : _Strbuf(_Sb) {}

    ostreambuf_iterator(ostream_type& _Ostr) noexcept : _Strbuf(_Ostr.rdbuf()) {}

    ostreambuf_iterator& operator=(_Elem _Right) { 
        if (!_Strbuf || traits_type::eq_int_type(_Traits::eof(), _Strbuf->sputc(_Right))) {
            _Failed = true;
        }

        return *this;
    }

    [[nodiscard]] ostreambuf_iterator& operator*() noexcept  {
        return *this;
    }

    ostreambuf_iterator& operator++() noexcept  {
        return *this;
    }

    ostreambuf_iterator& operator++(int) noexcept  {
        return *this;
    }

    [[nodiscard]] bool failed() const noexcept {
        return _Failed;
    }

private:
    bool _Failed = false; 
    streambuf_type* _Strbuf;
};


enum class _Variantish_state : unsigned char { _Nothing, _Holds_iter, _Holds_sentinel };

struct _Common_iterator_construct_tag {
    explicit _Common_iterator_construct_tag() = default;
};

template <input_or_output_iterator _It, sentinel_for<_It> _Se>
class _Variantish {
public:
    constexpr explicit _Variantish(_Common_iterator_construct_tag) noexcept : _Contains{_Variantish_state::_Nothing} {}

    constexpr _Variantish() noexcept(is_nothrow_default_constructible_v<_It>) requires default_initializable<_It>
        : _Iterator{}, _Contains{_Variantish_state::_Holds_iter} {}

    template <class... _Types>
    constexpr explicit _Variantish(in_place_type_t<_It>, _Types&&... _Args) noexcept(
        is_nothrow_constructible_v<_It, _Types...>)
        : _Iterator(::std:: forward<_Types>(_Args)...), _Contains{_Variantish_state::_Holds_iter} {}

    template <class... _Types>
    constexpr explicit _Variantish(in_place_type_t<_Se>, _Types&&... _Args) noexcept(
        is_nothrow_constructible_v<_Se, _Types...>)
        : _Sentinel(::std:: forward<_Types>(_Args)...), _Contains{_Variantish_state::_Holds_sentinel} {}

    
    template <class _OIter, class _OSe>
        requires _Not_same_as<_Variantish<_OIter, _OSe>, _Variantish>
    constexpr _Variantish(const _Variantish<_OIter, _OSe>& _That) noexcept(
        is_nothrow_constructible_v<_It, const _OIter&> && is_nothrow_constructible_v<_Se, const _OSe&>)
        : _Contains{_That._Contains} {
        
        switch (_That._Contains) {
        case _Variantish_state::_Holds_iter:
            _Construct_in_place(_Iterator, _That._Iterator);
            break;
        case _Variantish_state::_Holds_sentinel:
            _Construct_in_place(_Sentinel, _That._Sentinel);
            break;
        case _Variantish_state::_Nothing:
            break;
        }
    }

    
    constexpr _Variantish(const _Variantish&) requires is_trivially_copy_constructible_v<_It>
        && is_trivially_copy_constructible_v<_Se> = default;
    

    constexpr _Variantish(const _Variantish& _That) noexcept(
        is_nothrow_copy_constructible_v<_It>&& is_nothrow_copy_constructible_v<_Se>)
        : _Contains{_That._Contains} {
        switch (_Contains) {
        case _Variantish_state::_Holds_iter:
            _Construct_in_place(_Iterator, _That._Iterator);
            break;
        case _Variantish_state::_Holds_sentinel:
            _Construct_in_place(_Sentinel, _That._Sentinel);
            break;
        case _Variantish_state::_Nothing:
            break;
        }
    }

    
    constexpr _Variantish(_Variantish&&) requires is_trivially_move_constructible_v<_It>
        && is_trivially_move_constructible_v<_Se> = default;
    

    constexpr _Variantish(_Variantish&& _That) noexcept(
        is_nothrow_move_constructible_v<_It>&& is_nothrow_move_constructible_v<_Se>)
        : _Contains{_That._Contains} {
        switch (_Contains) {
        case _Variantish_state::_Holds_iter:
            _Construct_in_place(_Iterator, ::std:: move(_That._Iterator));
            break;
        case _Variantish_state::_Holds_sentinel:
            _Construct_in_place(_Sentinel, ::std:: move(_That._Sentinel));
            break;
        case _Variantish_state::_Nothing:
            break;
        }
    }

    
    constexpr ~_Variantish() requires is_trivially_destructible_v<_It> && is_trivially_destructible_v<_Se> = default;
    

    constexpr ~_Variantish() {
        _Raw_clear();
    }

    
    constexpr _Variantish& operator=(const _Variantish&) requires is_trivially_destructible_v<_It>
        && is_trivially_destructible_v<_Se>
        && is_trivially_copy_constructible_v<_It>
        && is_trivially_copy_constructible_v<_Se>
        && is_trivially_copy_assignable_v<_It>
        && is_trivially_copy_assignable_v<_Se> = default;
    

    constexpr _Variantish& operator=(const _Variantish& _That) noexcept(
        is_nothrow_copy_constructible_v<_It>&& is_nothrow_copy_constructible_v<_Se>&&
            is_nothrow_copy_assignable_v<_It>&& is_nothrow_copy_assignable_v<_Se>) {
        if (_Contains == _That._Contains) {
            switch (_Contains) {
            case _Variantish_state::_Holds_iter:
                _Iterator = _That._Iterator;
                break;
            case _Variantish_state::_Holds_sentinel:
                _Sentinel = _That._Sentinel;
                break;
            case _Variantish_state::_Nothing:
                break;
            }

            return *this;
        }

        _Clear();

        switch (_That._Contains) {
        case _Variantish_state::_Holds_iter:
            _Construct_in_place(_Iterator, _That._Iterator);
            break;
        case _Variantish_state::_Holds_sentinel:
            _Construct_in_place(_Sentinel, _That._Sentinel);
            break;
        case _Variantish_state::_Nothing:
            break;
        }

        _Contains = _That._Contains;

        return *this;
    }

    
    constexpr _Variantish& operator=(_Variantish&&) requires is_trivially_destructible_v<_It>
        && is_trivially_destructible_v<_Se>
        && is_trivially_move_constructible_v<_It>
        && is_trivially_move_constructible_v<_Se>
        && is_trivially_move_assignable_v<_It>
        && is_trivially_move_assignable_v<_Se> = default;
    

    constexpr _Variantish& operator=(_Variantish&& _That) noexcept(
        is_nothrow_move_constructible_v<_It>&& is_nothrow_move_constructible_v<_Se>&&
            is_nothrow_move_assignable_v<_It>&& is_nothrow_move_assignable_v<_Se>) {
        if (_Contains == _That._Contains) {
            switch (_Contains) {
            case _Variantish_state::_Holds_iter:
                _Iterator = ::std:: move(_That._Iterator);
                break;
            case _Variantish_state::_Holds_sentinel:
                _Sentinel = ::std:: move(_That._Sentinel);
                break;
            case _Variantish_state::_Nothing:
                break;
            }

            return *this;
        }

        _Clear();

        switch (_That._Contains) {
        case _Variantish_state::_Holds_iter:
            _Construct_in_place(_Iterator, ::std:: move(_That._Iterator));
            break;
        case _Variantish_state::_Holds_sentinel:
            _Construct_in_place(_Sentinel, ::std:: move(_That._Sentinel));
            break;
        case _Variantish_state::_Nothing:
            break;
        }

        _Contains = _That._Contains;

        return *this;
    }

    
    template <class _OIter, class _OSe>
        requires _Not_same_as<_Variantish<_OIter, _OSe>, _Variantish>
    constexpr _Variantish& operator=(const _Variantish<_OIter, _OSe>& _That) noexcept(
        is_nothrow_constructible_v<_It, const _OIter&> && is_nothrow_constructible_v<_Se, const _OSe&>
            && is_nothrow_assignable_v<_It&, const _OIter&> && is_nothrow_assignable_v<_Se&, const _OSe&>) {
        
        if (_Contains == _That._Contains) {
            switch (_Contains) {
            case _Variantish_state::_Holds_iter:
                _Iterator = _That._Iterator;
                break;
            case _Variantish_state::_Holds_sentinel:
                _Sentinel = _That._Sentinel;
                break;
            case _Variantish_state::_Nothing:
                break;
            }

            return *this;
        }

        _Clear();

        switch (_That._Contains) {
        case _Variantish_state::_Holds_iter:
            _Construct_in_place(_Iterator, _That._Iterator);
            break;
        case _Variantish_state::_Holds_sentinel:
            _Construct_in_place(_Sentinel, _That._Sentinel);
            break;
        case _Variantish_state::_Nothing:
            break;
        }

        _Contains = _That._Contains;

        return *this;
    }

    
    friend constexpr void swap(_Variantish& _Left, _Variantish& _Right) noexcept(
        is_nothrow_move_constructible_v<_It> && is_nothrow_move_constructible_v<_Se>
            && is_nothrow_swappable_v<_It> && is_nothrow_swappable_v<_Se>)
        requires (!_Is_trivially_swappable_v<_It> || !_Is_trivially_swappable_v<_Se>) {
        
        if (_Left._Contains == _Right._Contains) {
            switch (_Left._Contains) {
            case _Variantish_state::_Holds_iter:
                ::std::ranges:: swap(_Left._Iterator, _Right._Iterator);
                break;
            case _Variantish_state::_Holds_sentinel:
                ::std::ranges:: swap(_Left._Sentinel, _Right._Sentinel);
                break;
            case _Variantish_state::_Nothing:
                break;
            }

            return;
        }

        auto _Tmp = ::std:: move(_Left);
        _Left     = ::std:: move(_Right);
        _Right    = ::std:: move(_Tmp);
    }

    constexpr void _Raw_clear() noexcept {
        switch (_Contains) {
        case _Variantish_state::_Holds_iter:
            _Iterator.~_It();
            break;
        case _Variantish_state::_Holds_sentinel:
            _Sentinel.~_Se();
            break;
        case _Variantish_state::_Nothing:
            break;
        }
    }

    constexpr void _Clear() noexcept {
        _Raw_clear();
        _Contains = _Variantish_state::_Nothing;
    }

    union {
        _It _Iterator;
        _Se _Sentinel;
    };

    _Variantish_state _Contains;
};


template <class _Iter>
concept _Use_postfix_proxy = !requires(_Iter& __it) { { *__it++ } -> _Can_reference; }
    && indirectly_readable<_Iter>
    && constructible_from<iter_value_t<_Iter>, iter_reference_t<_Iter>>
    && move_constructible<iter_value_t<_Iter>>;

template <input_or_output_iterator _Iter, sentinel_for<_Iter> _Se>
    requires (!same_as<_Iter, _Se> && copyable<_Iter>)
class common_iterator {
    
private:
    struct _Proxy_base {
        iter_value_t<_Iter> _Keep;

        constexpr explicit _Proxy_base(iter_reference_t<_Iter>&& _Right) noexcept(
            is_nothrow_constructible_v<iter_value_t<_Iter>, iter_reference_t<_Iter>>) 
            : _Keep(::std:: forward<iter_reference_t<_Iter>>(_Right)) {}
    };

public:
    
    constexpr common_iterator() requires default_initializable<_Iter> = default;
    

    constexpr common_iterator(_Iter _Right) noexcept(is_nothrow_move_constructible_v<_Iter>) 
        : _Val{in_place_type<_Iter>, ::std:: move(_Right)} {}

    constexpr common_iterator(_Se _Right) noexcept(is_nothrow_move_constructible_v<_Se>) 
        : _Val{in_place_type<_Se>, ::std:: move(_Right)} {}

    constexpr explicit common_iterator(_Common_iterator_construct_tag _Tag) noexcept : _Val{_Tag} {}

    
    template <class _OIter, class _OSe>
        requires convertible_to<const _OIter&, _Iter> && convertible_to<const _OSe&, _Se>
    constexpr common_iterator(const common_iterator<_OIter, _OSe>& _Right) noexcept(
        is_nothrow_constructible_v<_Iter, const _OIter&>&& is_nothrow_constructible_v<_Se, const _OSe&>) 
        : _Val{_Right._Get_val()} {}

    template <class _OIter, class _OSe>
        requires convertible_to<const _OIter&, _Iter> && convertible_to<const _OSe&, _Se>
            && assignable_from<_Iter&, const _OIter&> && assignable_from<_Se&, const _OSe&>
    constexpr common_iterator& operator=(const common_iterator<_OIter, _OSe>& _Right) noexcept(
        is_nothrow_constructible_v<_Iter, const _OIter&> && is_nothrow_constructible_v<_Se, const _OSe&>
            && is_nothrow_assignable_v<_Iter&, const _OIter&>
            && is_nothrow_assignable_v<_Se&, const _OSe&>)  {
        
        _Val = _Right._Get_val();
        return *this;
    }

    [[nodiscard]] constexpr decltype(auto) operator*() {


#line 868 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
        return *_Val._Iterator;
    }

    [[nodiscard]] constexpr decltype(auto) operator*() const requires _Dereferenceable<const _Iter> {


#line 876 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
        return *_Val._Iterator;
    }

    
    [[nodiscard]] constexpr decltype(auto) operator->() const
        requires indirectly_readable<const _Iter>
            && (_Has_member_arrow<const _Iter&> || is_reference_v<iter_reference_t<_Iter>>
                || constructible_from<iter_value_t<_Iter>, iter_reference_t<_Iter>>) {
        

#line 889 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
        if constexpr (_Has_member_arrow<const _Iter&> || is_pointer_v<_Iter>) {
            return (_Val._Iterator); 
        } else if constexpr (is_reference_v<iter_reference_t<_Iter>>) {
            auto&& _Tmp = *_Val._Iterator;
            return ::std:: addressof(_Tmp);
        } else {
            class _Arrow_proxy : private _Proxy_base {
            public:
                friend common_iterator;

                using _Proxy_base::_Proxy_base;

                [[nodiscard]] constexpr const iter_value_t<_Iter>* operator->() const noexcept {
                    return ::std:: addressof(this->_Keep);
                }
            };

            return _Arrow_proxy{*_Val._Iterator};
        }
    }

    constexpr common_iterator& operator++() {


#line 915 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
        ++_Val._Iterator;
        return *this;
    }

    constexpr decltype(auto) operator++(int) {


#line 924 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
        if constexpr (forward_iterator<_Iter>) {
            common_iterator _Tmp = *this;
            ++_Val._Iterator;
            return _Tmp;
        } else if constexpr (_Use_postfix_proxy<_Iter>) {
            class _Postfix_proxy : private _Proxy_base {
            public:
                friend common_iterator;

                using _Proxy_base::_Proxy_base;

                [[nodiscard]] constexpr const iter_value_t<_Iter>& operator*() const noexcept {
                    return this->_Keep;
                }
            };

            _Postfix_proxy _Tmp{*_Val._Iterator};
            ++_Val._Iterator;
            return _Tmp;
        } else {
            return _Val._Iterator++;
        }
    }

    
    template <class _OIter, sentinel_for<_Iter> _OSe>
        requires sentinel_for<_Se, _OIter>
    [[nodiscard]] friend constexpr
    bool operator==(const common_iterator& _Left, const common_iterator<_OIter, _OSe>& _Right) {
        
        auto& _Right_val = _Right._Get_val();


#line 960 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"

        if (_Left._Val._Contains == _Variantish_state::_Holds_iter) {
            if (_Right_val._Contains == _Variantish_state::_Holds_iter) {
                if constexpr (equality_comparable_with<_Iter, _OIter>) {
                    return _Left._Val._Iterator == _Right_val._Iterator;
                } else {
                    return true;
                }
            } else {
                return _Left._Val._Iterator == _Right_val._Sentinel;
            }
        } else {
            if (_Right_val._Contains == _Variantish_state::_Holds_iter) {
                return _Left._Val._Sentinel == _Right_val._Iterator;
            } else {
                return true;
            }
        }
    }

    
    template <sized_sentinel_for<_Iter> _OIter, sized_sentinel_for<_Iter> _OSe>
        requires sized_sentinel_for<_Se, _OIter>
    [[nodiscard]] friend constexpr iter_difference_t<_OIter> operator-(
        const common_iterator& _Left, const common_iterator<_OIter, _OSe>& _Right) {
        
        auto& _Right_val = _Right._Get_val();


#line 992 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"

        if (_Left._Val._Contains == _Variantish_state::_Holds_iter) {
            if (_Right_val._Contains == _Variantish_state::_Holds_iter) {
                return _Left._Val._Iterator - _Right_val._Iterator;
            } else {
                return _Left._Val._Iterator - _Right_val._Sentinel;
            }
        } else {
            if (_Right_val._Contains == _Variantish_state::_Holds_iter) {
                return _Left._Val._Sentinel - _Right_val._Iterator;
            } else {
                return 0;
            }
        }
    }

    [[nodiscard]] friend constexpr iter_rvalue_reference_t<_Iter> iter_move(const common_iterator& _Right) noexcept(
        noexcept(::std::ranges:: iter_move(_Right._Val._Iterator))) requires input_iterator<_Iter> {


#line 1014 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
        return ::std::ranges:: iter_move(_Right._Val._Iterator);
    }

    template <indirectly_swappable<_Iter> _OIter, class _OSe>
    friend constexpr void iter_swap(const common_iterator& _Left, const common_iterator<_OIter, _OSe>& _Right) noexcept(
        noexcept(::std::ranges:: iter_swap(_Left._Val._Iterator, _Right._Get_val()._Iterator))) {
        auto& _Right_val = _Right._Get_val();


#line 1026 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
        return ::std::ranges:: iter_swap(_Left._Val._Iterator, _Right_val._Iterator);
    }

    [[nodiscard]] constexpr _Variantish<_Iter, _Se>& _Get_val() noexcept {
        return _Val;
    }
    [[nodiscard]] constexpr const _Variantish<_Iter, _Se>& _Get_val() const noexcept {
        return _Val;
    }

private:
    _Variantish<_Iter, _Se> _Val;
};

template <class _Iter, class _Se>
struct incrementable_traits<common_iterator<_Iter, _Se>> {
    using difference_type = iter_difference_t<_Iter>;
};

template <class, class>
struct _Common_iterator_pointer_type {
    using pointer = void;
};


template <class _Iter, class _Se>
    requires _Has_member_arrow<const common_iterator<_Iter, _Se>&>
struct _Common_iterator_pointer_type<_Iter, _Se> {
    
    using pointer = decltype(::std:: declval<const common_iterator<_Iter, _Se>&>().operator->());
};

template <class _Iter>
concept _Has_forward_category = requires {
    typename _Iter_cat_t<_Iter>;
    requires derived_from<_Iter_cat_t<_Iter>, forward_iterator_tag>;
};

template <input_iterator _Iter, class _Se>
struct iterator_traits<common_iterator<_Iter, _Se>> {
    using iterator_concept  = conditional_t<forward_iterator<_Iter>, forward_iterator_tag, input_iterator_tag>;
    using iterator_category = conditional_t<_Has_forward_category<_Iter>, forward_iterator_tag, input_iterator_tag>;
    using value_type        = iter_value_t<_Iter>;
    using difference_type   = iter_difference_t<_Iter>;
    using pointer           = typename _Common_iterator_pointer_type<_Iter, _Se>::pointer;
    using reference         = iter_reference_t<_Iter>;
};

template <class _Iter>
struct _Counted_iterator_value_type_base {};

template <indirectly_readable _Iter>
struct _Counted_iterator_value_type_base<_Iter> {
    using value_type = iter_value_t<_Iter>;
};

template <class _Iter>
struct _Counted_iterator_category_base : _Counted_iterator_value_type_base<_Iter> {};

template <_Has_member_iterator_category _Iter>
struct _Counted_iterator_category_base<_Iter> : _Counted_iterator_value_type_base<_Iter> {
    using iterator_category = typename _Iter::iterator_category;
};

template <class _Iter>
struct _Counted_iterator_concept_base : _Counted_iterator_category_base<_Iter> {};

template <_Has_member_iterator_concept _Iter>
struct _Counted_iterator_concept_base<_Iter> : _Counted_iterator_category_base<_Iter> {
    using iterator_concept = typename _Iter::iterator_concept;
};

template <input_or_output_iterator _Iter>
class counted_iterator : public _Counted_iterator_concept_base<_Iter> {
public:
    using iterator_type   = _Iter;
    using difference_type = iter_difference_t<_Iter>;

    
    constexpr counted_iterator() requires default_initializable<_Iter> = default;
    

    constexpr counted_iterator(_Iter _Right, const iter_difference_t<_Iter> _Diff) noexcept(
        is_nothrow_move_constructible_v<_Iter>) 
        : _Current(::std:: move(_Right)), _Length(_Diff) {


#line 1115 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
    }

    
    template <class _Other>
        requires convertible_to<const _Other&, _Iter>
    constexpr counted_iterator(const counted_iterator<_Other>& _Right) noexcept(
        is_nothrow_constructible_v<_Iter, const _Other&>) 
        : _Current(_Right.base()), _Length(_Right.count()) {}

    template <class _Other>
        requires assignable_from<_Iter&, const _Other&>
    constexpr counted_iterator& operator=(const counted_iterator<_Other>& _Right) noexcept(
        is_nothrow_assignable_v<_Iter&, const _Other&>)  {
        
        _Current = _Right.base();
        _Length  = _Right.count();
        return *this;
    }

    
    [[nodiscard]] constexpr const _Iter& base() const& noexcept {
        return _Current;
    }

    [[nodiscard]] constexpr _Iter base() && noexcept(is_nothrow_move_constructible_v<_Iter>)  {
        return ::std:: move(_Current);
    }

    [[nodiscard]] constexpr iter_difference_t<_Iter> count() const noexcept {
        return _Length;
    }

    
    [[nodiscard]] constexpr decltype(auto) operator*() noexcept(noexcept(*_Current))  {


#line 1152 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
        return *_Current;
    }

    [[nodiscard]] constexpr decltype(auto) operator*() const noexcept(noexcept(*_Current)) 
        requires _Dereferenceable<const _Iter> {


#line 1160 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
        return *_Current;
    }

    [[nodiscard]] constexpr auto operator->() const noexcept requires contiguous_iterator<_Iter> {
        return ::std:: to_address(_Current);
    }

    [[nodiscard]] constexpr decltype(auto) operator[](
        const iter_difference_t<_Iter> _Diff) const requires random_access_iterator<_Iter> {


#line 1172 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
        return _Current[_Diff];
    }

    
    constexpr counted_iterator& operator++() {


#line 1180 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
        ++_Current;
        --_Length;
        return *this;
    }

    constexpr decltype(auto) operator++(int) {


#line 1189 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
        --_Length;
        try {
        return _Current++;

        } catch (...) {
        ++_Length;

        throw;
        }
    }

    constexpr counted_iterator operator++(int) requires forward_iterator<_Iter> {


#line 1204 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
        counted_iterator _Tmp = *this;
        ++_Current;
        --_Length;
        return _Tmp;
    }

    constexpr counted_iterator& operator--() requires bidirectional_iterator<_Iter> {
        --_Current;
        ++_Length;
        return *this;
    }

    constexpr counted_iterator operator--(int) requires bidirectional_iterator<_Iter> {
        counted_iterator _Tmp = *this;
        --_Current;
        ++_Length;
        return _Tmp;
    }

    [[nodiscard]] constexpr counted_iterator operator+(
        const iter_difference_t<_Iter> _Diff) const requires random_access_iterator<_Iter> {
        return counted_iterator{_Current + _Diff, static_cast<iter_difference_t<_Iter>>(_Length - _Diff)};
    }

    [[nodiscard]] friend constexpr counted_iterator operator+(
        const iter_difference_t<_Iter> _Diff, const counted_iterator& _Right) requires random_access_iterator<_Iter> {
        return counted_iterator{_Right._Current + _Diff, static_cast<iter_difference_t<_Iter>>(_Right._Length - _Diff)};
    }

    constexpr counted_iterator& operator+=(
        const iter_difference_t<_Iter> _Diff) requires random_access_iterator<_Iter> {


#line 1238 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
        _Current += _Diff;
        _Length -= _Diff;
        return *this;
    }

    [[nodiscard]] constexpr counted_iterator operator-(
        const iter_difference_t<_Iter> _Diff) const requires random_access_iterator<_Iter> {
        return counted_iterator{_Current - _Diff, static_cast<iter_difference_t<_Iter>>(_Length + _Diff)};
    }

    template <common_with<_Iter> _Other>
    [[nodiscard]] friend constexpr iter_difference_t<_Other> operator-(
        const counted_iterator& _Left, const counted_iterator<_Other>& _Right) noexcept  {


#line 1254 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
        return _Right.count() - _Left._Length;
    }

    [[nodiscard]] friend constexpr iter_difference_t<_Iter> operator-(
        const counted_iterator& _Left, default_sentinel_t) noexcept  {
        return -_Left._Length;
    }

    [[nodiscard]] friend constexpr iter_difference_t<_Iter> operator-(
        default_sentinel_t, const counted_iterator& _Right) noexcept  {
        return _Right._Length;
    }

    constexpr counted_iterator& operator-=(
        const iter_difference_t<_Iter> _Diff) requires random_access_iterator<_Iter> {


#line 1272 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
        _Current -= _Diff;
        _Length += _Diff;
        return *this;
    }

    
    template <common_with<_Iter> _Other>
    [[nodiscard]] friend constexpr bool operator==(
        const counted_iterator& _Left, const counted_iterator<_Other>& _Right) noexcept  {


#line 1284 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
        return _Left._Length == _Right.count();
    }

    [[nodiscard]] friend constexpr bool operator==(const counted_iterator& _Left, default_sentinel_t) noexcept
     {
        return _Left._Length == 0;
    }

    template <common_with<_Iter> _Other>
    [[nodiscard]] friend constexpr strong_ordering operator<=>(
        const counted_iterator& _Left, const counted_iterator<_Other>& _Right) noexcept  {


#line 1298 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
        return _Right.count() <=> _Left._Length;
    }

    
    [[nodiscard]] friend constexpr iter_rvalue_reference_t<_Iter> iter_move(const counted_iterator& _Right) noexcept(
        noexcept(::std::ranges:: iter_move(_Right._Current))) requires input_iterator<_Iter> {
        return ::std::ranges:: iter_move(_Right._Current);
    }

    template <indirectly_swappable<_Iter> _Other>
    friend constexpr void iter_swap(const counted_iterator& _Left, const counted_iterator<_Other>& _Right) noexcept(
        noexcept(::std::ranges:: iter_swap(_Left._Current, _Right.base()))) {
        ::std::ranges:: iter_swap(_Left._Current, _Right.base());
    }

    template <common_with<_Iter> _Other>
    friend constexpr void _Same_sequence(
        const counted_iterator& _Left, const counted_iterator<_Other>& _Right) noexcept {
        
        
        if constexpr (forward_iterator<_Iter> && forward_iterator<_Other>) {
            using _CIter = common_type_t<_Iter, _Other>;
            using _CDiff = common_type_t<iter_difference_t<_Iter>, iter_difference_t<_Other>>;

            const _CDiff _Diff = static_cast<_CDiff>(_Left._Length) - static_cast<_CDiff>(_Right.count());
            if (_Diff < 0) {
                do { if (static_cast<_CIter>(_Left._Current) == ::std::ranges:: next(static_cast<_CIter>(_Right.base()), -_Diff)) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 1329 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
            } else {
                do { if (::std::ranges:: next(static_cast<_CIter>(_Left._Current), _Diff) == static_cast<_CIter>(_Right.base())) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 1333 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
            }
        }
    }

    template <common_with<_Iter> _Other>
    friend constexpr void _Verify_range(const counted_iterator& _Left, const counted_iterator<_Other>& _Right) {
        if constexpr (_Range_verifiable_v<_Iter, _Other>) {
            _Verify_range(_Left._Current, _Right.base());
        }


#line 1345 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
    }

    constexpr void _Verify_offset(const iter_difference_t<_Iter> _Off) const {


#line 1351 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
        if constexpr (_Offset_verifiable_v<_Iter>) {
            _Current._Verify_offset(_Off);
        }
    }

    using _Prevent_inheriting_unwrap = counted_iterator;

    [[nodiscard]] constexpr counted_iterator<_Unwrapped_t<const _Iter&>>
        _Unwrapped() const& requires _Unwrappable_v<const _Iter&> {
        return counted_iterator<_Unwrapped_t<const _Iter&>>{_Current._Unwrapped(), _Length};
    }

    [[nodiscard]] constexpr counted_iterator<_Unwrapped_t<_Iter>> _Unwrapped() && requires _Unwrappable_v<_Iter> {
        return counted_iterator<_Unwrapped_t<_Iter>>{::std:: move(_Current)._Unwrapped(), _Length};
    }

    static constexpr bool _Unwrap_when_unverified = _Do_unwrap_when_unverified_v<_Iter>;

    
    template <class _Other>
        requires _Wrapped_seekable_v<_Iter, const _Other&>
    constexpr void _Seek_to(const counted_iterator<_Other>& _It) {
        
        _Current._Seek_to(_It.base());
        _Length = _It.count();
    }

    
    template <class _Other>
        requires _Wrapped_seekable_v<_Iter, _Other>
    constexpr void _Seek_to(counted_iterator<_Other>&& _It) {
        
        _Current._Seek_to(::std:: move(_It).base());
        _Length = _It.count();
    }

private:
    _Iter _Current{};
    iter_difference_t<_Iter> _Length = 0;
};


template <input_iterator _Iter>
    requires (!_Is_from_primary<iterator_traits<_Iter>>)
struct iterator_traits<counted_iterator<_Iter>> : iterator_traits<_Iter> {
    
    using pointer = conditional_t<contiguous_iterator<_Iter>, add_pointer_t<iter_reference_t<_Iter>>, void>;
};
#line 1400 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"

}

namespace stdext {
using ::std:: iterator_traits;
using ::std:: size_t;

template <class _Ptr>
class checked_array_iterator { 
    static_assert(::std:: is_pointer_v<_Ptr>, "checked_array_iterator requires pointers");

public:
    using iterator_category = typename iterator_traits<_Ptr>::iterator_category;
    using value_type        = typename iterator_traits<_Ptr>::value_type;
    using difference_type   = typename iterator_traits<_Ptr>::difference_type;
    using pointer           = typename iterator_traits<_Ptr>::pointer;
    using reference         = typename iterator_traits<_Ptr>::reference;

    constexpr checked_array_iterator() noexcept : _Myarray(nullptr), _Mysize(0), _Myindex(0) {}

    constexpr checked_array_iterator(const _Ptr _Array, const size_t _Size, const size_t _Index = 0) noexcept
        : _Myarray(_Array), _Mysize(_Size), _Myindex(_Index) {
        do { if (_Index <= _Size) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
    }

    [[nodiscard]] constexpr _Ptr base() const noexcept {
        return _Myarray + _Myindex;
    }

    [[nodiscard]] constexpr reference operator*() const noexcept {
        return *operator->();
    }

    [[nodiscard]] constexpr pointer operator->() const noexcept {
        do { if (_Myarray) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
        do { if (_Myindex < _Mysize) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
        return _Myarray + _Myindex;
    }

    constexpr checked_array_iterator& operator++() noexcept {
        do { if (_Myarray) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
        do { if (_Myindex < _Mysize) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
        ++_Myindex;
        return *this;
    }

    constexpr checked_array_iterator operator++(int) noexcept {
        checked_array_iterator _Tmp = *this;
        ++*this;
        return _Tmp;
    }

    constexpr checked_array_iterator& operator--() noexcept {
        do { if (_Myarray) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
        do { if (_Myindex != 0) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
        --_Myindex;
        return *this;
    }

    constexpr checked_array_iterator operator--(int) noexcept {
        checked_array_iterator _Tmp = *this;
        --*this;
        return _Tmp;
    }

    constexpr checked_array_iterator& operator+=(const difference_type _Off) noexcept {
        if (_Off != 0) {
            do { if (_Myarray) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
        }

        if (_Off < 0) {
            do { if (_Myindex >= size_t{0} - static_cast<size_t>(_Off)) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 1473 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
        }

        if (_Off > 0) {
            do { if (_Mysize - _Myindex >= static_cast<size_t>(_Off)) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 1478 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
        }

        _Myindex += _Off;
        return *this;
    }

    [[nodiscard]] constexpr checked_array_iterator operator+(const difference_type _Off) const noexcept {
        checked_array_iterator _Tmp = *this;
        _Tmp += _Off;
        return _Tmp;
    }

    [[nodiscard]] friend constexpr checked_array_iterator operator+(
        const difference_type _Off, const checked_array_iterator<_Ptr>& _Next) noexcept {
        return _Next + _Off;
    }

    constexpr checked_array_iterator& operator-=(const difference_type _Off) noexcept {
        if (_Off != 0) {
            do { if (_Myarray) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
        }

        if (_Off > 0) {
            do { if (_Myindex >= static_cast<size_t>(_Off)) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
        }

        if (_Off < 0) {
            do { if (_Mysize - _Myindex >= size_t{0} - static_cast<size_t>(_Off)) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 1507 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
        }

        _Myindex -= _Off;
        return *this;
    }

    [[nodiscard]] constexpr checked_array_iterator operator-(const difference_type _Off) const noexcept {
        checked_array_iterator _Tmp = *this;
        _Tmp -= _Off;
        return _Tmp;
    }

    [[nodiscard]] constexpr difference_type operator-(const checked_array_iterator& _Right) const noexcept {
        do { if (_Myarray == _Right._Myarray && _Mysize == _Right._Mysize) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 1522 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
        return static_cast<difference_type>(_Myindex - _Right._Myindex);
    }

    [[nodiscard]] constexpr reference operator[](const difference_type _Off) const noexcept {
        return *(*this + _Off);
    }

    [[nodiscard]] constexpr bool operator==(const checked_array_iterator& _Right) const noexcept {
        do { if (_Myarray == _Right._Myarray && _Mysize == _Right._Mysize) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 1532 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
        return _Myindex == _Right._Myindex;
    }


    [[nodiscard]] constexpr ::std:: strong_ordering operator<=>(const checked_array_iterator& _Right) const noexcept {
        do { if (_Myarray == _Right._Myarray && _Mysize == _Right._Mysize) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 1539 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
        return _Myindex <=> _Right._Myindex;
    }


#line 1564 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"

    friend constexpr void _Verify_range(
        const checked_array_iterator& _First, const checked_array_iterator& _Last) noexcept {
        do { if (_First._Myarray == _Last._Myarray && _First._Mysize == _Last._Mysize) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 1569 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
        do { if (_First._Myindex <= _Last._Myindex) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
    }

    constexpr void _Verify_offset(const difference_type _Off) const noexcept {
        if (_Off < 0) {
            do { if (_Myindex >= size_t{0} - static_cast<size_t>(_Off)) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 1576 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
        }

        if (_Off > 0) {
            do { if (_Mysize - _Myindex >= static_cast<size_t>(_Off)) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 1581 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
        }
    }

    using _Prevent_inheriting_unwrap = checked_array_iterator;

    [[nodiscard]] constexpr _Ptr _Unwrapped() const noexcept {
        return _Myarray + _Myindex;
    }

    constexpr void _Seek_to(_Ptr _It) noexcept {
        _Myindex = static_cast<size_t>(_It - _Myarray);
    }

private:
    _Ptr _Myarray; 
    size_t _Mysize; 
    size_t _Myindex; 
};

template <class _Ptr>
[[nodiscard]] constexpr checked_array_iterator<_Ptr> make_checked_array_iterator(
    const _Ptr _Array, const size_t _Size, const size_t _Index = 0) {
    return checked_array_iterator<_Ptr>(_Array, _Size, _Index);
}

template <class _Ptr>
class unchecked_array_iterator { 
    static_assert(::std:: is_pointer_v<_Ptr>, "unchecked_array_iterator requires pointers");

public:
    using iterator_category = typename iterator_traits<_Ptr>::iterator_category;
    using value_type        = typename iterator_traits<_Ptr>::value_type;
    using difference_type   = typename iterator_traits<_Ptr>::difference_type;
    using pointer           = typename iterator_traits<_Ptr>::pointer;
    using reference         = typename iterator_traits<_Ptr>::reference;

    constexpr unchecked_array_iterator() noexcept : _Myptr(nullptr) {}

    constexpr explicit unchecked_array_iterator(const _Ptr _Src) noexcept : _Myptr(_Src) {}

    [[nodiscard]] constexpr _Ptr base() const noexcept {
        return _Myptr;
    }

    [[nodiscard]] constexpr reference operator*() const noexcept {
        return *_Myptr;
    }

    [[nodiscard]] constexpr pointer operator->() const noexcept {
        return _Myptr;
    }

    constexpr unchecked_array_iterator& operator++() noexcept {
        ++_Myptr;
        return *this;
    }

    constexpr unchecked_array_iterator operator++(int) noexcept {
        unchecked_array_iterator _Tmp = *this;
        ++_Myptr;
        return _Tmp;
    }

    constexpr unchecked_array_iterator& operator--() noexcept {
        --_Myptr;
        return *this;
    }

    constexpr unchecked_array_iterator operator--(int) noexcept {
        unchecked_array_iterator _Tmp = *this;
        --_Myptr;
        return _Tmp;
    }

    constexpr unchecked_array_iterator& operator+=(const difference_type _Off) noexcept {
        _Myptr += _Off;
        return *this;
    }

    [[nodiscard]] constexpr unchecked_array_iterator operator+(const difference_type _Off) const noexcept {
        unchecked_array_iterator _Tmp = *this;
        _Tmp += _Off;
        return _Tmp;
    }

    [[nodiscard]] friend constexpr unchecked_array_iterator operator+(
        const difference_type _Off, const unchecked_array_iterator& _Next) noexcept {
        return _Next + _Off;
    }

    constexpr unchecked_array_iterator& operator-=(const difference_type _Off) noexcept {
        return *this += -_Off;
    }

    [[nodiscard]] constexpr unchecked_array_iterator operator-(const difference_type _Off) const noexcept {
        unchecked_array_iterator _Tmp = *this;
        _Tmp -= _Off;
        return _Tmp;
    }

    [[nodiscard]] constexpr difference_type operator-(const unchecked_array_iterator& _Right) const noexcept {
        return _Myptr - _Right._Myptr;
    }

    [[nodiscard]] constexpr reference operator[](const difference_type _Off) const noexcept {
        return *(*this + _Off);
    }

    [[nodiscard]] constexpr bool operator==(const unchecked_array_iterator& _Right) const noexcept {
        return _Myptr == _Right._Myptr;
    }


    [[nodiscard]] constexpr ::std:: strong_ordering operator<=>(const unchecked_array_iterator& _Right) const noexcept {
        return _Myptr <=> _Right._Myptr;
    }


#line 1718 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"


#line 1725 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"

    using _Prevent_inheriting_unwrap = unchecked_array_iterator;

    static constexpr bool _Unwrap_when_unverified = true;

    [[nodiscard]] constexpr _Ptr _Unwrapped() const noexcept {
        return _Myptr;
    }

    constexpr void _Seek_to(_Ptr _It) noexcept {
        _Myptr = _It;
    }

private:
    _Ptr _Myptr; 
};

template <class _Ptr>
[[nodiscard]] unchecked_array_iterator<_Ptr> make_unchecked_array_iterator(const _Ptr _It) noexcept {
    return unchecked_array_iterator<_Ptr>(_It);
}
}


#pragma warning(pop)
#pragma pack(pop)
#line 1753 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
#line 1754 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iterator"
#line 16 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocnum"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\streambuf"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xiosbase"


#pragma once


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\share.h"


#pragma once


#line 14 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\share.h"
#line 12 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xiosbase"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\system_error"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_system_error_abi.hpp"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


#line 25 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_system_error_abi.hpp"

extern "C" {
[[nodiscard]] size_t __stdcall __std_get_string_size_without_trailing_whitespace(
    const char* _Str, size_t _Size) noexcept;

[[nodiscard]] size_t __stdcall __std_system_error_allocate_message(
    unsigned long _Message_id, char** _Ptr_str) noexcept;
void __stdcall __std_system_error_deallocate_message(char* _Str) noexcept;
}


#pragma warning(pop)
#pragma pack(pop)

#line 41 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_system_error_abi.hpp"
#line 42 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_system_error_abi.hpp"
#line 12 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\system_error"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cerrno"


#pragma once


#line 15 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cerrno"
#line 16 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cerrno"
#line 13 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\system_error"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stdexcept"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
class logic_error : public exception { 
public:
    using _Mybase = exception;

    explicit logic_error(const string& _Message) : _Mybase(_Message.c_str()) {}

    explicit logic_error(const char* _Message) : _Mybase(_Message) {}


#line 35 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stdexcept"
};

class domain_error : public logic_error { 
public:
    using _Mybase = logic_error;

    explicit domain_error(const string& _Message) : _Mybase(_Message.c_str()) {}

    explicit domain_error(const char* _Message) : _Mybase(_Message) {}


#line 51 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stdexcept"
};

class invalid_argument : public logic_error { 
public:
    using _Mybase = logic_error;

    explicit invalid_argument(const string& _Message) : _Mybase(_Message.c_str()) {}

    explicit invalid_argument(const char* _Message) : _Mybase(_Message) {}


#line 67 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stdexcept"
};

class length_error : public logic_error { 
public:
    using _Mybase = logic_error;

    explicit length_error(const string& _Message) : _Mybase(_Message.c_str()) {}

    explicit length_error(const char* _Message) : _Mybase(_Message) {}


#line 83 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stdexcept"
};

class out_of_range : public logic_error { 
public:
    using _Mybase = logic_error;

    explicit out_of_range(const string& _Message) : _Mybase(_Message.c_str()) {}

    explicit out_of_range(const char* _Message) : _Mybase(_Message) {}


#line 99 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stdexcept"
};

class runtime_error : public exception { 
public:
    using _Mybase = exception;

    explicit runtime_error(const string& _Message) : _Mybase(_Message.c_str()) {}

    explicit runtime_error(const char* _Message) : _Mybase(_Message) {}


#line 115 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stdexcept"
};

class overflow_error : public runtime_error { 
public:
    using _Mybase = runtime_error;

    explicit overflow_error(const string& _Message) : _Mybase(_Message.c_str()) {}

    explicit overflow_error(const char* _Message) : _Mybase(_Message) {}


#line 131 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stdexcept"
};

class underflow_error : public runtime_error { 
public:
    using _Mybase = runtime_error;

    explicit underflow_error(const string& _Message) : _Mybase(_Message.c_str()) {}

    explicit underflow_error(const char* _Message) : _Mybase(_Message) {}


#line 147 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stdexcept"
};

class range_error : public runtime_error { 
public:
    using _Mybase = runtime_error;

    explicit range_error(const string& _Message) : _Mybase(_Message.c_str()) {}

    explicit range_error(const char* _Message) : _Mybase(_Message) {}


#line 163 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stdexcept"
};

[[noreturn]] inline void _Throw_range_error(const char* const _Message) {
    throw range_error{_Message};
}
}


#pragma warning(pop)
#pragma pack(pop)
#line 174 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stdexcept"
#line 175 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stdexcept"
#line 15 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\system_error"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcall_once.h"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
struct once_flag { 
    constexpr once_flag() noexcept : _Opaque(nullptr) {}

    once_flag(const once_flag&) = delete;
    once_flag& operator=(const once_flag&) = delete;

    void* _Opaque;
};

using _Execute_once_fp_t = int(__stdcall*)(void*, void*, void**);

 int __cdecl _Execute_once(
    once_flag& _Flag, _Execute_once_fp_t _Callback, void* _Pv) noexcept;

template <class _Ty>
union _Immortalizer_impl { 
    constexpr _Immortalizer_impl() noexcept : _Storage{} {}
    _Immortalizer_impl(const _Immortalizer_impl&) = delete;
    _Immortalizer_impl& operator=(const _Immortalizer_impl&) = delete;
    ~_Immortalizer_impl() {
        
    }

    _Ty _Storage;
};
}


#pragma warning(pop)
#pragma pack(pop)
#line 52 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcall_once.h"
#line 53 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcall_once.h"
#line 16 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\system_error"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xerrc.h"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
enum class errc { 
    address_family_not_supported       = 102, 
    address_in_use                     = 100, 
    address_not_available              = 101, 
    already_connected                  = 113, 
    argument_list_too_long             = 7, 
    argument_out_of_domain             = 33, 
    bad_address                        = 14, 
    bad_file_descriptor                = 9, 
    bad_message                        = 104, 
    broken_pipe                        = 32, 
    connection_aborted                 = 106, 
    connection_already_in_progress     = 103, 
    connection_refused                 = 107, 
    connection_reset                   = 108, 
    cross_device_link                  = 18, 
    destination_address_required       = 109, 
    device_or_resource_busy            = 16, 
    directory_not_empty                = 41, 
    executable_format_error            = 8, 
    file_exists                        = 17, 
    file_too_large                     = 27, 
    filename_too_long                  = 38, 
    function_not_supported             = 40, 
    host_unreachable                   = 110, 
    identifier_removed                 = 111, 
    illegal_byte_sequence              = 42, 
    inappropriate_io_control_operation = 25, 
    interrupted                        = 4, 
    invalid_argument                   = 22, 
    invalid_seek                       = 29, 
    io_error                           = 5, 
    is_a_directory                     = 21, 
    message_size                       = 115, 
    network_down                       = 116, 
    network_reset                      = 117, 
    network_unreachable                = 118, 
    no_buffer_space                    = 119, 
    no_child_process                   = 10, 
    no_link                            = 121, 
    no_lock_available                  = 39, 
    no_message_available               = 120, 
    no_message                         = 122, 
    no_protocol_option                 = 123, 
    no_space_on_device                 = 28, 
    no_stream_resources                = 124, 
    no_such_device_or_address          = 6, 
    no_such_device                     = 19, 
    no_such_file_or_directory          = 2, 
    no_such_process                    = 3, 
    not_a_directory                    = 20, 
    not_a_socket                       = 128, 
    not_a_stream                       = 125, 
    not_connected                      = 126, 
    not_enough_memory                  = 12, 
    not_supported                      = 129, 
    operation_canceled                 = 105, 
    operation_in_progress              = 112, 
    operation_not_permitted            = 1, 
    operation_not_supported            = 130, 
    operation_would_block              = 140, 
    owner_dead                         = 133, 
    permission_denied                  = 13, 
    protocol_error                     = 134, 
    protocol_not_supported             = 135, 
    read_only_file_system              = 30, 
    resource_deadlock_would_occur      = 36, 
    resource_unavailable_try_again     = 11, 
    result_out_of_range                = 34, 
    state_not_recoverable              = 127, 
    stream_timeout                     = 137, 
    text_file_busy                     = 139, 
    timed_out                          = 138, 
    too_many_files_open_in_system      = 23, 
    too_many_files_open                = 24, 
    too_many_links                     = 31, 
    too_many_symbolic_link_levels      = 114, 
    value_too_large                    = 132, 
    wrong_protocol_type                = 136 
};

}


#pragma warning(pop)
#pragma pack(pop)

#line 109 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xerrc.h"
#line 110 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xerrc.h"
#line 17 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\system_error"


#line 20 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\system_error"


#line 24 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\system_error"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
enum class io_errc { 
    stream = 1
};

template <class _Enum>
struct is_error_code_enum : false_type {};

template <>
struct is_error_code_enum<io_errc> : true_type {};

template <class _Ty>
inline constexpr bool is_error_code_enum_v = is_error_code_enum<_Ty>::value;

template <class _Enum>
struct is_error_condition_enum : false_type {};

template <>
struct is_error_condition_enum<errc> : true_type {};

template <class _Ty>
inline constexpr bool is_error_condition_enum_v = is_error_condition_enum<_Ty>::value;

class error_code;
class error_condition;
[[nodiscard]] error_code make_error_code(errc) noexcept;
[[nodiscard]] error_code make_error_code(io_errc) noexcept;
[[nodiscard]] error_condition make_error_condition(errc) noexcept;
[[nodiscard]] error_condition make_error_condition(io_errc) noexcept;

class error_category;

[[nodiscard]] const error_category& generic_category() noexcept;
[[nodiscard]] const error_category& iostream_category() noexcept;
[[nodiscard]] const error_category& system_category() noexcept;

class __declspec(novtable) error_category { 
public:
     error_category() noexcept { 
        _Addr = reinterpret_cast<uintptr_t>(this);
    }


    constexpr
#line 77 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\system_error"
        virtual ~error_category() noexcept = default;

    [[nodiscard]] virtual const char* name() const noexcept = 0;

    [[nodiscard]] virtual string message(int _Errval) const = 0;

    [[nodiscard]] virtual error_condition default_error_condition(int _Errval) const noexcept;

    [[nodiscard]] virtual bool equivalent(int _Errval, const error_condition& _Cond) const noexcept;

    [[nodiscard]] virtual bool equivalent(const error_code& _Code, int _Errval) const noexcept;

    [[nodiscard]] bool operator==(const error_category& _Right) const noexcept {
        return _Addr == _Right._Addr;
    }


#line 98 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\system_error"


    [[nodiscard]] strong_ordering operator<=>(const error_category& _Right) const noexcept {
        return compare_three_way{}(_Addr, _Right._Addr);
    }


#line 108 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\system_error"

    error_category(const error_category&) = delete;
    error_category& operator=(const error_category&) = delete;

protected:
    uintptr_t _Addr;

    constexpr explicit error_category(const uintptr_t _Addr_) noexcept : _Addr(_Addr_) {}

    enum : uintptr_t { 
        _Future_addr   = 1,
        _Generic_addr  = 3,
        _Iostream_addr = 5,
        _System_addr   = 7
    };
};


[[nodiscard]] inline bool _System_error_equal(const error_code&, const error_condition&) noexcept;
#line 128 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\system_error"

class error_code { 
public:
    error_code() noexcept : _Myval(0), _Mycat(&::std:: system_category()) {} 

    error_code(int _Val, const error_category& _Cat) noexcept : _Myval(_Val), _Mycat(&_Cat) {}

    template <class _Enum, enable_if_t<is_error_code_enum_v<_Enum>, int> = 0>
    error_code(_Enum _Errcode) noexcept : _Myval(0), _Mycat(nullptr) {
        *this = make_error_code(_Errcode); 
    }

    void assign(int _Val, const error_category& _Cat) noexcept {
        _Myval = _Val;
        _Mycat = &_Cat;
    }

    template <class _Enum, enable_if_t<is_error_code_enum_v<_Enum>, int> = 0>
    error_code& operator=(_Enum _Errcode) noexcept {
        *this = make_error_code(_Errcode); 
        return *this;
    }

    void clear() noexcept {
        _Myval = 0;
        _Mycat = &::std:: system_category();
    }

    [[nodiscard]] int value() const noexcept {
        return _Myval;
    }

    [[nodiscard]] const error_category& category() const noexcept {
        return *_Mycat;
    }

    [[nodiscard]] error_condition default_error_condition() const noexcept;

    [[nodiscard]] string message() const {
        return category().message(value());
    }

    explicit operator bool() const noexcept {
        return value() != 0;
    }


    [[nodiscard]] friend bool operator==(const error_code& _Left, const error_code& _Right) noexcept {
        return _Left.category() == _Right.category() && _Left.value() == _Right.value();
    }

    [[nodiscard]] friend bool operator==(const error_code& _Left, const error_condition& _Right) noexcept {
        return _System_error_equal(_Left, _Right);
    }


    [[nodiscard]] friend strong_ordering operator<=>(const error_code& _Left, const error_code& _Right) noexcept {
        if (const auto _Result = _Left.category() <=> _Right.category(); _Result != 0) {
            return _Result;
        }
        return _Left.value() <=> _Right.value();
    }


#line 196 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\system_error"


#line 213 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\system_error"
#line 214 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\system_error"

private:
    int _Myval; 
    const error_category* _Mycat; 
};

class error_condition { 
public:
    error_condition() noexcept : _Myval(0), _Mycat(&::std:: generic_category()) {} 

    error_condition(int _Val, const error_category& _Cat) noexcept : _Myval(_Val), _Mycat(&_Cat) {}

    template <class _Enum, enable_if_t<is_error_condition_enum_v<_Enum>, int> = 0>
    error_condition(_Enum _Errcode) noexcept : _Myval(0), _Mycat(nullptr) {
        *this = make_error_condition(_Errcode); 
    }

    void assign(int _Val, const error_category& _Cat) noexcept {
        _Myval = _Val;
        _Mycat = &_Cat;
    }

    template <class _Enum, enable_if_t<is_error_condition_enum_v<_Enum>, int> = 0>
    error_condition& operator=(_Enum _Errcode) noexcept {
        *this = make_error_condition(_Errcode); 
        return *this;
    }

    void clear() noexcept {
        _Myval = 0;
        _Mycat = &::std:: generic_category();
    }

    [[nodiscard]] int value() const noexcept {
        return _Myval;
    }

    [[nodiscard]] const error_category& category() const noexcept {
        return *_Mycat;
    }

    [[nodiscard]] string message() const {
        return category().message(value());
    }

    explicit operator bool() const noexcept {
        return value() != 0;
    }


    [[nodiscard]] friend bool operator==(const error_condition& _Left, const error_condition& _Right) noexcept {
        return _Left.category() == _Right.category() && _Left.value() == _Right.value();
    }


    [[nodiscard]] friend strong_ordering operator<=>(
        const error_condition& _Left, const error_condition& _Right) noexcept {
        if (const auto _Result = _Left.category() <=> _Right.category(); _Result != 0) {
            return _Result;
        }
        return _Left.value() <=> _Right.value();
    }


#line 282 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\system_error"


#line 287 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\system_error"

    
    friend bool operator==(const error_code& _Left, const error_condition& _Right) noexcept;


#line 297 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\system_error"
#line 298 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\system_error"

private:
    int _Myval; 
    const error_category* _Mycat; 
};


[[nodiscard]] inline bool _System_error_equal(const error_code& _Left, const error_condition& _Right) noexcept {
    return _Left.category().equivalent(_Left.value(), _Right) || _Right.category().equivalent(_Left, _Right.value());
}


#line 369 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\system_error"

[[nodiscard]] inline error_condition error_category::default_error_condition(int _Errval) const noexcept {
    
    return error_condition(_Errval, *this);
}

[[nodiscard]] inline bool error_category::equivalent(int _Errval, const error_condition& _Cond) const noexcept {
    return default_error_condition(_Errval) == _Cond;
}

[[nodiscard]] inline bool error_category::equivalent(const error_code& _Code, int _Errval) const noexcept {
    return *this == _Code.category() && _Code.value() == _Errval;
}

[[nodiscard]] inline error_condition error_code::default_error_condition() const noexcept {
    
    return category().default_error_condition(value());
}

[[nodiscard]] inline error_code make_error_code(errc _Errno) noexcept {
    return error_code(static_cast<int>(_Errno), ::std:: generic_category());
}

[[nodiscard]] inline error_code make_error_code(io_errc _Errno) noexcept {
    return error_code(static_cast<int>(_Errno), ::std:: iostream_category());
}

[[nodiscard]] inline error_condition make_error_condition(errc _Errno) noexcept {
    return error_condition(static_cast<int>(_Errno), ::std:: generic_category());
}

[[nodiscard]] inline error_condition make_error_condition(io_errc _Errno) noexcept {
    return error_condition(static_cast<int>(_Errno), ::std:: iostream_category());
}

template <>
struct hash<error_code> {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef error_code _Unnameable_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef size_t _Unnameable_result;

    [[nodiscard]] size_t operator()(const error_code& _Keyval) const noexcept {
        return hash<int>{}(_Keyval.value());
    }
};

template <>
struct hash<error_condition> {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef error_condition _Unnameable_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef size_t _Unnameable_result;

    [[nodiscard]] size_t operator()(const error_condition& _Keyval) const noexcept {
        return hash<int>{}(_Keyval.value());
    }
};

class _System_error : public runtime_error { 
private:
    static string _Makestr(error_code _Errcode, string _Message) { 
        if (!_Message.empty()) {
            _Message.append(": ");
        }

        _Message.append(_Errcode.message());
        return _Message;
    }

protected:
    _System_error(error_code _Errcode, const string& _Message)
        : runtime_error(_Makestr(_Errcode, _Message)), _Mycode(_Errcode) {}

    error_code _Mycode; 
};

class system_error : public _System_error { 
private:
    using _Mybase = _System_error;

public:
    system_error(error_code _Errcode) : _Mybase(_Errcode, "") {}

    system_error(error_code _Errcode, const string& _Message) : _Mybase(_Errcode, _Message) {}

    system_error(error_code _Errcode, const char* _Message) : _Mybase(_Errcode, _Message) {}

    system_error(int _Errval, const error_category& _Errcat) : _Mybase(error_code(_Errval, _Errcat), "") {}

    system_error(int _Errval, const error_category& _Errcat, const string& _Message)
        : _Mybase(error_code(_Errval, _Errcat), _Message) {}

    system_error(int _Errval, const error_category& _Errcat, const char* _Message)
        : _Mybase(error_code(_Errval, _Errcat), _Message) {}

    [[nodiscard]] const error_code& code() const noexcept {
        return _Mycode;
    }


#line 471 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\system_error"
};

[[noreturn]] inline void _Throw_system_error(const errc _Errno) {
    throw system_error{::std:: make_error_code(_Errno)};
}

 const char* __cdecl _Syserror_map(int);
 int __cdecl _Winerror_map(int);

struct _System_error_message {
    char* _Str;
    size_t _Length;

    explicit _System_error_message(const unsigned long _Ec) noexcept
        : _Str(nullptr), _Length(:: __std_system_error_allocate_message(_Ec, &_Str)) {}

    _System_error_message(const _System_error_message&) = delete;
    _System_error_message& operator=(const _System_error_message&) = delete;

    ~_System_error_message() {
        :: __std_system_error_deallocate_message(_Str);
    }
};

class _Generic_error_category : public error_category { 
public:
    constexpr _Generic_error_category() noexcept : error_category(_Generic_addr) {}

    [[nodiscard]] const char* name() const noexcept override {
        return "generic";
    }

    [[nodiscard]] string message(int _Errcode) const override {
        
        if (_Errcode == 0) {
            return "success";
        } else {
            return _Syserror_map(_Errcode);
        }
    }
};

class _Iostream_error_category2 : public error_category { 
public:
    constexpr _Iostream_error_category2() noexcept : error_category(_Iostream_addr) {}

    [[nodiscard]] const char* name() const noexcept override {
        return "iostream";
    }

    [[nodiscard]] string message(int _Errcode) const override {
        if (_Errcode == static_cast<int>(io_errc::stream)) {
            static constexpr char _Iostream_error[] = "iostream stream error";
            constexpr size_t _Iostream_error_length = sizeof(_Iostream_error) - 1; 
            return string(_Iostream_error, _Iostream_error_length);
        } else {
            return _Syserror_map(_Errcode);
        }
    }
};

class _System_error_category : public error_category { 
public:
    constexpr _System_error_category() noexcept : error_category(_System_addr) {}

    [[nodiscard]] const char* name() const noexcept override {
        return "system";
    }

    [[nodiscard]] string message(int _Errcode) const override {
        const _System_error_message _Msg(static_cast<unsigned long>(_Errcode));
        if (_Msg._Length == 0) {
            static constexpr char _Unknown_error[] = "unknown error";
            constexpr size_t _Unknown_error_length = sizeof(_Unknown_error) - 1; 
            return string(_Unknown_error, _Unknown_error_length);
        } else {
            return string(_Msg._Str, _Msg._Length);
        }
    }

    [[nodiscard]] error_condition default_error_condition(int _Errval) const noexcept override {
        if (_Errval == 0) {
            return error_condition(0, ::std:: generic_category());
        }

        
        const int _Posv = _Winerror_map(_Errval);
        if (_Posv == 0) {
            return error_condition(_Errval, ::std:: system_category());
        } else {
            return error_condition(_Posv, ::std:: generic_category());
        }
    }
};


#line 603 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\system_error"
template <class _Ty>
[[nodiscard]] const _Ty& _Immortalize_memcpy_image() noexcept {
    static constexpr _Ty _Static;
    return _Static;
}


#line 656 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\system_error"

[[nodiscard]] inline const error_category& generic_category() noexcept {
    return _Immortalize_memcpy_image<_Generic_error_category>();
}

[[nodiscard]] inline const error_category& iostream_category() noexcept {
    return _Immortalize_memcpy_image<_Iostream_error_category2>();
}

[[nodiscard]] inline const error_category& system_category() noexcept {
    return _Immortalize_memcpy_image<_System_error_category>();
}
}


#pragma warning(pop)
#pragma pack(pop)
#line 674 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\system_error"
#line 675 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\system_error"
#line 13 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xiosbase"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocale"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"


#pragma once


#line 20 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {

namespace ranges {
    template <class _In, class _Out>
    using uninitialized_copy_result = in_out_result<_In, _Out>;

    class _Uninitialized_copy_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It, sentinel_for<_It> _Se, _No_throw_forward_iterator _Out,
            _No_throw_sentinel_for<_Out> _OSe>
            requires constructible_from<iter_value_t<_Out>, iter_reference_t<_It>>
        uninitialized_copy_result<_It, _Out> operator()(_It _First1, _Se _Last1, _Out _First2, _OSe _Last2) const {
            
            _Adl_verify_range(_First1, _Last1);
            _Adl_verify_range(_First2, _Last2);
            auto _UResult =
                _Uninitialized_copy_unchecked(_Get_unwrapped(::std:: move(_First1)), _Get_unwrapped(::std:: move(_Last1)),
                    _Get_unwrapped(::std:: move(_First2)), _Get_unwrapped(::std:: move(_Last2)));

            _Seek_wrapped(_First1, ::std:: move(_UResult.in));
            _Seek_wrapped(_First2, ::std:: move(_UResult.out));
            return {::std:: move(_First1), ::std:: move(_First2)};
        }

        
        template <input_range _Rng1, _No_throw_forward_range _Rng2>
            requires constructible_from<range_value_t<_Rng2>, range_reference_t<_Rng1>>
        uninitialized_copy_result<borrowed_iterator_t<_Rng1>, borrowed_iterator_t<_Rng2>> operator()(
            _Rng1&& _Range1, _Rng2&& _Range2) const {
            
            auto _First1  = ::std::ranges:: begin(_Range1);
            auto _UResult = _Uninitialized_copy_unchecked(
                _Get_unwrapped(::std:: move(_First1)), _Uend(_Range1), _Ubegin(_Range2), _Uend(_Range2));

            _Seek_wrapped(_First1, ::std:: move(_UResult.in));
            return {::std:: move(_First1), _Rewrap_iterator(_Range2, ::std:: move(_UResult.out))};
        }

    private:
        template <class _It, class _Se, class _Out, class _OSe>
        [[nodiscard]] static uninitialized_copy_result<_It, _Out> _Uninitialized_copy_unchecked(
            _It _IFirst, _Se _ILast, _Out _OFirst, _OSe _OLast) {
            ;
            ;
            ;
            ;
            ;

            constexpr bool _Is_sized1 = sized_sentinel_for<_Se, _It>;
            constexpr bool _Is_sized2 = sized_sentinel_for<_OSe, _Out>;
            if constexpr (_Iter_copy_cat<_It, _Out>::_Bitcopy_constructible
                          && _Sized_or_unreachable_sentinel_for<_Se, _It> 
                          && _Sized_or_unreachable_sentinel_for<_OSe, _Out>) {
                if constexpr (_Is_sized1 && _Is_sized2) {
                    return _Copy_memcpy_common(_IFirst, ::std::ranges:: next(_IFirst, ::std:: move(_ILast)), _OFirst,
                        ::std::ranges:: next(_OFirst, ::std:: move(_OLast)));
                } else if constexpr (_Is_sized1) {
                    return _Copy_memcpy_distance(_IFirst, _OFirst, _IFirst, ::std::ranges:: next(_IFirst, ::std:: move(_ILast)));
                } else if constexpr (_Is_sized2) {
                    return _Copy_memcpy_distance(_IFirst, _OFirst, _OFirst, ::std::ranges:: next(_OFirst, ::std:: move(_OLast)));
                } else {
                    ;
                }
            } else {
                _Uninitialized_backout _Backout{::std:: move(_OFirst)};

                for (; _IFirst != _ILast && _Backout._Last != _OLast; ++_IFirst) {
                    _Backout._Emplace_back(*_IFirst);
                }

                return {::std:: move(_IFirst), _Backout._Release()};
            }
        }
    };

    inline constexpr _Uninitialized_copy_fn uninitialized_copy{_Not_quite_object::_Construct_tag{}};
} 
#line 109 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

template <class _InIt, class _Diff, class _NoThrowFwdIt>
_NoThrowFwdIt uninitialized_copy_n(const _InIt _First, const _Diff _Count_raw, _NoThrowFwdIt _Dest) {
    
    _Algorithm_int_t<_Diff> _Count = _Count_raw;
    if (_Count <= 0) {
        return _Dest;
    }

    auto _UFirst = _Get_unwrapped_n(_First, _Count);
    auto _UDest  = _Get_unwrapped_n(_Dest, _Count);
    if constexpr (_Iter_copy_cat<decltype(_UFirst), decltype(_UDest)>::_Bitcopy_constructible) {
        _UDest = _Copy_memmove(_UFirst, _UFirst + _Count, _UDest);
    } else {
        _Uninitialized_backout<decltype(_UDest)> _Backout{_UDest};

        for (; _Count > 0; --_Count, (void) ++_UFirst) {
            _Backout._Emplace_back(*_UFirst);
        }

        _UDest = _Backout._Release();
    }

    _Seek_wrapped(_Dest, _UDest);
    return _Dest;
}


namespace ranges {
    template <class _In, class _Out>
    using uninitialized_copy_n_result = in_out_result<_In, _Out>;

    class _Uninitialized_copy_n_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It, _No_throw_forward_iterator _Out, _No_throw_sentinel_for<_Out> _OSe>
            requires constructible_from<iter_value_t<_Out>, iter_reference_t<_It>>
        uninitialized_copy_n_result<_It, _Out> operator()(
            _It _First1, iter_difference_t<_It> _Count, _Out _First2, _OSe _Last2) const {
            
            if (_Count <= 0) {
                return {::std:: move(_First1), ::std:: move(_First2)};
            }

            _Adl_verify_range(_First2, _Last2);
            auto _IFirst = _Get_unwrapped_n(::std:: move(_First1), _Count);
            auto _OFirst = _Get_unwrapped(::std:: move(_First2));
            auto _OLast  = _Get_unwrapped(::std:: move(_Last2));
            if constexpr (_Iter_copy_cat<_It, _Out>::_Bitcopy_constructible
                          && _Sized_or_unreachable_sentinel_for<_OSe, _Out>) {
                if constexpr (sized_sentinel_for<_OSe, _Out>) {
                    auto _UResult = _Copy_memcpy_common(
                        _IFirst, _IFirst + _Count, _OFirst, ::std::ranges:: next(_OFirst, ::std:: move(_OLast)));
                    _IFirst = ::std:: move(_UResult.in);
                    _OFirst = ::std:: move(_UResult.out);
                } else {
                    auto _UResult = _Copy_memcpy_count(_IFirst, _OFirst, static_cast<size_t>(_Count));
                    _IFirst       = ::std:: move(_UResult.in);
                    _OFirst       = ::std:: move(_UResult.out);
                }
            } else {
                _Uninitialized_backout _Backout{::std:: move(_OFirst)};

                for (; _Count > 0 && _Backout._Last != _OLast; --_Count, (void) ++_IFirst) {
                    _Backout._Emplace_back(*_IFirst);
                }

                _OFirst = _Backout._Release();
            }

            _Seek_wrapped(_First1, _IFirst);
            _Seek_wrapped(_First2, _OFirst);
            return {::std:: move(_First1), ::std:: move(_First2)};
        }
    };

    inline constexpr _Uninitialized_copy_n_fn uninitialized_copy_n{_Not_quite_object::_Construct_tag{}};
} 
#line 190 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"


template <class _InIt, class _NoThrowFwdIt>
_NoThrowFwdIt uninitialized_move(const _InIt _First, const _InIt _Last, _NoThrowFwdIt _Dest) {
    
    _Adl_verify_range(_First, _Last);
    const auto _UFirst = _Get_unwrapped(_First);
    const auto _ULast  = _Get_unwrapped(_Last);
    const auto _UDest  = _Get_unwrapped_n(_Dest, _Idl_distance<_InIt>(_UFirst, _ULast));
    _Seek_wrapped(_Dest, _Uninitialized_move_unchecked(_UFirst, _ULast, _UDest));
    return _Dest;
}


namespace ranges {
    class _Uninitialized_move_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It, sentinel_for<_It> _Se, _No_throw_forward_iterator _Out,
            _No_throw_sentinel_for<_Out> _OSe>
            requires constructible_from<iter_value_t<_Out>, iter_rvalue_reference_t<_It>>
        uninitialized_move_result<_It, _Out> operator()(_It _First1, _Se _Last1, _Out _First2, _OSe _Last2) const {
            
            _Adl_verify_range(_First1, _Last1);
            _Adl_verify_range(_First2, _Last2);
            auto _UResult = ::std::ranges:: _Uninitialized_move_unchecked(_Get_unwrapped(::std:: move(_First1)),
                _Get_unwrapped(::std:: move(_Last1)), _Get_unwrapped(::std:: move(_First2)),
                _Get_unwrapped(::std:: move(_Last2)));

            _Seek_wrapped(_First1, ::std:: move(_UResult.in));
            _Seek_wrapped(_First2, ::std:: move(_UResult.out));
            return {::std:: move(_First1), ::std:: move(_First2)};
        }

        
        template <input_range _Rng1, _No_throw_forward_range _Rng2>
            requires constructible_from<range_value_t<_Rng2>, range_rvalue_reference_t<_Rng1>>
        uninitialized_move_result<borrowed_iterator_t<_Rng1>, borrowed_iterator_t<_Rng2>> operator()(
            _Rng1&& _Range1, _Rng2&& _Range2) const {
            
            auto _First1  = ::std::ranges:: begin(_Range1);
            auto _UResult = ::std::ranges:: _Uninitialized_move_unchecked(
                _Get_unwrapped(::std:: move(_First1)), _Uend(_Range1), _Ubegin(_Range2), _Uend(_Range2));

            _Seek_wrapped(_First1, ::std:: move(_UResult.in));
            return {::std:: move(_First1), _Rewrap_iterator(_Range2, ::std:: move(_UResult.out))};
        }
    };

    inline constexpr _Uninitialized_move_fn uninitialized_move{_Not_quite_object::_Construct_tag{}};
} 
#line 244 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

template <class _InIt, class _Diff, class _NoThrowFwdIt>
pair<_InIt, _NoThrowFwdIt> uninitialized_move_n(_InIt _First, const _Diff _Count_raw, _NoThrowFwdIt _Dest) {
    
    _Algorithm_int_t<_Diff> _Count = _Count_raw;
    if (_Count <= 0) {
        return {_First, _Dest};
    }

    auto _UFirst = _Get_unwrapped_n(_First, _Count);
    auto _UDest  = _Get_unwrapped_n(_Dest, _Count);
    if constexpr (_Iter_move_cat<decltype(_UFirst), decltype(_UDest)>::_Bitcopy_constructible) {
        _UDest = _Copy_memmove(_UFirst, _UFirst + _Count, _UDest);
        _UFirst += _Count;
    } else {
        _Uninitialized_backout<decltype(_UDest)> _Backout{_UDest};

        for (; _Count > 0; --_Count, (void) ++_UFirst) {
            _Backout._Emplace_back(::std:: move(*_UFirst));
        }

        _UDest = _Backout._Release();
    }

    _Seek_wrapped(_Dest, _UDest);
    _Seek_wrapped(_First, _UFirst);
    return {_First, _Dest};
}
#line 273 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"


namespace ranges {
    template <class _In, class _Out>
    using uninitialized_move_n_result = in_out_result<_In, _Out>;

    class _Uninitialized_move_n_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <input_iterator _It, _No_throw_forward_iterator _Out, _No_throw_sentinel_for<_Out> _OSe>
            requires constructible_from<iter_value_t<_Out>, iter_rvalue_reference_t<_It>>
        uninitialized_move_n_result<_It, _Out> operator()(
            _It _First1, iter_difference_t<_It> _Count, _Out _First2, _OSe _Last2) const {
            
            if (_Count <= 0) {
                return {::std:: move(_First1), ::std:: move(_First2)};
            }

            _Adl_verify_range(_First2, _Last2);
            auto _IFirst      = _Get_unwrapped_n(::std:: move(_First1), _Count);
            auto _OFirst      = _Get_unwrapped(::std:: move(_First2));
            const auto _OLast = _Get_unwrapped(::std:: move(_Last2));
            if constexpr (_Iter_move_cat<_It, _Out>::_Bitcopy_constructible
                          && _Sized_or_unreachable_sentinel_for<_OSe, _Out>) {
                if constexpr (sized_sentinel_for<_OSe, _Out>) {
                    auto _UResult = _Copy_memcpy_common(
                        _IFirst, _IFirst + _Count, _OFirst, ::std::ranges:: next(_OFirst, ::std:: move(_OLast)));
                    _IFirst = ::std:: move(_UResult.in);
                    _OFirst = ::std:: move(_UResult.out);
                } else {
                    auto _UResult = _Copy_memcpy_count(_IFirst, _OFirst, static_cast<size_t>(_Count));
                    _IFirst       = ::std:: move(_UResult.in);
                    _OFirst       = ::std:: move(_UResult.out);
                }
            } else {
                _Uninitialized_backout _Backout{::std:: move(_OFirst)};

                for (; _Count > 0 && _Backout._Last != _OLast; --_Count, (void) ++_IFirst) {
                    _Backout._Emplace_back(::std::ranges:: iter_move(_IFirst));
                }

                _OFirst = _Backout._Release();
            }

            _Seek_wrapped(_First1, _IFirst);
            _Seek_wrapped(_First2, _OFirst);
            return {::std:: move(_First1), ::std:: move(_First2)};
        }
    };

    inline constexpr _Uninitialized_move_n_fn uninitialized_move_n{_Not_quite_object::_Construct_tag{}};

    class _Uninitialized_fill_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <_No_throw_forward_iterator _It, _No_throw_sentinel_for<_It> _Se, class _Ty>
            requires constructible_from<iter_value_t<_It>, const _Ty&>
        _It operator()(_It _First, _Se _Last, const _Ty& _Val) const {
            
            _Adl_verify_range(_First, _Last);
            auto _UResult = _Uninitialized_fill_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)), _Val);

            _Seek_wrapped(_First, ::std:: move(_UResult));
            return _First;
        }

        
        template <_No_throw_forward_range _Rng, class _Ty>
            requires constructible_from<range_value_t<_Rng>, const _Ty&>
        borrowed_iterator_t<_Rng> operator()(_Rng&& _Range, const _Ty& _Val) const {
            
            return _Rewrap_iterator(_Range, _Uninitialized_fill_unchecked(_Ubegin(_Range), _Uend(_Range), _Val));
        }

    private:
        template <class _It, class _Se, class _Ty>
        [[nodiscard]] static _It _Uninitialized_fill_unchecked(_It _OFirst, _Se _OLast, const _Ty& _Val) {
            ;
            ;
            ;

            if constexpr (_Fill_memset_is_safe<_It, _Ty>) {
                const auto _OFinal = ::std::ranges:: next(_OFirst, ::std:: move(_OLast));
                _Fill_memset(_OFirst, _Val, static_cast<size_t>(_OFinal - _OFirst));
                return _OFinal;
            } else {
                if constexpr (_Fill_zero_memset_is_safe<_It, _Ty>) {
                    if (_Is_all_bits_zero(_Val)) {
                        const auto _OFinal = ::std::ranges:: next(_OFirst, ::std:: move(_OLast));
                        _Fill_zero_memset(_OFirst, static_cast<size_t>(_OFinal - _OFirst));
                        return _OFinal;
                    }
                }

                _Uninitialized_backout _Backout{::std:: move(_OFirst)};

                while (_Backout._Last != _OLast) {
                    _Backout._Emplace_back(_Val);
                }

                return _Backout._Release();
            }
        }
    };

    inline constexpr _Uninitialized_fill_fn uninitialized_fill{_Not_quite_object::_Construct_tag{}};
} 
#line 387 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

template <class _NoThrowFwdIt, class _Diff, class _Tval>
_NoThrowFwdIt uninitialized_fill_n(_NoThrowFwdIt _First, const _Diff _Count_raw, const _Tval& _Val) {
    
    _Algorithm_int_t<_Diff> _Count = _Count_raw;
    if (_Count <= 0) {
        return _First;
    }

    auto _UFirst = _Get_unwrapped_n(_First, _Count);
    if constexpr (_Fill_memset_is_safe<decltype(_UFirst), _Tval>) {
        _Fill_memset(_UFirst, _Val, static_cast<size_t>(_Count));
        _UFirst += _Count;
    } else {
        if constexpr (_Fill_zero_memset_is_safe<decltype(_UFirst), _Tval>) {
            if (_Is_all_bits_zero(_Val)) {
                _Fill_zero_memset(_UFirst, static_cast<size_t>(_Count));
                _Seek_wrapped(_First, _UFirst + _Count);
                return _First;
            }
        }

        _Uninitialized_backout<decltype(_UFirst)> _Backout{_UFirst};

        for (; _Count > 0; --_Count) {
            _Backout._Emplace_back(_Val);
        }

        _UFirst = _Backout._Release();
    }

    _Seek_wrapped(_First, _UFirst);
    return _First;
}


namespace ranges {
    class _Uninitialized_fill_n_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <_No_throw_forward_iterator _It, class _Ty>
            requires constructible_from<iter_value_t<_It>, const _Ty&>
        _It operator()(_It _First, iter_difference_t<_It> _Count, const _Ty& _Val) const {
            
            if (_Count <= 0) {
                return _First;
            }

            auto _UFirst = _Get_unwrapped_n(::std:: move(_First), _Count);
            if constexpr (_Fill_memset_is_safe<decltype(_UFirst), _Ty>) {
                _Fill_memset(_UFirst, _Val, static_cast<size_t>(_Count));
                _Seek_wrapped(_First, _UFirst + _Count);
            } else {
                if constexpr (_Fill_zero_memset_is_safe<decltype(_UFirst), _Ty>) {
                    if (_Is_all_bits_zero(_Val)) {
                        _Fill_zero_memset(_UFirst, static_cast<size_t>(_Count));
                        _Seek_wrapped(_First, _UFirst + _Count);
                        return _First;
                    }
                }

                _Uninitialized_backout _Backout{::std:: move(_UFirst)};

                for (; _Count > 0; --_Count) {
                    _Backout._Emplace_back(_Val);
                }

                _Seek_wrapped(_First, _Backout._Release());
            }
            return _First;
        }
    };

    inline constexpr _Uninitialized_fill_n_fn uninitialized_fill_n{_Not_quite_object::_Construct_tag{}};

    class _Construct_at_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <class _Ty, class... _Types>
            requires requires(void* _Void_ptr, _Types&&... _Args) {
                ::new (_Void_ptr) _Ty(static_cast<_Types&&>(_Args)...);
            }
        constexpr _Ty* operator()(_Ty* _Location, _Types&&... _Args) const
            noexcept(noexcept(::new (const_cast<void*>(static_cast<const volatile void*>(_Location)))
                    _Ty(::std:: forward<_Types>(_Args)...)))  {
            
            return ::new (const_cast<void*>(static_cast<const volatile void*>(_Location)))
                _Ty(::std:: forward<_Types>(_Args)...);
        }
    };

    inline constexpr _Construct_at_fn construct_at{_Not_quite_object::_Construct_tag{}};

    
    template <_No_throw_input_iterator _It, _No_throw_sentinel_for<_It> _Se>
        requires destructible<iter_value_t<_It>>
    [[nodiscard]] constexpr _It _Destroy_unchecked(_It _First, _Se _Last) noexcept;
    

    class _Destroy_at_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        template <destructible _Ty>
        constexpr void operator()(_Ty* const _Location) const noexcept {
            if constexpr (is_array_v<_Ty>) {
                (void) ::std::ranges:: _Destroy_unchecked(::std::ranges:: begin(*_Location), ::std::ranges:: end(*_Location));
            } else {
                _Location->~_Ty();
            }
        }
    };

    inline constexpr _Destroy_at_fn destroy_at{_Not_quite_object::_Construct_tag{}};
} 
#line 507 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"


template <class _NoThrowFwdIt>
constexpr void destroy(const _NoThrowFwdIt _First, const _NoThrowFwdIt _Last) {
    
    _Adl_verify_range(_First, _Last);
    _Destroy_range(_Get_unwrapped(_First), _Get_unwrapped(_Last));
}


namespace ranges {
    
    template <_No_throw_input_iterator _It, _No_throw_sentinel_for<_It> _Se>
        requires destructible<iter_value_t<_It>>
    [[nodiscard]] constexpr _It _Destroy_unchecked(_It _First, _Se _Last) noexcept {
        
        if constexpr (is_trivially_destructible_v<iter_value_t<_It>>) {
            ::std::ranges:: advance(_First, ::std:: move(_Last));
        } else {
            for (; _First != _Last; ++_First) {
                ::std::ranges:: destroy_at(::std:: addressof(*_First));
            }
        }

        return _First;
    }

    class _Destroy_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <_No_throw_input_iterator _It, _No_throw_sentinel_for<_It> _Se>
            requires destructible<iter_value_t<_It>>
        constexpr _It operator()(_It _First, _Se _Last) const noexcept {
            
            _Adl_verify_range(_First, _Last);
            _Seek_wrapped(_First,
                ::std::ranges:: _Destroy_unchecked(_Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last))));
            return _First;
        }

        
        template <_No_throw_input_range _Rng>
            requires destructible<range_value_t<_Rng>>
        constexpr borrowed_iterator_t<_Rng> operator()(_Rng&& _Range) const noexcept {
            
            auto _First = ::std::ranges:: begin(_Range);
            _Seek_wrapped(_First, ::std::ranges:: _Destroy_unchecked(_Get_unwrapped(::std:: move(_First)), _Uend(_Range)));
            return _First;
        }
    };

    inline constexpr _Destroy_fn destroy{_Not_quite_object::_Construct_tag{}};
} 
#line 563 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

template <class _NoThrowFwdIt, class _Diff>
constexpr _NoThrowFwdIt destroy_n(_NoThrowFwdIt _First, const _Diff _Count_raw) {
    
    _Algorithm_int_t<_Diff> _Count = _Count_raw;
    if (_Count <= 0) {
        return _First;
    }

    auto _UFirst = _Get_unwrapped_n(_First, _Count);
    if constexpr (is_trivially_destructible_v<_Iter_value_t<_NoThrowFwdIt>>) {
        ::std:: advance(_UFirst, _Count);
    } else {
        for (; _Count > 0; --_Count, (void) ++_UFirst) {
            _Destroy_in_place(*_UFirst);
        }
    }

    _Seek_wrapped(_First, _UFirst);
    return _First;
}


namespace ranges {
    class _Destroy_n_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <_No_throw_input_iterator _It>
            requires destructible<iter_value_t<_It>>
        constexpr _It operator()(_It _First, const iter_difference_t<_It> _Count_raw) const noexcept {
            
            _Algorithm_int_t<iter_difference_t<_It>> _Count = _Count_raw;
            if (_Count <= 0) {
                return _First;
            }

            auto _UFirst = _Get_unwrapped_n(::std:: move(_First), _Count);
            if constexpr (is_trivially_destructible_v<iter_value_t<_It>>) {
                ::std::ranges:: advance(_UFirst, _Count);
            } else {
                do {
                    ::std::ranges:: destroy_at(::std:: addressof(*_UFirst));
                    ++_UFirst;
                    --_Count;
                } while (_Count > 0);
            }

            _Seek_wrapped(_First, ::std:: move(_UFirst));
            return _First;
        }
    };

    inline constexpr _Destroy_n_fn destroy_n{_Not_quite_object::_Construct_tag{}};
} 
#line 620 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

template <class _NoThrowFwdIt>
void uninitialized_default_construct(const _NoThrowFwdIt _First, const _NoThrowFwdIt _Last) {
    
    using _Ty = remove_reference_t<_Iter_ref_t<_NoThrowFwdIt>>;
    _Adl_verify_range(_First, _Last);
    if constexpr (!is_trivially_default_constructible_v<_Ty>) {
        _Uninitialized_backout _Backout{_Get_unwrapped(_First)};

        for (const auto _ULast = _Get_unwrapped(_Last); _Backout._Last != _ULast; ++_Backout._Last) {
            _Default_construct_in_place(*_Backout._Last);
        }

        _Backout._Release();
    }
}


namespace ranges {
    class _Uninitialized_default_construct_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <_No_throw_forward_iterator _It, _No_throw_sentinel_for<_It> _Se>
            requires default_initializable<iter_value_t<_It>>
        _It operator()(_It _First, _Se _Last) const {
            
            _Adl_verify_range(_First, _Last);
            auto _UResult = _Uninitialized_default_construct_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)));

            _Seek_wrapped(_First, ::std:: move(_UResult));
            return _First;
        }

        
        template <_No_throw_forward_range _Rng>
            requires default_initializable<range_value_t<_Rng>>
        borrowed_iterator_t<_Rng> operator()(_Rng&& _Range) const {
            
            auto _UResult = _Uninitialized_default_construct_unchecked(_Ubegin(_Range), _Uend(_Range));

            return _Rewrap_iterator(_Range, ::std:: move(_UResult));
        }

    private:
        template <class _It, class _Se>
        [[nodiscard]] static _It _Uninitialized_default_construct_unchecked(_It _OFirst, const _Se _OLast) {
            ;
            ;
            ;

            using _Ty = remove_reference_t<iter_reference_t<_It>>;
            if constexpr (is_trivially_default_constructible_v<_Ty>) {
                ::std::ranges:: advance(_OFirst, _OLast);
                return _OFirst;
            } else {
                _Uninitialized_backout _Backout{::std:: move(_OFirst)};

                for (; _Backout._Last != _OLast; ++_Backout._Last) {
                    _Default_construct_in_place(*_Backout._Last);
                }

                return _Backout._Release();
            }
        }
    };

    inline constexpr _Uninitialized_default_construct_fn uninitialized_default_construct{
        _Not_quite_object::_Construct_tag{}};
} 
#line 693 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

template <class _NoThrowFwdIt, class _Diff>
_NoThrowFwdIt uninitialized_default_construct_n(_NoThrowFwdIt _First, const _Diff _Count_raw) {
    
    using _Ty                      = _Iter_value_t<_NoThrowFwdIt>;
    _Algorithm_int_t<_Diff> _Count = _Count_raw;
    if (_Count <= 0) {
        return _First;
    }

    if constexpr (is_trivially_default_constructible_v<_Ty>) {
        ::std:: advance(_First, _Count);
    } else {
        _Uninitialized_backout _Backout{_Get_unwrapped_n(_First, _Count)};

        for (; _Count > 0; ++_Backout._Last, (void) --_Count) {
            _Default_construct_in_place(*_Backout._Last);
        }

        _Seek_wrapped(_First, _Backout._Release());
    }
    return _First;
}


namespace ranges {
    class _Uninitialized_default_construct_n_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <_No_throw_forward_iterator _It>
            requires default_initializable<iter_value_t<_It>>
        _It operator()(_It _First, iter_difference_t<_It> _Count) const {
            
            if (_Count <= 0) {
                return _First;
            }

            using _Ty = remove_reference_t<iter_reference_t<_It>>;
            if constexpr (is_trivially_default_constructible_v<_Ty>) {
                ::std::ranges:: advance(_First, _Count);
            } else {
                _Uninitialized_backout _Backout{_Get_unwrapped_n(::std:: move(_First), _Count)};

                for (; _Count > 0; --_Count, (void) ++_Backout._Last) {
                    _Default_construct_in_place(*_Backout._Last);
                }

                _Seek_wrapped(_First, _Backout._Release());
            }
            return _First;
        }
    };

    inline constexpr _Uninitialized_default_construct_n_fn uninitialized_default_construct_n{
        _Not_quite_object::_Construct_tag{}};
} 
#line 752 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

template <class _NoThrowFwdIt>
void uninitialized_value_construct(const _NoThrowFwdIt _First, const _NoThrowFwdIt _Last) {
    
    _Adl_verify_range(_First, _Last);
    const auto _UFirst = _Get_unwrapped(_First);
    const auto _ULast  = _Get_unwrapped(_Last);
    if constexpr (_Use_memset_value_construct_v<_Unwrapped_t<const _NoThrowFwdIt&>>) {
        _Zero_range(_UFirst, _ULast);
    } else {
        _Uninitialized_backout _Backout{_UFirst};

        while (_Backout._Last != _ULast) {
            _Backout._Emplace_back();
        }

        _Backout._Release();
    }
}


namespace ranges {
    class _Uninitialized_value_construct_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <_No_throw_forward_iterator _It, _No_throw_sentinel_for<_It> _Se>
            requires default_initializable<iter_value_t<_It>>
        _It operator()(_It _First, _Se _Last) const {
            
            _Adl_verify_range(_First, _Last);
            auto _UResult = _Uninitialized_value_construct_unchecked(
                _Get_unwrapped(::std:: move(_First)), _Get_unwrapped(::std:: move(_Last)));

            _Seek_wrapped(_First, ::std:: move(_UResult));
            return _First;
        }

        
        template <_No_throw_forward_range _Rng>
            requires default_initializable<range_value_t<_Rng>>
        borrowed_iterator_t<_Rng> operator()(_Rng&& _Range) const {
            
            auto _UResult = _Uninitialized_value_construct_unchecked(_Ubegin(_Range), _Uend(_Range));

            return _Rewrap_iterator(_Range, ::std:: move(_UResult));
        }

    private:
        template <class _It, class _Se>
        [[nodiscard]] static _It _Uninitialized_value_construct_unchecked(_It _OFirst, _Se _OLast) {
            ;
            ;
            ;

            if constexpr (_Use_memset_value_construct_v<_It>) {
                return _Zero_range(_OFirst, ::std::ranges:: next(_OFirst, ::std:: move(_OLast)));
            } else {
                _Uninitialized_backout _Backout{::std:: move(_OFirst)};

                while (_Backout._Last != _OLast) {
                    _Backout._Emplace_back();
                }

                return _Backout._Release();
            }
        }
    };

    inline constexpr _Uninitialized_value_construct_fn uninitialized_value_construct{
        _Not_quite_object::_Construct_tag{}};
} 
#line 826 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

template <class _NoThrowFwdIt, class _Diff>
_NoThrowFwdIt uninitialized_value_construct_n(_NoThrowFwdIt _First, const _Diff _Count_raw) {
    
    _Algorithm_int_t<_Diff> _Count = _Count_raw;
    if (_Count <= 0) {
        return _First;
    }

    _Seek_wrapped(_First, _Uninitialized_value_construct_n_unchecked1(_Get_unwrapped_n(_First, _Count), _Count));
    return _First;
}


namespace ranges {
    class _Uninitialized_value_construct_n_fn : private _Not_quite_object {
    public:
        using _Not_quite_object::_Not_quite_object;

        
        template <_No_throw_forward_iterator _It>
            requires default_initializable<iter_value_t<_It>>
        _It operator()(_It _First, iter_difference_t<_It> _Count) const {
            
            if (_Count <= 0) {
                return _First;
            }

            auto _UFirst = _Get_unwrapped_n(::std:: move(_First), _Count);
            if constexpr (_Use_memset_value_construct_v<_It>) {
                _Seek_wrapped(_First, _Zero_range(_UFirst, _UFirst + _Count));
            } else {
                _Uninitialized_backout _Backout{::std:: move(_UFirst)};

                for (; _Count > 0; --_Count) {
                    _Backout._Emplace_back();
                }

                _Seek_wrapped(_First, _Backout._Release());
            }
            return _First;
        }
    };

    inline constexpr _Uninitialized_value_construct_n_fn uninitialized_value_construct_n{
        _Not_quite_object::_Construct_tag{}};
} 
#line 874 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"
#line 875 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"


#line 926 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"


#line 1036 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"


class bad_weak_ptr : public exception { 
public:
    bad_weak_ptr() noexcept {}

    [[nodiscard]] const char*  what() const noexcept override {
        
        return "bad_weak_ptr";
    }
};

[[noreturn]] inline void _Throw_bad_weak_ptr() {
    throw bad_weak_ptr{};
}

class __declspec(novtable) _Ref_count_base { 
private:


    virtual void _Destroy() noexcept     = 0; 
    virtual void _Delete_this() noexcept = 0; 
#line 1067 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

    _Atomic_counter_t _Uses  = 1;
    _Atomic_counter_t _Weaks = 1;

protected:
    constexpr _Ref_count_base() noexcept = default; 

public:
    _Ref_count_base(const _Ref_count_base&) = delete;
    _Ref_count_base& operator=(const _Ref_count_base&) = delete;

    virtual ~_Ref_count_base() noexcept {} 

    bool _Incref_nz() noexcept { 
        auto& _Volatile_uses = reinterpret_cast<volatile long&>(_Uses);


        long _Count = __iso_volatile_load32(reinterpret_cast<volatile int*>(&_Volatile_uses));
#line 1087 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"
        while (_Count != 0) {
            const long _Old_value = _InterlockedCompareExchange(&_Volatile_uses, _Count + 1, _Count);
            if (_Old_value == _Count) {
                return true;
            }

            _Count = _Old_value;
        }

        return false;
    }

    void _Incref() noexcept { 
        _InterlockedIncrement(reinterpret_cast<volatile long*>(&_Uses));
    }

    void _Incwref() noexcept { 
        _InterlockedIncrement(reinterpret_cast<volatile long*>(&_Weaks));
    }

    void _Decref() noexcept { 
        if (_InterlockedDecrement(reinterpret_cast<volatile long*>(&_Uses)) == 0) {
            _Destroy();
            _Decwref();
        }
    }

    void _Decwref() noexcept { 
        if (_InterlockedDecrement(reinterpret_cast<volatile long*>(&_Weaks)) == 0) {
            _Delete_this();
        }
    }

    long _Use_count() const noexcept {
        return static_cast<long>(_Uses);
    }

    virtual void* _Get_deleter(const type_info&) const noexcept {
        return nullptr;
    }
};

template <class _Ty>
class _Ref_count : public _Ref_count_base { 
public:
    explicit _Ref_count(_Ty* _Px) : _Ref_count_base(), _Ptr(_Px) {}

private:
    void _Destroy() noexcept override { 
        delete _Ptr;
    }

    void _Delete_this() noexcept override { 
        delete this;
    }

    _Ty* _Ptr;
};

template <class _Resource, class _Dx>
class _Ref_count_resource : public _Ref_count_base { 
public:
    _Ref_count_resource(_Resource _Px, _Dx _Dt)
        : _Ref_count_base(), _Mypair(_One_then_variadic_args_t{}, ::std:: move(_Dt), _Px) {}


    ~_Ref_count_resource() noexcept override = default; 
#line 1157 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

    void* _Get_deleter(const type_info& _Typeid) const noexcept override {

        if (_Typeid == typeid(_Dx)) {
            return const_cast<_Dx*>(::std:: addressof(_Mypair._Get_first()));
        }


#line 1166 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

        return nullptr;
    }

private:
    void _Destroy() noexcept override { 
        _Mypair._Get_first()(_Mypair._Myval2);
    }

    void _Delete_this() noexcept override { 
        delete this;
    }

    _Compressed_pair<_Dx, _Resource> _Mypair;
};

template <class _Resource, class _Dx, class _Alloc>
class _Ref_count_resource_alloc : public _Ref_count_base {
    
public:
    _Ref_count_resource_alloc(_Resource _Px, _Dx _Dt, const _Alloc& _Ax)
        : _Ref_count_base(),
          _Mypair(_One_then_variadic_args_t{}, ::std:: move(_Dt), _One_then_variadic_args_t{}, _Ax, _Px) {}


    ~_Ref_count_resource_alloc() noexcept override = default; 
#line 1195 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

    void* _Get_deleter(const type_info& _Typeid) const noexcept override {

        if (_Typeid == typeid(_Dx)) {
            return const_cast<_Dx*>(::std:: addressof(_Mypair._Get_first()));
        }


#line 1204 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

        return nullptr;
    }

private:
    using _Myalty = _Rebind_alloc_t<_Alloc, _Ref_count_resource_alloc>;

    void _Destroy() noexcept override { 
        _Mypair._Get_first()(_Mypair._Myval2._Myval2);
    }

    void _Delete_this() noexcept override { 
        _Myalty _Al = _Mypair._Myval2._Get_first();
        this->~_Ref_count_resource_alloc();
        _Deallocate_plain(_Al, this);
    }

    _Compressed_pair<_Dx, _Compressed_pair<_Myalty, _Resource>> _Mypair;
};

template <class _Ty>
struct default_delete;

template <class _Ty, class _Dx = default_delete<_Ty>>
class unique_ptr;

template <class _Ty>
class shared_ptr;

template <class _Ty>
class weak_ptr;

template <class _Yty, class = void>
struct _Can_enable_shared : false_type {}; 

template <class _Yty>
struct _Can_enable_shared<_Yty, void_t<typename _Yty::_Esft_type>>
    : is_convertible<remove_cv_t<_Yty>*, typename _Yty::_Esft_type*>::type {
    
};

struct _Exception_ptr_access;

template <class _Ty>
class _Ptr_base { 
public:
    using element_type = remove_extent_t<_Ty>;

    [[nodiscard]] long use_count() const noexcept {
        return _Rep ? _Rep->_Use_count() : 0;
    }

    template <class _Ty2>
    [[nodiscard]] bool owner_before(const _Ptr_base<_Ty2>& _Right) const noexcept { 
        return _Rep < _Right._Rep;
    }

    _Ptr_base(const _Ptr_base&) = delete;
    _Ptr_base& operator=(const _Ptr_base&) = delete;

protected:
    [[nodiscard]] element_type* get() const noexcept {
        return _Ptr;
    }

    constexpr _Ptr_base() noexcept = default;

    ~_Ptr_base() = default;

    template <class _Ty2>
    void _Move_construct_from(_Ptr_base<_Ty2>&& _Right) noexcept {
        
        _Ptr = _Right._Ptr;
        _Rep = _Right._Rep;

        _Right._Ptr = nullptr;
        _Right._Rep = nullptr;
    }

    template <class _Ty2>
    void _Copy_construct_from(const shared_ptr<_Ty2>& _Other) noexcept {
        
        _Other._Incref();

        _Ptr = _Other._Ptr;
        _Rep = _Other._Rep;
    }

    template <class _Ty2>
    void _Alias_construct_from(const shared_ptr<_Ty2>& _Other, element_type* _Px) noexcept {
        
        _Other._Incref();

        _Ptr = _Px;
        _Rep = _Other._Rep;
    }

    template <class _Ty2>
    void _Alias_move_construct_from(shared_ptr<_Ty2>&& _Other, element_type* _Px) noexcept {
        
        _Ptr = _Px;
        _Rep = _Other._Rep;

        _Other._Ptr = nullptr;
        _Other._Rep = nullptr;
    }

    template <class _Ty0>
    friend class weak_ptr; 

    template <class _Ty2>
    bool _Construct_from_weak(const weak_ptr<_Ty2>& _Other) noexcept {
        
        if (_Other._Rep && _Other._Rep->_Incref_nz()) {
            _Ptr = _Other._Ptr;
            _Rep = _Other._Rep;
            return true;
        }

        return false;
    }

    void _Incref() const noexcept {
        if (_Rep) {
            _Rep->_Incref();
        }
    }

    void _Decref() noexcept { 
        if (_Rep) {
            _Rep->_Decref();
        }
    }

    void _Swap(_Ptr_base& _Right) noexcept { 
        ::std:: swap(_Ptr, _Right._Ptr);
        ::std:: swap(_Rep, _Right._Rep);
    }

    template <class _Ty2>
    void _Weakly_construct_from(const _Ptr_base<_Ty2>& _Other) noexcept { 
        if (_Other._Rep) {
            _Ptr = _Other._Ptr;
            _Rep = _Other._Rep;
            _Rep->_Incwref();
        } else {
            ;
        }
    }

    template <class _Ty2>
    void _Weakly_convert_lvalue_avoiding_expired_conversions(const _Ptr_base<_Ty2>& _Other) noexcept {
        
        if (_Other._Rep) {
            _Rep = _Other._Rep; 
            _Rep->_Incwref();

            if (_Rep->_Incref_nz()) {
                _Ptr = _Other._Ptr; 
                _Rep->_Decref();
            } else {
                ;
            }
        } else {
            ;
        }
    }

    template <class _Ty2>
    void _Weakly_convert_rvalue_avoiding_expired_conversions(_Ptr_base<_Ty2>&& _Other) noexcept {
        
        _Rep        = _Other._Rep; 
        _Other._Rep = nullptr;

        if (_Rep && _Rep->_Incref_nz()) {
            _Ptr = _Other._Ptr; 
            _Rep->_Decref();
        } else {
            ;
        }

        _Other._Ptr = nullptr;
    }

    void _Incwref() const noexcept {
        if (_Rep) {
            _Rep->_Incwref();
        }
    }

    void _Decwref() noexcept { 
        if (_Rep) {
            _Rep->_Decwref();
        }
    }

private:
    element_type* _Ptr{nullptr};
    _Ref_count_base* _Rep{nullptr};

    template <class _Ty0>
    friend class _Ptr_base;

    friend shared_ptr<_Ty>;

    template <class _Ty0>
    friend struct atomic;

    friend _Exception_ptr_access;


    template <class _Dx, class _Ty0>
    friend _Dx* get_deleter(const shared_ptr<_Ty0>& _Sx) noexcept;
#line 1418 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"
};

template <class _Yty, class = void>
struct _Can_scalar_delete : false_type {};
template <class _Yty>
struct _Can_scalar_delete<_Yty, void_t<decltype(delete ::std:: declval<_Yty*>())>> : true_type {};

template <class _Yty, class = void>
struct _Can_array_delete : false_type {};
template <class _Yty>
struct _Can_array_delete<_Yty, void_t<decltype(delete[] ::std:: declval<_Yty*>())>> : true_type {};

template <class _Fx, class _Arg, class = void>
struct _Can_call_function_object : false_type {};
template <class _Fx, class _Arg>
struct _Can_call_function_object<_Fx, _Arg, void_t<decltype(::std:: declval<_Fx>()(::std:: declval<_Arg>()))>> : true_type {};

template <class _Yty, class _Ty>
struct _SP_convertible : is_convertible<_Yty*, _Ty*>::type {};
template <class _Yty, class _Uty>
struct _SP_convertible<_Yty, _Uty[]> : is_convertible<_Yty (*)[], _Uty (*)[]>::type {};
template <class _Yty, class _Uty, size_t _Ext>
struct _SP_convertible<_Yty, _Uty[_Ext]> : is_convertible<_Yty (*)[_Ext], _Uty (*)[_Ext]>::type {};

template <class _Yty, class _Ty>
struct _SP_pointer_compatible : is_convertible<_Yty*, _Ty*>::type {
    
    
};
template <class _Uty, size_t _Ext>
struct _SP_pointer_compatible<_Uty[_Ext], _Uty[]> : true_type {
    
};
template <class _Uty, size_t _Ext>
struct _SP_pointer_compatible<_Uty[_Ext], const _Uty[]> : true_type {
    
};
template <class _Uty, size_t _Ext>
struct _SP_pointer_compatible<_Uty[_Ext], volatile _Uty[]> : true_type {
    
};
template <class _Uty, size_t _Ext>
struct _SP_pointer_compatible<_Uty[_Ext], const volatile _Uty[]> : true_type {
    
};

template <class _Ux>
struct _Temporary_owner {
    _Ux* _Ptr;

    explicit _Temporary_owner(_Ux* const _Ptr_) noexcept : _Ptr(_Ptr_) {}
    _Temporary_owner(const _Temporary_owner&) = delete;
    _Temporary_owner& operator=(const _Temporary_owner&) = delete;
    ~_Temporary_owner() {
        delete _Ptr;
    }
};

template <class _UxptrOrNullptr, class _Dx>
struct _Temporary_owner_del {
    _UxptrOrNullptr _Ptr;
    _Dx& _Dt;
    bool _Call_deleter = true;

    explicit _Temporary_owner_del(const _UxptrOrNullptr _Ptr_, _Dx& _Dt_) noexcept : _Ptr(_Ptr_), _Dt(_Dt_) {}
    _Temporary_owner_del(const _Temporary_owner_del&) = delete;
    _Temporary_owner_del& operator=(const _Temporary_owner_del&) = delete;
    ~_Temporary_owner_del() {
        if (_Call_deleter) {
            _Dt(_Ptr);
        }
    }
};

template <class _Ty>
class shared_ptr : public _Ptr_base<_Ty> { 
private:
    using _Mybase = _Ptr_base<_Ty>;

public:
    using typename _Mybase::element_type;


    using weak_type = weak_ptr<_Ty>;
#line 1503 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

    constexpr shared_ptr() noexcept = default;

    constexpr shared_ptr(nullptr_t) noexcept {} 

    template <class _Ux,
        enable_if_t<conjunction_v<conditional_t<is_array_v<_Ty>, _Can_array_delete<_Ux>, _Can_scalar_delete<_Ux>>,
                        _SP_convertible<_Ux, _Ty>>,
            int> = 0>
    explicit shared_ptr(_Ux* _Px) { 
        if constexpr (is_array_v<_Ty>) {
            _Setpd(_Px, default_delete<_Ux[]>{});
        } else {
            _Temporary_owner<_Ux> _Owner(_Px);
            _Set_ptr_rep_and_enable_shared(_Owner._Ptr, new _Ref_count<_Ux>(_Owner._Ptr));
            _Owner._Ptr = nullptr;
        }
    }

    template <class _Ux, class _Dx,
        enable_if_t<conjunction_v<is_move_constructible<_Dx>, _Can_call_function_object<_Dx&, _Ux*&>,
                        _SP_convertible<_Ux, _Ty>>,
            int> = 0>
    shared_ptr(_Ux* _Px, _Dx _Dt) { 
        _Setpd(_Px, ::std:: move(_Dt));
    }

    template <class _Ux, class _Dx, class _Alloc,
        enable_if_t<conjunction_v<is_move_constructible<_Dx>, _Can_call_function_object<_Dx&, _Ux*&>,
                        _SP_convertible<_Ux, _Ty>>,
            int> = 0>
    shared_ptr(_Ux* _Px, _Dx _Dt, _Alloc _Ax) { 
        _Setpda(_Px, ::std:: move(_Dt), _Ax);
    }

    template <class _Dx,
        enable_if_t<conjunction_v<is_move_constructible<_Dx>, _Can_call_function_object<_Dx&, nullptr_t&>>, int> = 0>
    shared_ptr(nullptr_t, _Dx _Dt) { 
        _Setpd(nullptr, ::std:: move(_Dt));
    }

    template <class _Dx, class _Alloc,
        enable_if_t<conjunction_v<is_move_constructible<_Dx>, _Can_call_function_object<_Dx&, nullptr_t&>>, int> = 0>
    shared_ptr(nullptr_t, _Dx _Dt, _Alloc _Ax) { 
        _Setpda(nullptr, ::std:: move(_Dt), _Ax);
    }

    template <class _Ty2>
    shared_ptr(const shared_ptr<_Ty2>& _Right, element_type* _Px) noexcept {
        
        this->_Alias_construct_from(_Right, _Px);
    }

    template <class _Ty2>
    shared_ptr(shared_ptr<_Ty2>&& _Right, element_type* _Px) noexcept {
        
        this->_Alias_move_construct_from(::std:: move(_Right), _Px);
    }

    shared_ptr(const shared_ptr& _Other) noexcept { 
        this->_Copy_construct_from(_Other);
    }

    template <class _Ty2, enable_if_t<_SP_pointer_compatible<_Ty2, _Ty>::value, int> = 0>
    shared_ptr(const shared_ptr<_Ty2>& _Other) noexcept {
        
        this->_Copy_construct_from(_Other);
    }

    shared_ptr(shared_ptr&& _Right) noexcept { 
        this->_Move_construct_from(::std:: move(_Right));
    }

    template <class _Ty2, enable_if_t<_SP_pointer_compatible<_Ty2, _Ty>::value, int> = 0>
    shared_ptr(shared_ptr<_Ty2>&& _Right) noexcept { 
        this->_Move_construct_from(::std:: move(_Right));
    }

    template <class _Ty2, enable_if_t<_SP_pointer_compatible<_Ty2, _Ty>::value, int> = 0>
    explicit shared_ptr(const weak_ptr<_Ty2>& _Other) { 
        if (!this->_Construct_from_weak(_Other)) {
            _Throw_bad_weak_ptr();
        }
    }


#line 1596 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

    template <class _Ux, class _Dx,
        enable_if_t<conjunction_v<_SP_pointer_compatible<_Ux, _Ty>,
                        is_convertible<typename unique_ptr<_Ux, _Dx>::pointer, element_type*>>,
            int> = 0>
    shared_ptr(unique_ptr<_Ux, _Dx>&& _Other) {
        using _Fancy_t   = typename unique_ptr<_Ux, _Dx>::pointer;
        using _Raw_t     = typename unique_ptr<_Ux, _Dx>::element_type*;
        using _Deleter_t = conditional_t<is_reference_v<_Dx>, decltype(::std:: ref(_Other.get_deleter())), _Dx>;

        const _Fancy_t _Fancy = _Other.get();

        if (_Fancy) {
            const _Raw_t _Raw = _Fancy;
            const auto _Rx =
                new _Ref_count_resource<_Fancy_t, _Deleter_t>(_Fancy, ::std:: forward<_Dx>(_Other.get_deleter()));
            _Set_ptr_rep_and_enable_shared(_Raw, _Rx);
            _Other.release();
        }
    }

    ~shared_ptr() noexcept { 
        this->_Decref();
    }

    shared_ptr& operator=(const shared_ptr& _Right) noexcept {
        shared_ptr(_Right).swap(*this);
        return *this;
    }

    template <class _Ty2>
    shared_ptr& operator=(const shared_ptr<_Ty2>& _Right) noexcept {
        shared_ptr(_Right).swap(*this);
        return *this;
    }

    shared_ptr& operator=(shared_ptr&& _Right) noexcept { 
        shared_ptr(::std:: move(_Right)).swap(*this);
        return *this;
    }

    template <class _Ty2>
    shared_ptr& operator=(shared_ptr<_Ty2>&& _Right) noexcept { 
        shared_ptr(::std:: move(_Right)).swap(*this);
        return *this;
    }


#line 1650 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

    template <class _Ux, class _Dx>
    shared_ptr& operator=(unique_ptr<_Ux, _Dx>&& _Right) { 
        shared_ptr(::std:: move(_Right)).swap(*this);
        return *this;
    }

    void swap(shared_ptr& _Other) noexcept {
        this->_Swap(_Other);
    }

    void reset() noexcept { 
        shared_ptr().swap(*this);
    }

    template <class _Ux>
    void reset(_Ux* _Px) { 
        shared_ptr(_Px).swap(*this);
    }

    template <class _Ux, class _Dx>
    void reset(_Ux* _Px, _Dx _Dt) { 
        shared_ptr(_Px, _Dt).swap(*this);
    }

    template <class _Ux, class _Dx, class _Alloc>
    void reset(_Ux* _Px, _Dx _Dt, _Alloc _Ax) { 
        shared_ptr(_Px, _Dt, _Ax).swap(*this);
    }

    using _Mybase::get;

    template <class _Ty2 = _Ty, enable_if_t<!disjunction_v<is_array<_Ty2>, is_void<_Ty2>>, int> = 0>
    [[nodiscard]] _Ty2& operator*() const noexcept {
        return *get();
    }

    template <class _Ty2 = _Ty, enable_if_t<!is_array_v<_Ty2>, int> = 0>
    [[nodiscard]] _Ty2* operator->() const noexcept {
        return get();
    }

    template <class _Ty2 = _Ty, class _Elem = element_type, enable_if_t<is_array_v<_Ty2>, int> = 0>
    [[nodiscard]] _Elem& operator[](ptrdiff_t _Idx) const noexcept  {
        return get()[_Idx];
    }


#line 1703 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

    explicit operator bool() const noexcept {
        return get() != nullptr;
    }

private:
    template <class _UxptrOrNullptr, class _Dx>
    void _Setpd(const _UxptrOrNullptr _Px, _Dx _Dt) { 
        _Temporary_owner_del<_UxptrOrNullptr, _Dx> _Owner(_Px, _Dt);
        _Set_ptr_rep_and_enable_shared(
            _Owner._Ptr, new _Ref_count_resource<_UxptrOrNullptr, _Dx>(_Owner._Ptr, ::std:: move(_Dt)));
        _Owner._Call_deleter = false;
    }

    template <class _UxptrOrNullptr, class _Dx, class _Alloc>
    void _Setpda(const _UxptrOrNullptr _Px, _Dx _Dt, _Alloc _Ax) { 
        using _Alref_alloc = _Rebind_alloc_t<_Alloc, _Ref_count_resource_alloc<_UxptrOrNullptr, _Dx, _Alloc>>;

        _Temporary_owner_del<_UxptrOrNullptr, _Dx> _Owner(_Px, _Dt);
        _Alref_alloc _Alref(_Ax);
        _Alloc_construct_ptr<_Alref_alloc> _Constructor(_Alref);
        _Constructor._Allocate();
        _Construct_in_place(*_Constructor._Ptr, _Owner._Ptr, ::std:: move(_Dt), _Ax);
        _Set_ptr_rep_and_enable_shared(_Owner._Ptr, _Unfancy(_Constructor._Ptr));
        _Constructor._Ptr    = nullptr;
        _Owner._Call_deleter = false;
    }


    template <class _Ty0, class... _Types>
    friend enable_if_t<!is_array_v<_Ty0>, shared_ptr<_Ty0>> make_shared(_Types&&... _Args);

    template <class _Ty0, class _Alloc, class... _Types>
    friend enable_if_t<!is_array_v<_Ty0>, shared_ptr<_Ty0>> allocate_shared(const _Alloc& _Al_arg, _Types&&... _Args);

    template <class _Ty0>
    friend enable_if_t<is_bounded_array_v<_Ty0>, shared_ptr<_Ty0>> make_shared();

    template <class _Ty0, class _Alloc>
    friend enable_if_t<is_bounded_array_v<_Ty0>, shared_ptr<_Ty0>> allocate_shared(const _Alloc& _Al_arg);

    template <class _Ty0>
    friend enable_if_t<is_bounded_array_v<_Ty0>, shared_ptr<_Ty0>> make_shared(const remove_extent_t<_Ty0>& _Val);

    template <class _Ty0, class _Alloc>
    friend enable_if_t<is_bounded_array_v<_Ty0>, shared_ptr<_Ty0>> allocate_shared(
        const _Alloc& _Al_arg, const remove_extent_t<_Ty0>& _Val);

    template <class _Ty0>
    friend enable_if_t<!is_unbounded_array_v<_Ty0>, shared_ptr<_Ty0>> make_shared_for_overwrite();

    template <class _Ty0, class _Alloc>
    friend enable_if_t<!is_unbounded_array_v<_Ty0>, shared_ptr<_Ty0>> allocate_shared_for_overwrite(
        const _Alloc& _Al_arg);

    template <class _Ty0, class... _ArgTypes>
    friend shared_ptr<_Ty0> _Make_shared_unbounded_array(size_t _Count, const _ArgTypes&... _Args);

    template <class _Ty0, class _Alloc, class... _ArgTypes>
    friend shared_ptr<_Ty0> _Allocate_shared_unbounded_array(
        const _Alloc& _Al, size_t _Count, const _ArgTypes&... _Args);


#line 1771 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

    template <class _Ux>
    void _Set_ptr_rep_and_enable_shared(_Ux* const _Px, _Ref_count_base* const _Rx) noexcept { 
        this->_Ptr = _Px;
        this->_Rep = _Rx;
        if constexpr (conjunction_v<negation<is_array<_Ty>>, negation<is_volatile<_Ux>>, _Can_enable_shared<_Ux>>) {
            if (_Px && _Px->_Wptr.expired()) {
                _Px->_Wptr = shared_ptr<remove_cv_t<_Ux>>(*this, const_cast<remove_cv_t<_Ux>*>(_Px));
            }
        }
    }

    void _Set_ptr_rep_and_enable_shared(nullptr_t, _Ref_count_base* const _Rx) noexcept { 
        this->_Ptr = nullptr;
        this->_Rep = _Rx;
    }
};


template <class _Ty>
shared_ptr(weak_ptr<_Ty>) -> shared_ptr<_Ty>;

template <class _Ty, class _Dx>
shared_ptr(unique_ptr<_Ty, _Dx>) -> shared_ptr<_Ty>;
#line 1796 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

template <class _Ty1, class _Ty2>
[[nodiscard]] bool operator==(const shared_ptr<_Ty1>& _Left, const shared_ptr<_Ty2>& _Right) noexcept {
    return _Left.get() == _Right.get();
}


template <class _Ty1, class _Ty2>
[[nodiscard]] strong_ordering operator<=>(const shared_ptr<_Ty1>& _Left, const shared_ptr<_Ty2>& _Right) noexcept {
    return _Left.get() <=> _Right.get();
}


#line 1833 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

template <class _Ty>
[[nodiscard]] bool operator==(const shared_ptr<_Ty>& _Left, nullptr_t) noexcept {
    return _Left.get() == nullptr;
}


template <class _Ty>
[[nodiscard]] strong_ordering operator<=>(const shared_ptr<_Ty>& _Left, nullptr_t) noexcept {
    return _Left.get() <=> static_cast<typename shared_ptr<_Ty>::element_type*>(nullptr);
}


#line 1900 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

template <class _Elem, class _Traits, class _Ty>
basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Out, const shared_ptr<_Ty>& _Px) {
    
    return _Out << _Px.get();
}

template <class _Ty>
void swap(shared_ptr<_Ty>& _Left, shared_ptr<_Ty>& _Right) noexcept {
    _Left.swap(_Right);
}

template <class _Ty1, class _Ty2>
[[nodiscard]] shared_ptr<_Ty1> static_pointer_cast(const shared_ptr<_Ty2>& _Other) noexcept {
    
    const auto _Ptr = static_cast<typename shared_ptr<_Ty1>::element_type*>(_Other.get());
    return shared_ptr<_Ty1>(_Other, _Ptr);
}

template <class _Ty1, class _Ty2>
[[nodiscard]] shared_ptr<_Ty1> static_pointer_cast(shared_ptr<_Ty2>&& _Other) noexcept {
    
    const auto _Ptr = static_cast<typename shared_ptr<_Ty1>::element_type*>(_Other.get());
    return shared_ptr<_Ty1>(::std:: move(_Other), _Ptr);
}

template <class _Ty1, class _Ty2>
[[nodiscard]] shared_ptr<_Ty1> const_pointer_cast(const shared_ptr<_Ty2>& _Other) noexcept {
    
    const auto _Ptr = const_cast<typename shared_ptr<_Ty1>::element_type*>(_Other.get());
    return shared_ptr<_Ty1>(_Other, _Ptr);
}

template <class _Ty1, class _Ty2>
[[nodiscard]] shared_ptr<_Ty1> const_pointer_cast(shared_ptr<_Ty2>&& _Other) noexcept {
    
    const auto _Ptr = const_cast<typename shared_ptr<_Ty1>::element_type*>(_Other.get());
    return shared_ptr<_Ty1>(::std:: move(_Other), _Ptr);
}

template <class _Ty1, class _Ty2>
[[nodiscard]] shared_ptr<_Ty1> reinterpret_pointer_cast(const shared_ptr<_Ty2>& _Other) noexcept {
    
    const auto _Ptr = reinterpret_cast<typename shared_ptr<_Ty1>::element_type*>(_Other.get());
    return shared_ptr<_Ty1>(_Other, _Ptr);
}

template <class _Ty1, class _Ty2>
[[nodiscard]] shared_ptr<_Ty1> reinterpret_pointer_cast(shared_ptr<_Ty2>&& _Other) noexcept {
    
    const auto _Ptr = reinterpret_cast<typename shared_ptr<_Ty1>::element_type*>(_Other.get());
    return shared_ptr<_Ty1>(::std:: move(_Other), _Ptr);
}


template <class _Ty1, class _Ty2>
[[nodiscard]] shared_ptr<_Ty1> dynamic_pointer_cast(const shared_ptr<_Ty2>& _Other) noexcept {
    
    const auto _Ptr = dynamic_cast<typename shared_ptr<_Ty1>::element_type*>(_Other.get());

    if (_Ptr) {
        return shared_ptr<_Ty1>(_Other, _Ptr);
    }

    return {};
}

template <class _Ty1, class _Ty2>
[[nodiscard]] shared_ptr<_Ty1> dynamic_pointer_cast(shared_ptr<_Ty2>&& _Other) noexcept {
    
    const auto _Ptr = dynamic_cast<typename shared_ptr<_Ty1>::element_type*>(_Other.get());

    if (_Ptr) {
        return shared_ptr<_Ty1>(::std:: move(_Other), _Ptr);
    }

    return {};
}


#line 1984 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"


template <class _Dx, class _Ty>
[[nodiscard]] _Dx* get_deleter(const shared_ptr<_Ty>& _Sx) noexcept {
    
    if (_Sx._Rep) {
        return static_cast<_Dx*>(_Sx._Rep->_Get_deleter(typeid(_Dx)));
    }

    return nullptr;
}


#line 1999 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"


struct _For_overwrite_tag {
    explicit _For_overwrite_tag() = default;
};
#line 2005 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

template <class _Ty>
class _Ref_count_obj2 : public _Ref_count_base { 
public:
    template <class... _Types>
    explicit _Ref_count_obj2(_Types&&... _Args) : _Ref_count_base() {

        if constexpr (sizeof...(_Types) == 1 && (is_same_v<_For_overwrite_tag, remove_cvref_t<_Types>> && ...)) {
            _Default_construct_in_place(_Storage._Value);
            ((void) _Args, ...);
        } else
#line 2017 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"
        {
            _Construct_in_place(_Storage._Value, ::std:: forward<_Types>(_Args)...);
        }
    }

    ~_Ref_count_obj2() noexcept override { 
        

    }

    union {
        _Wrap<_Ty> _Storage;
    };

private:
    void _Destroy() noexcept override { 
        _Destroy_in_place(_Storage._Value);
    }

    void _Delete_this() noexcept override { 
        delete this;
    }
};


template <size_t _Align>
struct _Alignas_storage_unit {
    alignas(_Align) char _Space[_Align];
};

enum class _Check_overflow : bool { _Nope, _Yes };

template <class _Refc, _Check_overflow _Check>
[[nodiscard]] size_t _Calculate_bytes_for_flexible_array(const size_t _Count) noexcept(_Check == _Check_overflow::_Nope) {
    constexpr size_t _Align = alignof(_Refc);

    size_t _Bytes = sizeof(_Refc); 

    if (_Count > 1) {
        constexpr size_t _Element_size = sizeof(typename _Refc::_Element_type);

        size_t _Extra_bytes;

        if constexpr (_Check == _Check_overflow::_Yes) {
            _Extra_bytes = _Get_size_of_n<_Element_size>(_Count - 1); 

            if (_Extra_bytes > static_cast<size_t>(-1) - _Bytes - (_Align - 1)) { 
                _Throw_bad_array_new_length(); 
            }
        } else {
            _Extra_bytes = _Element_size * (_Count - 1);
        }

        _Bytes += _Extra_bytes;

        _Bytes = (_Bytes + _Align - 1) & ~(_Align - 1);
    }


    return _Bytes;
}

template <class _Refc>
[[nodiscard]] _Refc* _Allocate_flexible_array(const size_t _Count) {
    const size_t _Bytes     = _Calculate_bytes_for_flexible_array<_Refc, _Check_overflow::_Yes>(_Count);
    constexpr size_t _Align = alignof(_Refc);

    if constexpr (_Align > 8u) {
        return static_cast<_Refc*>(::operator new (_Bytes, align_val_t{_Align}));
    } else
#line 2095 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"
    {
        return static_cast<_Refc*>(::operator new(_Bytes));
    }
}

template <class _Refc>
void _Deallocate_flexible_array(_Refc* const _Ptr) noexcept {
    constexpr size_t _Align = alignof(_Refc);

    if constexpr (_Align > 8u) {
        ::operator delete (static_cast<void*>(_Ptr), align_val_t{_Align});
    } else
#line 2108 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"
    {
        ::operator delete(static_cast<void*>(_Ptr));
    }
}

template <class _NoThrowIt>
struct [[nodiscard]] _Uninitialized_rev_destroying_backout {
    
    _NoThrowIt _First;
    _NoThrowIt _Last;

    explicit _Uninitialized_rev_destroying_backout(_NoThrowIt _Dest) noexcept : _First(_Dest), _Last(_Dest) {}

    _Uninitialized_rev_destroying_backout(const _Uninitialized_rev_destroying_backout&) = delete;
    _Uninitialized_rev_destroying_backout& operator=(const _Uninitialized_rev_destroying_backout&) = delete;

    ~_Uninitialized_rev_destroying_backout() {
        while (_Last != _First) {
            --_Last;
            ::std:: destroy_at(::std:: addressof(*_Last));
        }
    }

    template <class... _Types>
    void _Emplace_back(_Types&&... _Vals) { 
        _Construct_in_place(*_Last, ::std:: forward<_Types>(_Vals)...);
        ++_Last;
    }

    void _Emplace_back_for_overwrite() {
        _Default_construct_in_place(*_Last);
        ++_Last;
    }

    _NoThrowIt _Release() noexcept { 
        _First = _Last;
        return _Last;
    }
};

template <class _Ty>
void _Reverse_destroy_multidimensional_n(_Ty* const _Arr, size_t _Size) noexcept {
    while (_Size > 0) {
        --_Size;
        if constexpr (is_array_v<_Ty>) {
            _Reverse_destroy_multidimensional_n(_Arr[_Size], extent_v<_Ty>);
        } else {
            _Destroy_in_place(_Arr[_Size]);
        }
    }
}

template <class _Ty>
struct [[nodiscard]] _Reverse_destroy_multidimensional_n_guard {
    _Ty* _Target;
    size_t _Index;

    ~_Reverse_destroy_multidimensional_n_guard() {
        if (_Target) {
            _Reverse_destroy_multidimensional_n(_Target, _Index);
        }
    }
};

template <class _Ty, size_t _Size>
void _Uninitialized_copy_multidimensional(const _Ty (&_In)[_Size], _Ty (&_Out)[_Size]) {
    if constexpr (is_trivial_v<_Ty>) {
        _Copy_memmove(_In, _In + _Size, _Out);
    } else if constexpr (is_array_v<_Ty>) {
        _Reverse_destroy_multidimensional_n_guard<_Ty> _Guard{_Out, 0};
        for (size_t& _Idx = _Guard._Index; _Idx < _Size; ++_Idx) {
            _Uninitialized_copy_multidimensional(_In[_Idx], _Out[_Idx]);
        }
        _Guard._Target = nullptr;
    } else {
        _Uninitialized_rev_destroying_backout _Backout{_Out};
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Backout._Emplace_back(_In[_Idx]);
        }
        _Backout._Release();
    }
}

template <class _Ty>
void _Uninitialized_value_construct_multidimensional_n(_Ty* const _Out, const size_t _Size) {
    using _Item = remove_all_extents_t<_Ty>;
    if constexpr (_Use_memset_value_construct_v<_Item*>) {
        _Zero_range(_Out, _Out + _Size);
    } else if constexpr (is_array_v<_Ty>) {
        _Reverse_destroy_multidimensional_n_guard<_Ty> _Guard{_Out, 0};
        for (size_t& _Idx = _Guard._Index; _Idx < _Size; ++_Idx) {
            _Uninitialized_value_construct_multidimensional_n(_Out[_Idx], extent_v<_Ty>);
        }
        _Guard._Target = nullptr;
    } else {
        _Uninitialized_rev_destroying_backout _Backout{_Out};
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Backout._Emplace_back();
        }
        _Backout._Release();
    }
}

template <class _Ty>
void _Uninitialized_default_construct_multidimensional_n(_Ty* const _Out, const size_t _Size) {
    if constexpr (!is_trivially_default_constructible_v<_Ty>) {
        if constexpr (is_array_v<_Ty>) {
            _Reverse_destroy_multidimensional_n_guard<_Ty> _Guard{_Out, 0};
            for (size_t& _Idx = _Guard._Index; _Idx < _Size; ++_Idx) {
                _Uninitialized_default_construct_multidimensional_n(_Out[_Idx], extent_v<_Ty>);
            }
            _Guard._Target = nullptr;
        } else {
            _Uninitialized_rev_destroying_backout _Backout{_Out};
            for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
                _Backout._Emplace_back_for_overwrite();
            }
            _Backout._Release();
        }
    }
}

template <class _Ty>
void _Uninitialized_fill_multidimensional_n(_Ty* const _Out, const size_t _Size, const _Ty& _Val) {
    if constexpr (is_array_v<_Ty>) {
        _Reverse_destroy_multidimensional_n_guard<_Ty> _Guard{_Out, 0};
        for (size_t& _Idx = _Guard._Index; _Idx < _Size; ++_Idx) {
            _Uninitialized_copy_multidimensional(_Val, _Out[_Idx]); 
        }
        _Guard._Target = nullptr;
    } else if constexpr (_Fill_memset_is_safe<_Ty*, _Ty>) {
        _Fill_memset(_Out, _Val, _Size);
    } else {
        if constexpr (_Fill_zero_memset_is_safe<_Ty*, _Ty>) {
            if (_Is_all_bits_zero(_Val)) {
                _Fill_zero_memset(_Out, _Size);
                return;
            }
        }
        _Uninitialized_rev_destroying_backout _Backout{_Out};
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Backout._Emplace_back(_Val);
        }
        _Backout._Release();
    }
}

template <class _Ty, bool = is_trivially_destructible_v<remove_extent_t<_Ty>>>
class _Ref_count_unbounded_array : public _Ref_count_base {
    
public:
    static_assert(is_unbounded_array_v<_Ty>);

    using _Element_type = remove_extent_t<_Ty>;

    explicit _Ref_count_unbounded_array(const size_t _Count) : _Ref_count_base() {
        _Uninitialized_value_construct_multidimensional_n(_Get_ptr(), _Count);
    }

    template <class _Arg>
    explicit _Ref_count_unbounded_array(const size_t _Count, const _Arg& _Val) : _Ref_count_base() {
        if constexpr (is_same_v<_For_overwrite_tag, _Arg>) {
            _Uninitialized_default_construct_multidimensional_n(_Get_ptr(), _Count);
        } else {
            _Uninitialized_fill_multidimensional_n(_Get_ptr(), _Count, _Val);
        }
    }

    [[nodiscard]] auto _Get_ptr() noexcept {
        return ::std:: addressof(_Storage._Value);
    }

private:
    union {
        _Wrap<_Element_type> _Storage; 
    };

    ~_Ref_count_unbounded_array() noexcept override { 
        

    }

    void _Destroy() noexcept override { 
        
    }

    void _Delete_this() noexcept override { 
        this->~_Ref_count_unbounded_array();
        _Deallocate_flexible_array(this);
    }
};

template <class _Ty>
class _Ref_count_unbounded_array<_Ty, false> : public _Ref_count_base {
    
public:
    static_assert(is_unbounded_array_v<_Ty>);

    using _Element_type = remove_extent_t<_Ty>;

    explicit _Ref_count_unbounded_array(const size_t _Count) : _Ref_count_base(), _Size(_Count) {
        _Uninitialized_value_construct_multidimensional_n(_Get_ptr(), _Size);
    }

    template <class _Arg>
    explicit _Ref_count_unbounded_array(const size_t _Count, const _Arg& _Val) : _Ref_count_base(), _Size(_Count) {
        if constexpr (is_same_v<_For_overwrite_tag, _Arg>) {
            _Uninitialized_default_construct_multidimensional_n(_Get_ptr(), _Size);
        } else {
            _Uninitialized_fill_multidimensional_n(_Get_ptr(), _Size, _Val);
        }
    }

    [[nodiscard]] auto _Get_ptr() noexcept {
        return ::std:: addressof(_Storage._Value);
    }

private:
    size_t _Size;

    union {
        _Wrap<_Element_type> _Storage; 
    };

    ~_Ref_count_unbounded_array() noexcept override { 
        

    }

    void _Destroy() noexcept override { 
        _Reverse_destroy_multidimensional_n(_Get_ptr(), _Size);
    }

    void _Delete_this() noexcept override { 
        this->~_Ref_count_unbounded_array();
        _Deallocate_flexible_array(this);
    }
};

template <class _Ty>
class _Ref_count_bounded_array : public _Ref_count_base {
    
public:
    static_assert(is_bounded_array_v<_Ty>);

    _Ref_count_bounded_array() : _Ref_count_base(), _Storage() {} 

    template <class _Arg>
    explicit _Ref_count_bounded_array(const _Arg& _Val) : _Ref_count_base() { 
        if constexpr (is_same_v<_For_overwrite_tag, _Arg>) {
            _Uninitialized_default_construct_multidimensional_n(_Storage._Value, extent_v<_Ty>);
        } else {
            _Uninitialized_fill_multidimensional_n(_Storage._Value, extent_v<_Ty>, _Val);
        }
    }

    union {
        _Wrap<_Ty> _Storage;
    };

private:
    ~_Ref_count_bounded_array() noexcept override { 
        

    }

    void _Destroy() noexcept override { 
        _Destroy_in_place(_Storage); 
    }

    void _Delete_this() noexcept override { 
        delete this;
    }
};
#line 2386 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

template <class _Ty,
    bool = is_empty_v<_Ty> && !is_final_v<_Ty>>
class _Ebco_base : private _Ty { 
private:
    using _Mybase = _Ty; 

protected:
    template <class _Other, enable_if_t<!is_same_v<_Remove_cvref_t<_Other>, _Ebco_base>, int> = 0>
    constexpr explicit _Ebco_base(_Other&& _Val) noexcept(is_nothrow_constructible_v<_Ty, _Other>)
        : _Ty(::std:: forward<_Other>(_Val)) {}

    constexpr _Ty& _Get_val() noexcept {
        return *this;
    }

    constexpr const _Ty& _Get_val() const noexcept {
        return *this;
    }
};

template <class _Ty>
class _Ebco_base<_Ty, false> { 
private:
    _Ty _Myval;

protected:
    template <class _Other, enable_if_t<!is_same_v<_Remove_cvref_t<_Other>, _Ebco_base>, int> = 0>
    constexpr explicit _Ebco_base(_Other&& _Val) noexcept(is_nothrow_constructible_v<_Ty, _Other>)
        : _Myval(::std:: forward<_Other>(_Val)) {}

    constexpr _Ty& _Get_val() noexcept {
        return _Myval;
    }

    constexpr const _Ty& _Get_val() const noexcept {
        return _Myval;
    }
};

template <class _Ty, class _Alloc>
class _Ref_count_obj_alloc3 : public _Ebco_base<_Rebind_alloc_t<_Alloc, _Ty>>, public _Ref_count_base {
    
private:
    static_assert(is_same_v<_Ty, remove_cv_t<_Ty>>, "allocate_shared should remove_cv_t");

    using _Rebound = _Rebind_alloc_t<_Alloc, _Ty>;

public:
    template <class... _Types>
    explicit _Ref_count_obj_alloc3(const _Alloc& _Al_arg, _Types&&... _Args)
        : _Ebco_base<_Rebound>(_Al_arg), _Ref_count_base() {

        if constexpr (sizeof...(_Types) == 1 && (is_same_v<_For_overwrite_tag, remove_cvref_t<_Types>> && ...)) {
            _Default_construct_in_place(_Storage._Value);
            ((void) _Args, ...);
        } else
#line 2444 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"
        {
            allocator_traits<_Rebound>::construct(
                this->_Get_val(), ::std:: addressof(_Storage._Value), ::std:: forward<_Types>(_Args)...);
        }
    }

    union {
        _Wrap<_Ty> _Storage;
    };

private:
    ~_Ref_count_obj_alloc3() noexcept override { 
        

    }

    void _Destroy() noexcept override { 
        allocator_traits<_Rebound>::destroy(this->_Get_val(), ::std:: addressof(_Storage._Value));
    }

    void _Delete_this() noexcept override { 
        _Rebind_alloc_t<_Alloc, _Ref_count_obj_alloc3> _Al(this->_Get_val());
        this->~_Ref_count_obj_alloc3();
        _Deallocate_plain(_Al, this);
    }
};


template <class _Alloc>
class [[nodiscard]] _Uninitialized_rev_destroying_backout_al {
    

private:
    using pointer = _Alloc_ptr_t<_Alloc>;

public:
    _Uninitialized_rev_destroying_backout_al(pointer _Dest, _Alloc& _Al_) noexcept
        : _First(_Dest), _Last(_Dest), _Al(_Al_) {}

    _Uninitialized_rev_destroying_backout_al(const _Uninitialized_rev_destroying_backout_al&) = delete;
    _Uninitialized_rev_destroying_backout_al& operator=(const _Uninitialized_rev_destroying_backout_al&) = delete;

    ~_Uninitialized_rev_destroying_backout_al() {
        while (_Last != _First) {
            --_Last;
            allocator_traits<_Alloc>::destroy(_Al, _Last);
        }
    }

    template <class... _Types>
    void _Emplace_back(_Types&&... _Vals) { 
        allocator_traits<_Alloc>::construct(_Al, _Unfancy(_Last), ::std:: forward<_Types>(_Vals)...);
        ++_Last;
    }

    pointer _Release() noexcept { 
        _First = _Last;
        return _Last;
    }

private:
    pointer _First;
    pointer _Last;
    _Alloc& _Al;
};

template <class _Ty, class _Alloc>
void _Reverse_destroy_multidimensional_n_al(_Ty* const _Arr, size_t _Size, _Alloc& _Al) noexcept {
    while (_Size > 0) {
        --_Size;
        if constexpr (is_array_v<_Ty>) {
            _Reverse_destroy_multidimensional_n_al(_Arr[_Size], extent_v<_Ty>, _Al);
        } else {
            allocator_traits<_Alloc>::destroy(_Al, _Arr + _Size);
        }
    }
}

template <class _Ty, class _Alloc>
struct [[nodiscard]] _Reverse_destroy_multidimensional_n_al_guard {
    _Ty* _Target;
    size_t _Index;
    _Alloc& _Al;

    ~_Reverse_destroy_multidimensional_n_al_guard() {
        if (_Target) {
            _Reverse_destroy_multidimensional_n_al(_Target, _Index, _Al);
        }
    }
};

template <class _Ty, size_t _Size, class _Alloc>
void _Uninitialized_copy_multidimensional_al(const _Ty (&_In)[_Size], _Ty (&_Out)[_Size], _Alloc& _Al) {
    using _Item = remove_all_extents_t<_Ty>;
    if constexpr (conjunction_v<is_trivial<_Ty>, _Uses_default_construct<_Alloc, _Item*, const _Item&>>) {
        _Copy_memmove(_In, _In + _Size, _Out);
    } else if constexpr (is_array_v<_Ty>) {
        _Reverse_destroy_multidimensional_n_al_guard<_Ty, _Alloc> _Guard{_Out, 0, _Al};
        for (size_t& _Idx = _Guard._Index; _Idx < _Size; ++_Idx) {
            _Uninitialized_copy_multidimensional_al(_In[_Idx], _Out[_Idx], _Al);
        }
        _Guard._Target = nullptr;
    } else {
        _Uninitialized_rev_destroying_backout_al _Backout{_Out, _Al};
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Backout._Emplace_back(_In[_Idx]);
        }
        _Backout._Release();
    }
}

template <class _Ty, class _Alloc>
void _Uninitialized_value_construct_multidimensional_n_al(_Ty* const _Out, const size_t _Size, _Alloc& _Al) {
    using _Item = remove_all_extents_t<_Ty>;
    if constexpr (_Use_memset_value_construct_v<_Item*> && _Uses_default_construct<_Alloc, _Item*>::value) {
        _Zero_range(_Out, _Out + _Size);
    } else if constexpr (is_array_v<_Ty>) {
        _Reverse_destroy_multidimensional_n_al_guard<_Ty, _Alloc> _Guard{_Out, 0, _Al};
        for (size_t& _Idx = _Guard._Index; _Idx < _Size; ++_Idx) {
            _Uninitialized_value_construct_multidimensional_n_al(_Out[_Idx], extent_v<_Ty>, _Al);
        }
        _Guard._Target = nullptr;
    } else {
        _Uninitialized_rev_destroying_backout_al _Backout{_Out, _Al};
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Backout._Emplace_back();
        }
        _Backout._Release();
    }
}

template <class _Ty, class _Alloc>
void _Uninitialized_fill_multidimensional_n_al(_Ty* const _Out, const size_t _Size, const _Ty& _Val, _Alloc& _Al) {
    if constexpr (is_array_v<_Ty>) {
        _Reverse_destroy_multidimensional_n_al_guard<_Ty, _Alloc> _Guard{_Out, 0, _Al};
        for (size_t& _Idx = _Guard._Index; _Idx < _Size; ++_Idx) {
            _Uninitialized_copy_multidimensional_al(_Val, _Out[_Idx], _Al); 
        }
        _Guard._Target = nullptr;
    } else if constexpr (_Fill_memset_is_safe<_Ty*, _Ty> && _Uses_default_construct<_Alloc, _Ty*, const _Ty&>::value) {
        _Fill_memset(_Out, _Val, _Size);
    } else {
        if constexpr (_Fill_zero_memset_is_safe<_Ty*,
                          _Ty> && _Uses_default_construct<_Alloc, _Ty*, const _Ty&>::value) {
            if (_Is_all_bits_zero(_Val)) {
                _Fill_zero_memset(_Out, _Size);
                return;
            }
        }
        _Uninitialized_rev_destroying_backout_al _Backout{_Out, _Al};
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Backout._Emplace_back(_Val);
        }
        _Backout._Release();
    }
}

template <class _Ty, class _Alloc>
class _Ref_count_unbounded_array_alloc : public _Ebco_base<_Rebind_alloc_t<_Alloc, remove_all_extents_t<_Ty>>>,
                                         public _Ref_count_base {
    
private:
    static_assert(is_unbounded_array_v<_Ty>);
    static_assert(is_same_v<_Ty, remove_cv_t<_Ty>>, "allocate_shared should remove_cv_t");

    using _Item    = remove_all_extents_t<_Ty>;
    using _Rebound = _Rebind_alloc_t<_Alloc, _Item>;

public:
    using _Element_type = remove_extent_t<_Ty>;

    explicit _Ref_count_unbounded_array_alloc(const _Alloc& _Al_arg, const size_t _Count)
        : _Ebco_base<_Rebound>(_Al_arg), _Ref_count_base(), _Size(_Count) {
        _Uninitialized_value_construct_multidimensional_n_al(_Get_ptr(), _Size, this->_Get_val());
    }

    template <class _Arg>
    explicit _Ref_count_unbounded_array_alloc(const _Alloc& _Al_arg, const size_t _Count, const _Arg& _Val)
        : _Ebco_base<_Rebound>(_Al_arg), _Ref_count_base(), _Size(_Count) {
        if constexpr (is_same_v<_For_overwrite_tag, _Arg>) {
            _Uninitialized_default_construct_multidimensional_n(_Get_ptr(), _Size); 
        } else {
            _Uninitialized_fill_multidimensional_n_al(_Get_ptr(), _Size, _Val, this->_Get_val());
        }
    }

    [[nodiscard]] auto _Get_ptr() noexcept {
        return ::std:: addressof(_Storage._Value);
    }

private:
    size_t _Size;

    union {
        _Wrap<_Element_type> _Storage; 
    };

    ~_Ref_count_unbounded_array_alloc() noexcept override { 
        

    }

    void _Destroy() noexcept override { 
        if constexpr (!conjunction_v<is_trivially_destructible<_Item>, _Uses_default_destroy<_Rebound, _Item*>>) {
            _Reverse_destroy_multidimensional_n_al(_Get_ptr(), _Size, this->_Get_val());
        }
    }

    void _Delete_this() noexcept override { 
        constexpr size_t _Align = alignof(_Ref_count_unbounded_array_alloc);
        using _Storage          = _Alignas_storage_unit<_Align>;

        _Rebind_alloc_t<_Alloc, _Storage> _Al(this->_Get_val());
        const size_t _Bytes =
            _Calculate_bytes_for_flexible_array<_Ref_count_unbounded_array_alloc, _Check_overflow::_Nope>(_Size);
        const size_t _Storage_units = _Bytes / sizeof(_Storage);

        this->~_Ref_count_unbounded_array_alloc();

        _Al.deallocate(reinterpret_cast<_Storage*>(this), _Storage_units);
    }
};

template <class _Ty, class _Alloc>
class _Ref_count_bounded_array_alloc : public _Ebco_base<_Rebind_alloc_t<_Alloc, remove_all_extents_t<_Ty>>>,
                                       public _Ref_count_base {
    
private:
    static_assert(is_bounded_array_v<_Ty>);
    static_assert(is_same_v<_Ty, remove_cv_t<_Ty>>, "allocate_shared should remove_cv_t");

    using _Item    = remove_all_extents_t<_Ty>;
    using _Rebound = _Rebind_alloc_t<_Alloc, _Item>;

public:
    explicit _Ref_count_bounded_array_alloc(const _Alloc& _Al_arg)
        : _Ebco_base<_Rebound>(_Al_arg), _Ref_count_base() { 
        _Uninitialized_value_construct_multidimensional_n_al(_Storage._Value, extent_v<_Ty>, this->_Get_val());
    }

    template <class _Arg>
    explicit _Ref_count_bounded_array_alloc(const _Alloc& _Al_arg, const _Arg& _Val)
        : _Ebco_base<_Rebound>(_Al_arg), _Ref_count_base() { 
        if constexpr (is_same_v<_For_overwrite_tag, _Arg>) {
            _Uninitialized_default_construct_multidimensional_n(
                _Storage._Value, extent_v<_Ty>); 
        } else {
            _Uninitialized_fill_multidimensional_n_al(_Storage._Value, extent_v<_Ty>, _Val, this->_Get_val());
        }
    }

    union {
        _Wrap<_Ty> _Storage;
    };

private:
    ~_Ref_count_bounded_array_alloc() noexcept override { 
        

    }

    void _Destroy() noexcept override { 
        if constexpr (!conjunction_v<is_trivially_destructible<_Item>, _Uses_default_destroy<_Rebound, _Item*>>) {
            _Reverse_destroy_multidimensional_n_al(_Storage._Value, extent_v<_Ty>, this->_Get_val());
        }
    }

    void _Delete_this() noexcept override { 
        _Rebind_alloc_t<_Alloc, _Ref_count_bounded_array_alloc> _Al(this->_Get_val());
        this->~_Ref_count_bounded_array_alloc();
        _Deallocate_plain(_Al, this);
    }
};
#line 2721 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

template <class _Ty, class... _Types>
[[nodiscard]]

    enable_if_t<!is_array_v<_Ty>, shared_ptr<_Ty>>


#line 2729 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"
    make_shared(_Types&&... _Args) { 
    const auto _Rx = new _Ref_count_obj2<_Ty>(::std:: forward<_Types>(_Args)...);
    shared_ptr<_Ty> _Ret;
    _Ret._Set_ptr_rep_and_enable_shared(::std:: addressof(_Rx->_Storage._Value), _Rx);
    return _Ret;
}


template <class _Refc>
struct [[nodiscard]] _Global_delete_guard {
    _Refc* _Target;

    ~_Global_delete_guard() {
        
        
        if (_Target) {
            _Deallocate_flexible_array(_Target);
        }
    }
};

template <class _Ty, class... _ArgTypes>
[[nodiscard]] shared_ptr<_Ty> _Make_shared_unbounded_array(const size_t _Count, const _ArgTypes&... _Args) {
    
    static_assert(is_unbounded_array_v<_Ty>);
    using _Refc    = _Ref_count_unbounded_array<_Ty>;
    const auto _Rx = _Allocate_flexible_array<_Refc>(_Count);
    _Global_delete_guard<_Refc> _Guard{_Rx};
    ::new (static_cast<void*>(_Rx)) _Refc(_Count, _Args...);
    _Guard._Target = nullptr;
    shared_ptr<_Ty> _Ret;
    _Ret._Set_ptr_rep_and_enable_shared(_Rx->_Get_ptr(), _Rx);
    return _Ret;
}

template <class _Ty>
[[nodiscard]] enable_if_t<is_unbounded_array_v<_Ty>, shared_ptr<_Ty>> make_shared(const size_t _Count) {
    return _Make_shared_unbounded_array<_Ty>(_Count);
}

template <class _Ty>
[[nodiscard]] enable_if_t<is_unbounded_array_v<_Ty>, shared_ptr<_Ty>> make_shared(
    const size_t _Count, const remove_extent_t<_Ty>& _Val) {
    return _Make_shared_unbounded_array<_Ty>(_Count, _Val);
}

template <class _Ty>
[[nodiscard]] enable_if_t<is_bounded_array_v<_Ty>, shared_ptr<_Ty>> make_shared() {
    
    const auto _Rx = new _Ref_count_bounded_array<_Ty>();
    shared_ptr<_Ty> _Ret;
    _Ret._Set_ptr_rep_and_enable_shared(_Rx->_Storage._Value, _Rx);
    return _Ret;
}

template <class _Ty>
[[nodiscard]] enable_if_t<is_bounded_array_v<_Ty>, shared_ptr<_Ty>> make_shared(const remove_extent_t<_Ty>& _Val) {
    
    const auto _Rx = new _Ref_count_bounded_array<_Ty>(_Val);
    shared_ptr<_Ty> _Ret;
    _Ret._Set_ptr_rep_and_enable_shared(_Rx->_Storage._Value, _Rx);
    return _Ret;
}

template <class _Ty>
[[nodiscard]] enable_if_t<!is_unbounded_array_v<_Ty>, shared_ptr<_Ty>> make_shared_for_overwrite() {
    shared_ptr<_Ty> _Ret;
    if constexpr (is_array_v<_Ty>) {
        
        const auto _Rx = new _Ref_count_bounded_array<_Ty>(_For_overwrite_tag{});
        _Ret._Set_ptr_rep_and_enable_shared(_Rx->_Storage._Value, _Rx);
    } else {
        
        const auto _Rx = new _Ref_count_obj2<_Ty>(_For_overwrite_tag{});
        _Ret._Set_ptr_rep_and_enable_shared(::std:: addressof(_Rx->_Storage._Value), _Rx);
    }
    return _Ret;
}

template <class _Ty>
[[nodiscard]] enable_if_t<is_unbounded_array_v<_Ty>, shared_ptr<_Ty>> make_shared_for_overwrite(const size_t _Count) {
    return _Make_shared_unbounded_array<_Ty>(_Count, _For_overwrite_tag{});
}
#line 2814 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

template <class _Ty, class _Alloc, class... _Types>
[[nodiscard]]

    enable_if_t<!is_array_v<_Ty>, shared_ptr<_Ty>>


#line 2822 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"
    allocate_shared(const _Alloc& _Al, _Types&&... _Args) { 
    
    
    using _Refoa   = _Ref_count_obj_alloc3<remove_cv_t<_Ty>, _Alloc>;
    using _Alblock = _Rebind_alloc_t<_Alloc, _Refoa>;
    _Alblock _Rebound(_Al);
    _Alloc_construct_ptr<_Alblock> _Constructor{_Rebound};
    _Constructor._Allocate();
    _Construct_in_place(*_Constructor._Ptr, _Al, ::std:: forward<_Types>(_Args)...);
    shared_ptr<_Ty> _Ret;
    const auto _Ptr = reinterpret_cast<_Ty*>(::std:: addressof(_Constructor._Ptr->_Storage._Value));
    _Ret._Set_ptr_rep_and_enable_shared(_Ptr, _Unfancy(_Constructor._Release()));
    return _Ret;
}


template <class _Alloc>
struct _Allocate_n_ptr {
    _Alloc& _Al;
    _Alloc_ptr_t<_Alloc> _Ptr;
    size_t _Nx;

    _Allocate_n_ptr(_Alloc& _Al_, const size_t _Nx_) : _Al(_Al_), _Ptr(_Al_.allocate(_Nx_)), _Nx(_Nx_) {}

    ~_Allocate_n_ptr() {
        if (_Ptr) {
            _Al.deallocate(_Ptr, _Nx);
        }
    }

    _Allocate_n_ptr(const _Allocate_n_ptr&) = delete;
    _Allocate_n_ptr& operator=(const _Allocate_n_ptr&) = delete;
};

template <class _Ty, class _Alloc, class... _ArgTypes>
[[nodiscard]] shared_ptr<_Ty> _Allocate_shared_unbounded_array(
    const _Alloc& _Al, const size_t _Count, const _ArgTypes&... _Args) {
    
    static_assert(is_unbounded_array_v<_Ty>);
    using _Refc             = _Ref_count_unbounded_array_alloc<remove_cv_t<_Ty>, _Alloc>;
    constexpr size_t _Align = alignof(_Refc);
    using _Storage          = _Alignas_storage_unit<_Align>;
    _Rebind_alloc_t<_Alloc, _Storage> _Rebound(_Al);
    const size_t _Bytes         = _Calculate_bytes_for_flexible_array<_Refc, _Check_overflow::_Yes>(_Count);
    const size_t _Storage_units = _Bytes / sizeof(_Storage);
    _Allocate_n_ptr _Guard{_Rebound, _Storage_units};
    const auto _Rx = reinterpret_cast<_Refc*>(_Unfancy(_Guard._Ptr));
    ::new (static_cast<void*>(_Rx)) _Refc(_Al, _Count, _Args...);
    _Guard._Ptr = nullptr;
    shared_ptr<_Ty> _Ret;
    _Ret._Set_ptr_rep_and_enable_shared(_Rx->_Get_ptr(), _Rx);
    return _Ret;
}

template <class _Ty, class _Alloc>
[[nodiscard]] enable_if_t<is_unbounded_array_v<_Ty>, shared_ptr<_Ty>> allocate_shared(
    const _Alloc& _Al, const size_t _Count) {
    return _Allocate_shared_unbounded_array<_Ty>(_Al, _Count);
}

template <class _Ty, class _Alloc>
[[nodiscard]] enable_if_t<is_unbounded_array_v<_Ty>, shared_ptr<_Ty>> allocate_shared(
    const _Alloc& _Al, const size_t _Count, const remove_extent_t<_Ty>& _Val) {
    return _Allocate_shared_unbounded_array<_Ty>(_Al, _Count, _Val);
}

template <class _Ty, class _Alloc>
[[nodiscard]] enable_if_t<is_bounded_array_v<_Ty>, shared_ptr<_Ty>> allocate_shared(const _Alloc& _Al) {
    
    using _Refc    = _Ref_count_bounded_array_alloc<remove_cv_t<_Ty>, _Alloc>;
    using _Alblock = _Rebind_alloc_t<_Alloc, _Refc>;
    _Alblock _Rebound(_Al);
    _Alloc_construct_ptr _Constructor{_Rebound};
    _Constructor._Allocate();
    ::new (_Voidify_iter(_Constructor._Ptr)) _Refc(_Al);
    shared_ptr<_Ty> _Ret;
    const auto _Ptr = static_cast<remove_extent_t<_Ty>*>(_Constructor._Ptr->_Storage._Value);
    _Ret._Set_ptr_rep_and_enable_shared(_Ptr, _Unfancy(_Constructor._Release()));
    return _Ret;
}

template <class _Ty, class _Alloc>
[[nodiscard]] enable_if_t<is_bounded_array_v<_Ty>, shared_ptr<_Ty>> allocate_shared(
    const _Alloc& _Al, const remove_extent_t<_Ty>& _Val) {
    
    using _Refc    = _Ref_count_bounded_array_alloc<remove_cv_t<_Ty>, _Alloc>;
    using _Alblock = _Rebind_alloc_t<_Alloc, _Refc>;
    _Alblock _Rebound(_Al);
    _Alloc_construct_ptr _Constructor{_Rebound};
    _Constructor._Allocate();
    ::new (_Voidify_iter(_Constructor._Ptr)) _Refc(_Al, _Val);
    shared_ptr<_Ty> _Ret;
    const auto _Ptr = static_cast<remove_extent_t<_Ty>*>(_Constructor._Ptr->_Storage._Value);
    _Ret._Set_ptr_rep_and_enable_shared(_Ptr, _Unfancy(_Constructor._Release()));
    return _Ret;
}

template <class _Ty, class _Alloc>
[[nodiscard]] enable_if_t<!is_unbounded_array_v<_Ty>, shared_ptr<_Ty>> allocate_shared_for_overwrite(const _Alloc& _Al) {
    shared_ptr<_Ty> _Ret;
    if constexpr (is_array_v<_Ty>) {
        
        using _Refc    = _Ref_count_bounded_array_alloc<remove_cv_t<_Ty>, _Alloc>;
        using _Alblock = _Rebind_alloc_t<_Alloc, _Refc>;
        _Alblock _Rebound(_Al);
        _Alloc_construct_ptr _Constructor{_Rebound};
        _Constructor._Allocate();
        ::new (_Voidify_iter(_Constructor._Ptr)) _Refc(_Al, _For_overwrite_tag{});
        const auto _Ptr = static_cast<remove_extent_t<_Ty>*>(_Constructor._Ptr->_Storage._Value);
        _Ret._Set_ptr_rep_and_enable_shared(_Ptr, _Unfancy(_Constructor._Release()));
    } else {
        
        using _Refoa   = _Ref_count_obj_alloc3<remove_cv_t<_Ty>, _Alloc>;
        using _Alblock = _Rebind_alloc_t<_Alloc, _Refoa>;
        _Alblock _Rebound(_Al);
        _Alloc_construct_ptr<_Alblock> _Constructor{_Rebound};
        _Constructor._Allocate();
        _Construct_in_place(*_Constructor._Ptr, _Al, _For_overwrite_tag{});
        const auto _Ptr = reinterpret_cast<_Ty*>(::std:: addressof(_Constructor._Ptr->_Storage._Value));
        _Ret._Set_ptr_rep_and_enable_shared(_Ptr, _Unfancy(_Constructor._Release()));
    }

    return _Ret;
}

template <class _Ty, class _Alloc>
[[nodiscard]] enable_if_t<is_unbounded_array_v<_Ty>, shared_ptr<_Ty>> allocate_shared_for_overwrite(
    const _Alloc& _Al, const size_t _Count) {
    return _Allocate_shared_unbounded_array<_Ty>(_Al, _Count, _For_overwrite_tag{});
}
#line 2953 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

template <class _Ty>
class weak_ptr : public _Ptr_base<_Ty> { 
public:

    
    template <class _Ty2, class = const _Ty2*>
    static constexpr bool _Must_avoid_expired_conversions_from = true;

    
    template <class _Ty2>
    static constexpr bool
        _Must_avoid_expired_conversions_from<_Ty2, decltype(static_cast<const _Ty2*>(static_cast<_Ty*>(nullptr)))> =
            false;
#line 2971 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

    constexpr weak_ptr() noexcept {}

    weak_ptr(const weak_ptr& _Other) noexcept {
        this->_Weakly_construct_from(_Other); 
    }

    template <class _Ty2, enable_if_t<_SP_pointer_compatible<_Ty2, _Ty>::value, int> = 0>
    weak_ptr(const shared_ptr<_Ty2>& _Other) noexcept {
        this->_Weakly_construct_from(_Other); 
    }

    template <class _Ty2, enable_if_t<_SP_pointer_compatible<_Ty2, _Ty>::value, int> = 0>
    weak_ptr(const weak_ptr<_Ty2>& _Other) noexcept {


        constexpr bool _Avoid_expired_conversions = _Must_avoid_expired_conversions_from<_Ty2>;
#line 2990 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

        if constexpr (_Avoid_expired_conversions) {
            this->_Weakly_convert_lvalue_avoiding_expired_conversions(_Other);
        } else {
            this->_Weakly_construct_from(_Other);
        }
    }

    weak_ptr(weak_ptr&& _Other) noexcept {
        this->_Move_construct_from(::std:: move(_Other));
    }

    template <class _Ty2, enable_if_t<_SP_pointer_compatible<_Ty2, _Ty>::value, int> = 0>
    weak_ptr(weak_ptr<_Ty2>&& _Other) noexcept {


        constexpr bool _Avoid_expired_conversions = _Must_avoid_expired_conversions_from<_Ty2>;
#line 3009 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

        if constexpr (_Avoid_expired_conversions) {
            this->_Weakly_convert_rvalue_avoiding_expired_conversions(::std:: move(_Other));
        } else {
            this->_Move_construct_from(::std:: move(_Other));
        }
    }

    ~weak_ptr() noexcept {
        this->_Decwref();
    }

    weak_ptr& operator=(const weak_ptr& _Right) noexcept {
        weak_ptr(_Right).swap(*this);
        return *this;
    }

    template <class _Ty2>
    weak_ptr& operator=(const weak_ptr<_Ty2>& _Right) noexcept {
        weak_ptr(_Right).swap(*this);
        return *this;
    }

    weak_ptr& operator=(weak_ptr&& _Right) noexcept {
        weak_ptr(::std:: move(_Right)).swap(*this);
        return *this;
    }

    template <class _Ty2>
    weak_ptr& operator=(weak_ptr<_Ty2>&& _Right) noexcept {
        weak_ptr(::std:: move(_Right)).swap(*this);
        return *this;
    }

    template <class _Ty2>
    weak_ptr& operator=(const shared_ptr<_Ty2>& _Right) noexcept {
        weak_ptr(_Right).swap(*this);
        return *this;
    }

    void reset() noexcept { 
        weak_ptr{}.swap(*this);
    }

    void swap(weak_ptr& _Other) noexcept {
        this->_Swap(_Other);
    }

    [[nodiscard]] bool expired() const noexcept {
        return this->use_count() == 0;
    }

    [[nodiscard]] shared_ptr<_Ty> lock() const noexcept { 
        shared_ptr<_Ty> _Ret;
        (void) _Ret._Construct_from_weak(*this);
        return _Ret;
    }
};


template <class _Ty>
weak_ptr(shared_ptr<_Ty>) -> weak_ptr<_Ty>;
#line 3072 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

template <class _Ty>
void swap(weak_ptr<_Ty>& _Left, weak_ptr<_Ty>& _Right) noexcept {
    _Left.swap(_Right);
}

template <class _Ty>
class enable_shared_from_this { 
public:
    using _Esft_type = enable_shared_from_this;

    [[nodiscard]] shared_ptr<_Ty> shared_from_this() {
        return shared_ptr<_Ty>(_Wptr);
    }

    [[nodiscard]] shared_ptr<const _Ty> shared_from_this() const {
        return shared_ptr<const _Ty>(_Wptr);
    }

    [[nodiscard]] weak_ptr<_Ty> weak_from_this() noexcept {
        return _Wptr;
    }

    [[nodiscard]] weak_ptr<const _Ty> weak_from_this() const noexcept {
        return _Wptr;
    }

protected:
    constexpr enable_shared_from_this() noexcept : _Wptr() {}

    enable_shared_from_this(const enable_shared_from_this&) noexcept : _Wptr() {
        
    }

    enable_shared_from_this& operator=(const enable_shared_from_this&) noexcept { 
        return *this;
    }

    ~enable_shared_from_this() = default;

private:
    template <class _Yty>
    friend class shared_ptr;

    mutable weak_ptr<_Ty> _Wptr;
};


template <class _Ty>
struct default_delete { 
    constexpr default_delete() noexcept = default;

    template <class _Ty2, enable_if_t<is_convertible_v<_Ty2*, _Ty*>, int> = 0>
    default_delete(const default_delete<_Ty2>&) noexcept {}

    void operator()(_Ty* _Ptr) const noexcept  { 
        static_assert(0 < sizeof(_Ty), "can't delete an incomplete type");
        delete _Ptr;
    }
};

template <class _Ty>
struct default_delete<_Ty[]> { 
    constexpr default_delete() noexcept = default;

    template <class _Uty, enable_if_t<is_convertible_v<_Uty (*)[], _Ty (*)[]>, int> = 0>
    default_delete(const default_delete<_Uty[]>&) noexcept {}

    template <class _Uty, enable_if_t<is_convertible_v<_Uty (*)[], _Ty (*)[]>, int> = 0>
    void operator()(_Uty* _Ptr) const noexcept  { 
        static_assert(0 < sizeof(_Uty), "can't delete an incomplete type");
        delete[] _Ptr;
    }
};

template <class _Ty, class _Dx_noref, class = void>
struct _Get_deleter_pointer_type { 
    using type = _Ty*;
};

template <class _Ty, class _Dx_noref>
struct _Get_deleter_pointer_type<_Ty, _Dx_noref, void_t<typename _Dx_noref::pointer>> { 
    using type = typename _Dx_noref::pointer;
};

template <class _Dx2>
using _Unique_ptr_enable_default_t =
    enable_if_t<conjunction_v<negation<is_pointer<_Dx2>>, is_default_constructible<_Dx2>>, int>;

template <class _Ty, class _Dx >
class unique_ptr { 
public:
    using pointer      = typename _Get_deleter_pointer_type<_Ty, remove_reference_t<_Dx>>::type;
    using element_type = _Ty;
    using deleter_type = _Dx;

    template <class _Dx2 = _Dx, _Unique_ptr_enable_default_t<_Dx2> = 0>
    constexpr unique_ptr() noexcept : _Mypair(_Zero_then_variadic_args_t{}) {}

    template <class _Dx2 = _Dx, _Unique_ptr_enable_default_t<_Dx2> = 0>
    constexpr unique_ptr(nullptr_t) noexcept : _Mypair(_Zero_then_variadic_args_t{}) {}

    unique_ptr& operator=(nullptr_t) noexcept {
        reset();
        return *this;
    }

    
    template <class _Dx2 = _Dx, _Unique_ptr_enable_default_t<_Dx2> = 0>
    explicit unique_ptr(pointer _Ptr) noexcept : _Mypair(_Zero_then_variadic_args_t{}, _Ptr) {}

    template <class _Dx2 = _Dx, enable_if_t<is_constructible_v<_Dx2, const _Dx2&>, int> = 0>
    unique_ptr(pointer _Ptr, const _Dx& _Dt) noexcept : _Mypair(_One_then_variadic_args_t{}, _Dt, _Ptr) {}

    template <class _Dx2                                                                            = _Dx,
        enable_if_t<conjunction_v<negation<is_reference<_Dx2>>, is_constructible<_Dx2, _Dx2>>, int> = 0>
    unique_ptr(pointer _Ptr, _Dx&& _Dt) noexcept : _Mypair(_One_then_variadic_args_t{}, ::std:: move(_Dt), _Ptr) {}

    template <class _Dx2                                                                                      = _Dx,
        enable_if_t<conjunction_v<is_reference<_Dx2>, is_constructible<_Dx2, remove_reference_t<_Dx2>>>, int> = 0>
    unique_ptr(pointer, remove_reference_t<_Dx>&&) = delete;

    template <class _Dx2 = _Dx, enable_if_t<is_move_constructible_v<_Dx2>, int> = 0>
    unique_ptr(unique_ptr&& _Right) noexcept
        : _Mypair(_One_then_variadic_args_t{}, ::std:: forward<_Dx>(_Right.get_deleter()), _Right.release()) {}

    template <class _Ty2, class _Dx2,
        enable_if_t<
            conjunction_v<negation<is_array<_Ty2>>, is_convertible<typename unique_ptr<_Ty2, _Dx2>::pointer, pointer>,
                conditional_t<is_reference_v<_Dx>, is_same<_Dx2, _Dx>, is_convertible<_Dx2, _Dx>>>,
            int> = 0>
    unique_ptr(unique_ptr<_Ty2, _Dx2>&& _Right) noexcept
        : _Mypair(_One_then_variadic_args_t{}, ::std:: forward<_Dx2>(_Right.get_deleter()), _Right.release()) {}


#line 3212 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

    template <class _Ty2, class _Dx2,
        enable_if_t<conjunction_v<negation<is_array<_Ty2>>, is_assignable<_Dx&, _Dx2>,
                        is_convertible<typename unique_ptr<_Ty2, _Dx2>::pointer, pointer>>,
            int> = 0>
    unique_ptr& operator=(unique_ptr<_Ty2, _Dx2>&& _Right) noexcept {
        reset(_Right.release());
        _Mypair._Get_first() = ::std:: forward<_Dx2>(_Right._Mypair._Get_first());
        return *this;
    }

    template <class _Dx2 = _Dx, enable_if_t<is_move_assignable_v<_Dx2>, int> = 0>
    unique_ptr& operator=(unique_ptr&& _Right) noexcept {
        if (this != ::std:: addressof(_Right)) {
            reset(_Right.release());
            _Mypair._Get_first() = ::std:: forward<_Dx>(_Right._Mypair._Get_first());
        }
        return *this;
    }

    void swap(unique_ptr& _Right) noexcept {
        _Swap_adl(_Mypair._Myval2, _Right._Mypair._Myval2);
        _Swap_adl(_Mypair._Get_first(), _Right._Mypair._Get_first());
    }

    ~unique_ptr() noexcept {
        if (_Mypair._Myval2) {
            _Mypair._Get_first()(_Mypair._Myval2);
        }
    }

    [[nodiscard]] _Dx& get_deleter() noexcept {
        return _Mypair._Get_first();
    }

    [[nodiscard]] const _Dx& get_deleter() const noexcept {
        return _Mypair._Get_first();
    }

    [[nodiscard]] add_lvalue_reference_t<_Ty> operator*() const noexcept(noexcept(*::std:: declval<pointer>())) {
        return *_Mypair._Myval2;
    }

    [[nodiscard]] pointer operator->() const noexcept {
        return _Mypair._Myval2;
    }

    [[nodiscard]] pointer get() const noexcept {
        return _Mypair._Myval2;
    }

    explicit operator bool() const noexcept {
        return static_cast<bool>(_Mypair._Myval2);
    }

    pointer release() noexcept {
        return ::std:: exchange(_Mypair._Myval2, nullptr);
    }

    void reset(pointer _Ptr = nullptr) noexcept {
        pointer _Old = ::std:: exchange(_Mypair._Myval2, _Ptr);
        if (_Old) {
            _Mypair._Get_first()(_Old);
        }
    }

    unique_ptr(const unique_ptr&) = delete;
    unique_ptr& operator=(const unique_ptr&) = delete;

private:
    template <class, class>
    friend class unique_ptr;

    _Compressed_pair<_Dx, pointer> _Mypair;
};

template <class _Ty, class _Dx>
class unique_ptr<_Ty[], _Dx> { 
public:
    using pointer      = typename _Get_deleter_pointer_type<_Ty, remove_reference_t<_Dx>>::type;
    using element_type = _Ty;
    using deleter_type = _Dx;

    template <class _Dx2 = _Dx, _Unique_ptr_enable_default_t<_Dx2> = 0>
    constexpr unique_ptr() noexcept : _Mypair(_Zero_then_variadic_args_t{}) {}

    template <class _Uty, class _Is_nullptr = is_same<_Uty, nullptr_t>>
    using _Enable_ctor_reset =
        enable_if_t<is_same_v<_Uty, pointer> 
                    || _Is_nullptr::value 
                    || (is_same_v<pointer, element_type*> 
                        && is_pointer_v<_Uty> 
                        && is_convertible_v<remove_pointer_t<_Uty> (*)[], element_type (*)[]>)>; 

    template <class _Uty, class _Dx2 = _Dx, _Unique_ptr_enable_default_t<_Dx2> = 0, class = _Enable_ctor_reset<_Uty>>
    explicit unique_ptr(_Uty _Ptr) noexcept : _Mypair(_Zero_then_variadic_args_t{}, _Ptr) {}

    template <class _Uty, class _Dx2 = _Dx, enable_if_t<is_constructible_v<_Dx2, const _Dx2&>, int> = 0,
        class = _Enable_ctor_reset<_Uty>>
    unique_ptr(_Uty _Ptr, const _Dx& _Dt) noexcept : _Mypair(_One_then_variadic_args_t{}, _Dt, _Ptr) {}

    template <class _Uty, class _Dx2 = _Dx,
        enable_if_t<conjunction_v<negation<is_reference<_Dx2>>, is_constructible<_Dx2, _Dx2>>, int> = 0,
        class = _Enable_ctor_reset<_Uty>>
    unique_ptr(_Uty _Ptr, _Dx&& _Dt) noexcept : _Mypair(_One_then_variadic_args_t{}, ::std:: move(_Dt), _Ptr) {}

    template <class _Uty, class _Dx2 = _Dx,
        enable_if_t<conjunction_v<is_reference<_Dx2>, is_constructible<_Dx2, remove_reference_t<_Dx2>>>, int> = 0>
    unique_ptr(_Uty, remove_reference_t<_Dx>&&) = delete;

    template <class _Dx2 = _Dx, enable_if_t<is_move_constructible_v<_Dx2>, int> = 0>
    unique_ptr(unique_ptr&& _Right) noexcept
        : _Mypair(_One_then_variadic_args_t{}, ::std:: forward<_Dx>(_Right.get_deleter()), _Right.release()) {}

    template <class _Dx2 = _Dx, enable_if_t<is_move_assignable_v<_Dx2>, int> = 0>
    unique_ptr& operator=(unique_ptr&& _Right) noexcept {
        if (this != ::std:: addressof(_Right)) {
            reset(_Right.release());
            _Mypair._Get_first() = ::std:: move(_Right._Mypair._Get_first());
        }

        return *this;
    }

    template <class _Uty, class _Ex, class _More, class _UP_pointer = typename unique_ptr<_Uty, _Ex>::pointer,
        class _UP_element_type = typename unique_ptr<_Uty, _Ex>::element_type>
    using _Enable_conversion = enable_if_t<
        conjunction_v<is_array<_Uty>, is_same<pointer, element_type*>, is_same<_UP_pointer, _UP_element_type*>,
            is_convertible<_UP_element_type (*)[], element_type (*)[]>, _More>>; 

    template <class _Uty, class _Ex,
        class = _Enable_conversion<_Uty, _Ex,
            conditional_t<is_reference_v<_Dx>, is_same<_Ex, _Dx>, is_convertible<_Ex, _Dx>>>>
    unique_ptr(unique_ptr<_Uty, _Ex>&& _Right) noexcept
        : _Mypair(_One_then_variadic_args_t{}, ::std:: forward<_Ex>(_Right.get_deleter()), _Right.release()) {}

    template <class _Uty, class _Ex, class = _Enable_conversion<_Uty, _Ex, is_assignable<_Dx&, _Ex>>>
    unique_ptr& operator=(unique_ptr<_Uty, _Ex>&& _Right) noexcept {
        reset(_Right.release());
        _Mypair._Get_first() = ::std:: forward<_Ex>(_Right._Mypair._Get_first());
        return *this;
    }

    template <class _Dx2 = _Dx, _Unique_ptr_enable_default_t<_Dx2> = 0>
    constexpr unique_ptr(nullptr_t) noexcept : _Mypair(_Zero_then_variadic_args_t{}) {}

    unique_ptr& operator=(nullptr_t) noexcept {
        reset();
        return *this;
    }

    void reset(nullptr_t = nullptr) noexcept {
        reset(pointer());
    }

    void swap(unique_ptr& _Right) noexcept {
        _Swap_adl(_Mypair._Myval2, _Right._Mypair._Myval2);
        _Swap_adl(_Mypair._Get_first(), _Right._Mypair._Get_first());
    }

    ~unique_ptr() noexcept {
        if (_Mypair._Myval2) {
            _Mypair._Get_first()(_Mypair._Myval2);
        }
    }

    [[nodiscard]] _Dx& get_deleter() noexcept {
        return _Mypair._Get_first();
    }

    [[nodiscard]] const _Dx& get_deleter() const noexcept {
        return _Mypair._Get_first();
    }

    [[nodiscard]] _Ty& operator[](size_t _Idx) const noexcept  {
        return _Mypair._Myval2[_Idx];
    }

    [[nodiscard]] pointer get() const noexcept {
        return _Mypair._Myval2;
    }

    explicit operator bool() const noexcept {
        return static_cast<bool>(_Mypair._Myval2);
    }

    pointer release() noexcept {
        return ::std:: exchange(_Mypair._Myval2, nullptr);
    }

    template <class _Uty, class = _Enable_ctor_reset<_Uty, false_type>>
    void reset(_Uty _Ptr) noexcept {
        pointer _Old = ::std:: exchange(_Mypair._Myval2, _Ptr);
        if (_Old) {
            _Mypair._Get_first()(_Old);
        }
    }

    unique_ptr(const unique_ptr&) = delete;
    unique_ptr& operator=(const unique_ptr&) = delete;

private:
    template <class, class>
    friend class unique_ptr;

    _Compressed_pair<_Dx, pointer> _Mypair;
};


template <class _Ty, class... _Types, enable_if_t<!is_array_v<_Ty>, int> = 0>
[[nodiscard]] unique_ptr<_Ty> make_unique(_Types&&... _Args) { 
    return unique_ptr<_Ty>(new _Ty(::std:: forward<_Types>(_Args)...));
}

template <class _Ty, enable_if_t<is_array_v<_Ty> && extent_v<_Ty> == 0, int> = 0>
[[nodiscard]] unique_ptr<_Ty> make_unique(const size_t _Size) { 
    using _Elem = remove_extent_t<_Ty>;
    return unique_ptr<_Ty>(new _Elem[_Size]());
}

template <class _Ty, class... _Types, enable_if_t<extent_v<_Ty> != 0, int> = 0>
void make_unique(_Types&&...) = delete;


template <class _Ty, enable_if_t<!is_array_v<_Ty>, int> = 0>
[[nodiscard]] unique_ptr<_Ty> make_unique_for_overwrite() { 
    return unique_ptr<_Ty>(new _Ty);
}

template <class _Ty, enable_if_t<is_unbounded_array_v<_Ty>, int> = 0>
[[nodiscard]] unique_ptr<_Ty> make_unique_for_overwrite(
    const size_t _Size) { 
    using _Elem = remove_extent_t<_Ty>;
    return unique_ptr<_Ty>(new _Elem[_Size]);
}

template <class _Ty, class... _Types, enable_if_t<is_bounded_array_v<_Ty>, int> = 0>
void make_unique_for_overwrite(_Types&&...) = delete;
#line 3451 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

template <class _Ty, class _Dx, enable_if_t<_Is_swappable<_Dx>::value, int> = 0>
void swap(unique_ptr<_Ty, _Dx>& _Left, unique_ptr<_Ty, _Dx>& _Right) noexcept {
    _Left.swap(_Right);
}

template <class _Ty1, class _Dx1, class _Ty2, class _Dx2>
[[nodiscard]] bool operator==(const unique_ptr<_Ty1, _Dx1>& _Left, const unique_ptr<_Ty2, _Dx2>& _Right) {
    return _Left.get() == _Right.get();
}


#line 3468 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

template <class _Ty1, class _Dx1, class _Ty2, class _Dx2>
[[nodiscard]] bool operator<(const unique_ptr<_Ty1, _Dx1>& _Left, const unique_ptr<_Ty2, _Dx2>& _Right) {
    using _Ptr1   = typename unique_ptr<_Ty1, _Dx1>::pointer;
    using _Ptr2   = typename unique_ptr<_Ty2, _Dx2>::pointer;
    using _Common = common_type_t<_Ptr1, _Ptr2>;
    return less<_Common>{}(_Left.get(), _Right.get());
}

template <class _Ty1, class _Dx1, class _Ty2, class _Dx2>
[[nodiscard]] bool operator>=(const unique_ptr<_Ty1, _Dx1>& _Left, const unique_ptr<_Ty2, _Dx2>& _Right) {
    return !(_Left < _Right);
}

template <class _Ty1, class _Dx1, class _Ty2, class _Dx2>
[[nodiscard]] bool operator>(const unique_ptr<_Ty1, _Dx1>& _Left, const unique_ptr<_Ty2, _Dx2>& _Right) {
    return _Right < _Left;
}

template <class _Ty1, class _Dx1, class _Ty2, class _Dx2>
[[nodiscard]] bool operator<=(const unique_ptr<_Ty1, _Dx1>& _Left, const unique_ptr<_Ty2, _Dx2>& _Right) {
    return !(_Right < _Left);
}


template <class _Ty1, class _Dx1, class _Ty2, class _Dx2>
    requires three_way_comparable_with<typename unique_ptr<_Ty1, _Dx1>::pointer,
        typename unique_ptr<_Ty2, _Dx2>::pointer>
[[nodiscard]] compare_three_way_result_t<typename unique_ptr<_Ty1, _Dx1>::pointer,
        typename unique_ptr<_Ty2, _Dx2>::pointer>
    operator<=>(const unique_ptr<_Ty1, _Dx1>& _Left, const unique_ptr<_Ty2, _Dx2>& _Right) {
    
    return _Left.get() <=> _Right.get();
}
#line 3504 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

template <class _Ty, class _Dx>
[[nodiscard]] bool operator==(const unique_ptr<_Ty, _Dx>& _Left, nullptr_t) noexcept {
    return !_Left;
}


#line 3526 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

template <class _Ty, class _Dx>
[[nodiscard]] bool operator<(const unique_ptr<_Ty, _Dx>& _Left, nullptr_t _Right) {
    using _Ptr = typename unique_ptr<_Ty, _Dx>::pointer;
    return less<_Ptr>{}(_Left.get(), _Right);
}

template <class _Ty, class _Dx>
[[nodiscard]] bool operator<(nullptr_t _Left, const unique_ptr<_Ty, _Dx>& _Right) {
    using _Ptr = typename unique_ptr<_Ty, _Dx>::pointer;
    return less<_Ptr>{}(_Left, _Right.get());
}

template <class _Ty, class _Dx>
[[nodiscard]] bool operator>=(const unique_ptr<_Ty, _Dx>& _Left, nullptr_t _Right) {
    return !(_Left < _Right);
}

template <class _Ty, class _Dx>
[[nodiscard]] bool operator>=(nullptr_t _Left, const unique_ptr<_Ty, _Dx>& _Right) {
    return !(_Left < _Right);
}

template <class _Ty, class _Dx>
[[nodiscard]] bool operator>(const unique_ptr<_Ty, _Dx>& _Left, nullptr_t _Right) {
    return _Right < _Left;
}

template <class _Ty, class _Dx>
[[nodiscard]] bool operator>(nullptr_t _Left, const unique_ptr<_Ty, _Dx>& _Right) {
    return _Right < _Left;
}

template <class _Ty, class _Dx>
[[nodiscard]] bool operator<=(const unique_ptr<_Ty, _Dx>& _Left, nullptr_t _Right) {
    return !(_Right < _Left);
}

template <class _Ty, class _Dx>
[[nodiscard]] bool operator<=(nullptr_t _Left, const unique_ptr<_Ty, _Dx>& _Right) {
    return !(_Right < _Left);
}


template <class _Ty, class _Dx>
    requires three_way_comparable<typename unique_ptr<_Ty, _Dx>::pointer>
[[nodiscard]] compare_three_way_result_t<typename unique_ptr<_Ty, _Dx>::pointer> operator<=>(
    const unique_ptr<_Ty, _Dx>& _Left, nullptr_t) {
    
    return _Left.get() <=> static_cast<typename unique_ptr<_Ty, _Dx>::pointer>(nullptr);
}
#line 3579 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

template <class _OutTy, class _PxTy, class = void>
struct _Can_stream_unique_ptr : false_type {};
template <class _OutTy, class _PxTy>
struct _Can_stream_unique_ptr<_OutTy, _PxTy, void_t<decltype(::std:: declval<_OutTy>() << ::std:: declval<_PxTy>().get())>>
    : true_type {};

template <class _Elem, class _Traits, class _Yty, class _Dx,
    enable_if_t<_Can_stream_unique_ptr<basic_ostream<_Elem, _Traits>&, const unique_ptr<_Yty, _Dx>&>::value, int> = 0>
basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Out, const unique_ptr<_Yty, _Dx>& _Px) {
    
    _Out << _Px.get();
    return _Out;
}


#line 3612 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

template <class _Ty = void>
struct owner_less; 

template <class _Ty>
struct owner_less<shared_ptr<_Ty>> {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef shared_ptr<_Ty> _Unnameable_first_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef shared_ptr<_Ty> _Unnameable_second_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef bool _Unnameable_result;

    [[nodiscard]] bool operator()(const shared_ptr<_Ty>& _Left, const shared_ptr<_Ty>& _Right) const noexcept {
        return _Left.owner_before(_Right);
    }

    [[nodiscard]] bool operator()(const shared_ptr<_Ty>& _Left, const weak_ptr<_Ty>& _Right) const noexcept {
        return _Left.owner_before(_Right);
    }

    [[nodiscard]] bool operator()(const weak_ptr<_Ty>& _Left, const shared_ptr<_Ty>& _Right) const noexcept {
        return _Left.owner_before(_Right);
    }
};

template <class _Ty>
struct owner_less<weak_ptr<_Ty>> {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef weak_ptr<_Ty> _Unnameable_first_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef weak_ptr<_Ty> _Unnameable_second_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef bool _Unnameable_result;

    [[nodiscard]] bool operator()(const weak_ptr<_Ty>& _Left, const weak_ptr<_Ty>& _Right) const noexcept {
        return _Left.owner_before(_Right);
    }

    [[nodiscard]] bool operator()(const weak_ptr<_Ty>& _Left, const shared_ptr<_Ty>& _Right) const noexcept {
        return _Left.owner_before(_Right);
    }

    [[nodiscard]] bool operator()(const shared_ptr<_Ty>& _Left, const weak_ptr<_Ty>& _Right) const noexcept {
        return _Left.owner_before(_Right);
    }
};

template <>
struct owner_less<void> {
    template <class _Ty, class _Uty>
    [[nodiscard]] bool operator()(const shared_ptr<_Ty>& _Left, const shared_ptr<_Uty>& _Right) const noexcept {
        return _Left.owner_before(_Right);
    }

    template <class _Ty, class _Uty>
    [[nodiscard]] bool operator()(const shared_ptr<_Ty>& _Left, const weak_ptr<_Uty>& _Right) const noexcept {
        return _Left.owner_before(_Right);
    }

    template <class _Ty, class _Uty>
    [[nodiscard]] bool operator()(const weak_ptr<_Ty>& _Left, const shared_ptr<_Uty>& _Right) const noexcept {
        return _Left.owner_before(_Right);
    }

    template <class _Ty, class _Uty>
    [[nodiscard]] bool operator()(const weak_ptr<_Ty>& _Left, const weak_ptr<_Uty>& _Right) const noexcept {
        return _Left.owner_before(_Right);
    }

    using is_transparent = int;
};

template <class _Ty, class _Dx>
struct hash<unique_ptr<_Ty, _Dx>> : _Conditionally_enabled_hash<unique_ptr<_Ty, _Dx>,
                                        is_default_constructible_v<hash<typename unique_ptr<_Ty, _Dx>::pointer>>> {
    static size_t _Do_hash(const unique_ptr<_Ty, _Dx>& _Keyval) noexcept(
        _Is_nothrow_hashable<typename unique_ptr<_Ty, _Dx>::pointer>::value) {
        return hash<typename unique_ptr<_Ty, _Dx>::pointer>{}(_Keyval.get());
    }
};

template <class _Ty>
struct hash<shared_ptr<_Ty>> {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef shared_ptr<_Ty> _Unnameable_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef size_t _Unnameable_result;

    [[nodiscard]] size_t operator()(const shared_ptr<_Ty>& _Keyval) const noexcept {
        return hash<typename shared_ptr<_Ty>::element_type*>()(_Keyval.get());
    }
};

inline void* align(size_t _Bound, size_t _Size, void*& _Ptr, size_t& _Space) noexcept  {
    
    size_t _Off = static_cast<size_t>(reinterpret_cast<uintptr_t>(_Ptr) & (_Bound - 1));
    if (_Off != 0) {
        _Off = _Bound - _Off; 
    }

    if (_Space < _Off || _Space - _Off < _Size) {
        return nullptr;
    }

    
    _Ptr = static_cast<char*>(_Ptr) + _Off;
    _Space -= _Off;
    return _Ptr;
}


template <size_t _Nx, class _Ty>
[[nodiscard]] constexpr _Ty* assume_aligned(_Ty* const _Ptr) noexcept  {
    if (::std:: is_constant_evaluated()) {
        return _Ptr;
    } else {
        
        return static_cast<_Ty*>(__builtin_assume_aligned(_Ptr, _Nx));
    }
}
#line 3726 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

extern "C" {
 void __cdecl _Lock_shared_ptr_spin_lock();
 void __cdecl _Unlock_shared_ptr_spin_lock();
}

struct _Shared_ptr_spin_lock { 
    _Shared_ptr_spin_lock() { 
        _Lock_shared_ptr_spin_lock();
    }

    ~_Shared_ptr_spin_lock() noexcept { 
        _Unlock_shared_ptr_spin_lock();
    }
};

template <class _Ty>
[[deprecated("warning STL4029: " "std::atomic_*() overloads for shared_ptr are deprecated in C++20. " "The shared_ptr specialization of std::atomic provides superior functionality. " "You can define _SILENCE_CXX20_OLD_SHARED_PTR_ATOMIC_SUPPORT_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] [[nodiscard]] bool atomic_is_lock_free(const shared_ptr<_Ty>*) {
    
    return false;
}

template <class _Ty>
[[deprecated("warning STL4029: " "std::atomic_*() overloads for shared_ptr are deprecated in C++20. " "The shared_ptr specialization of std::atomic provides superior functionality. " "You can define _SILENCE_CXX20_OLD_SHARED_PTR_ATOMIC_SUPPORT_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] [[nodiscard]] shared_ptr<_Ty> atomic_load_explicit(
    const shared_ptr<_Ty>* _Ptr, memory_order) {
    
    _Shared_ptr_spin_lock _Lock;
    shared_ptr<_Ty> _Result = *_Ptr;
    return _Result;
}

template <class _Ty>
[[deprecated("warning STL4029: " "std::atomic_*() overloads for shared_ptr are deprecated in C++20. " "The shared_ptr specialization of std::atomic provides superior functionality. " "You can define _SILENCE_CXX20_OLD_SHARED_PTR_ATOMIC_SUPPORT_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] [[nodiscard]] shared_ptr<_Ty> atomic_load(
    const shared_ptr<_Ty>* _Ptr) { 
    return ::std:: atomic_load_explicit(_Ptr, memory_order_seq_cst);
}

template <class _Ty>
[[deprecated("warning STL4029: " "std::atomic_*() overloads for shared_ptr are deprecated in C++20. " "The shared_ptr specialization of std::atomic provides superior functionality. " "You can define _SILENCE_CXX20_OLD_SHARED_PTR_ATOMIC_SUPPORT_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] void atomic_store_explicit(
    shared_ptr<_Ty>* _Ptr, shared_ptr<_Ty> _Other, memory_order) {
    
    _Shared_ptr_spin_lock _Lock;
    _Ptr->swap(_Other);
}

template <class _Ty>
[[deprecated("warning STL4029: " "std::atomic_*() overloads for shared_ptr are deprecated in C++20. " "The shared_ptr specialization of std::atomic provides superior functionality. " "You can define _SILENCE_CXX20_OLD_SHARED_PTR_ATOMIC_SUPPORT_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] void atomic_store(
    shared_ptr<_Ty>* _Ptr, shared_ptr<_Ty> _Other) { 
    ::std:: atomic_store_explicit(_Ptr, ::std:: move(_Other), memory_order_seq_cst);
}

template <class _Ty>
[[deprecated("warning STL4029: " "std::atomic_*() overloads for shared_ptr are deprecated in C++20. " "The shared_ptr specialization of std::atomic provides superior functionality. " "You can define _SILENCE_CXX20_OLD_SHARED_PTR_ATOMIC_SUPPORT_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] shared_ptr<_Ty> atomic_exchange_explicit(
    shared_ptr<_Ty>* _Ptr, shared_ptr<_Ty> _Other, memory_order) {
    
    _Shared_ptr_spin_lock _Lock;
    _Ptr->swap(_Other);
    return _Other;
}

template <class _Ty>
[[deprecated("warning STL4029: " "std::atomic_*() overloads for shared_ptr are deprecated in C++20. " "The shared_ptr specialization of std::atomic provides superior functionality. " "You can define _SILENCE_CXX20_OLD_SHARED_PTR_ATOMIC_SUPPORT_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] shared_ptr<_Ty> atomic_exchange(
    shared_ptr<_Ty>* _Ptr, shared_ptr<_Ty> _Other) {
    
    return ::std:: atomic_exchange_explicit(_Ptr, ::std:: move(_Other), memory_order_seq_cst);
}

template <class _Ty>
[[deprecated("warning STL4029: " "std::atomic_*() overloads for shared_ptr are deprecated in C++20. " "The shared_ptr specialization of std::atomic provides superior functionality. " "You can define _SILENCE_CXX20_OLD_SHARED_PTR_ATOMIC_SUPPORT_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] bool atomic_compare_exchange_weak_explicit(shared_ptr<_Ty>* _Ptr,
    shared_ptr<_Ty>* _Exp, shared_ptr<_Ty> _Value, memory_order, memory_order) { 
    shared_ptr<_Ty> _Old_exp; 
    _Shared_ptr_spin_lock _Lock;
    bool _Success = _Ptr->get() == _Exp->get() && !_Ptr->owner_before(*_Exp) && !_Exp->owner_before(*_Ptr);
    if (_Success) {
        _Ptr->swap(_Value);
    } else { 
        _Exp->swap(_Old_exp);
        *_Exp = *_Ptr;
    }
    return _Success;
}

template <class _Ty>
[[deprecated("warning STL4029: " "std::atomic_*() overloads for shared_ptr are deprecated in C++20. " "The shared_ptr specialization of std::atomic provides superior functionality. " "You can define _SILENCE_CXX20_OLD_SHARED_PTR_ATOMIC_SUPPORT_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] bool atomic_compare_exchange_weak(
    shared_ptr<_Ty>* _Ptr, shared_ptr<_Ty>* _Exp, shared_ptr<_Ty> _Value) {
    
    return ::std:: atomic_compare_exchange_weak_explicit(
        _Ptr, _Exp, ::std:: move(_Value), memory_order_seq_cst, memory_order_seq_cst);
}

template <class _Ty>
[[deprecated("warning STL4029: " "std::atomic_*() overloads for shared_ptr are deprecated in C++20. " "The shared_ptr specialization of std::atomic provides superior functionality. " "You can define _SILENCE_CXX20_OLD_SHARED_PTR_ATOMIC_SUPPORT_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] bool atomic_compare_exchange_strong_explicit(shared_ptr<_Ty>* _Ptr,
    shared_ptr<_Ty>* _Exp, shared_ptr<_Ty> _Value, memory_order, memory_order) { 
    return ::std:: atomic_compare_exchange_weak_explicit(
        _Ptr, _Exp, ::std:: move(_Value), memory_order_seq_cst, memory_order_seq_cst);
}

template <class _Ty>
[[deprecated("warning STL4029: " "std::atomic_*() overloads for shared_ptr are deprecated in C++20. " "The shared_ptr specialization of std::atomic provides superior functionality. " "You can define _SILENCE_CXX20_OLD_SHARED_PTR_ATOMIC_SUPPORT_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] bool atomic_compare_exchange_strong(
    shared_ptr<_Ty>* _Ptr, shared_ptr<_Ty>* _Exp, shared_ptr<_Ty> _Value) {
    
    return ::std:: atomic_compare_exchange_strong_explicit(
        _Ptr, _Exp, ::std:: move(_Value), memory_order_seq_cst, memory_order_seq_cst);
}


template <class _Ty>
class alignas(2 * sizeof(void*)) _Atomic_ptr_base {
    
protected:
    constexpr _Atomic_ptr_base() noexcept = default;

    _Atomic_ptr_base(_Ty* const _Px, _Ref_count_base* const _Ref) noexcept : _Ptr(_Px), _Repptr(_Ref) {}

    void _Wait(_Ty* _Old, memory_order) const noexcept {
        for (;;) {
            auto _Rep   = _Repptr._Lock_and_load();
            bool _Equal = _Ptr.load(memory_order_relaxed) == _Old;
            _Repptr._Store_and_unlock(_Rep);
            if (!_Equal) {
                break;
            }
            __std_atomic_wait_direct(&_Ptr, &_Old, sizeof(_Old), _Atomic_wait_no_timeout);
        }
    }

    void notify_one() noexcept {
        _Ptr.notify_one();
    }

    void notify_all() noexcept {
        _Ptr.notify_all();
    }

    atomic<_Ty*> _Ptr{nullptr};
    mutable _Locked_pointer<_Ref_count_base> _Repptr;
};

template <class _Ty>
struct atomic<shared_ptr<_Ty>> : private _Atomic_ptr_base<_Ty> {
private:
    using _Base = _Atomic_ptr_base<_Ty>;

public:
    using value_type = shared_ptr<_Ty>;

    static constexpr bool is_always_lock_free = false;

    [[nodiscard]] bool is_lock_free() const noexcept {
        return false;
    }

    void store(shared_ptr<_Ty> _Value, const memory_order _Order = memory_order_seq_cst) noexcept {
        _Check_store_memory_order(_Order);
        const auto _Rep = this->_Repptr._Lock_and_load();
        _Ty* const _Tmp = _Value._Ptr;
        _Value._Ptr     = this->_Ptr.load(memory_order_relaxed);
        this->_Ptr.store(_Tmp, memory_order_relaxed);
        this->_Repptr._Store_and_unlock(_Value._Rep);
        _Value._Rep = _Rep;
    }

    [[nodiscard]] shared_ptr<_Ty> load(const memory_order _Order = memory_order_seq_cst) const noexcept {
        _Check_load_memory_order(_Order);
        shared_ptr<_Ty> _Result;
        const auto _Rep = this->_Repptr._Lock_and_load();
        _Result._Ptr    = this->_Ptr.load(memory_order_relaxed);
        _Result._Rep    = _Rep;
        _Result._Incref();
        this->_Repptr._Store_and_unlock(_Rep);
        return _Result;
    }

    operator shared_ptr<_Ty>() const noexcept {
        return load();
    }

    shared_ptr<_Ty> exchange(shared_ptr<_Ty> _Value, const memory_order _Order = memory_order_seq_cst) noexcept {
        _Check_memory_order(_Order);
        shared_ptr<_Ty> _Result;
        _Result._Rep = this->_Repptr._Lock_and_load();
        _Result._Ptr = this->_Ptr.load(memory_order_relaxed);
        this->_Ptr.store(_Value._Ptr, memory_order_relaxed);
        this->_Repptr._Store_and_unlock(_Value._Rep);
        _Value._Ptr = nullptr; 
        _Value._Rep = nullptr;
        return _Result;
    }

    bool compare_exchange_weak(shared_ptr<_Ty>& _Expected, shared_ptr<_Ty> _Desired, const memory_order _Success,
        const memory_order _Failure) noexcept {
        return compare_exchange_strong(_Expected, ::std:: move(_Desired), _Combine_cas_memory_orders(_Success, _Failure));
    }

    bool compare_exchange_strong(shared_ptr<_Ty>& _Expected, shared_ptr<_Ty> _Desired, const memory_order _Success,
        const memory_order _Failure) noexcept {
        return compare_exchange_strong(_Expected, ::std:: move(_Desired), _Combine_cas_memory_orders(_Success, _Failure));
    }

    bool compare_exchange_weak(shared_ptr<_Ty>& _Expected, shared_ptr<_Ty> _Desired,
        const memory_order _Order = memory_order_seq_cst) noexcept {
        return compare_exchange_strong(_Expected, ::std:: move(_Desired), _Order);
    }

    bool compare_exchange_strong(shared_ptr<_Ty>& _Expected, shared_ptr<_Ty> _Desired,
        const memory_order _Order = memory_order_seq_cst) noexcept {
        _Check_memory_order(_Order);
        auto _Rep = this->_Repptr._Lock_and_load();
        if (this->_Ptr.load(memory_order_relaxed) == _Expected._Ptr && _Rep == _Expected._Rep) {
            _Ty* const _Tmp = _Desired._Ptr;
            _Desired._Ptr   = this->_Ptr.load(memory_order_relaxed);
            this->_Ptr.store(_Tmp, memory_order_relaxed);
            ::std:: swap(_Rep, _Desired._Rep);
            this->_Repptr._Store_and_unlock(_Rep);
            return true;
        }
        _Ref_count_base* _Expected_rep = _Expected._Rep;
        _Expected._Ptr                 = this->_Ptr.load(memory_order_relaxed);
        _Expected._Rep                 = _Rep;
        _Expected._Incref();
        this->_Repptr._Store_and_unlock(_Rep);
        if (_Expected_rep) {
            _Expected_rep->_Decref();
        }
        return false;
    }

    void wait(shared_ptr<_Ty> _Old, memory_order _Order = memory_order_seq_cst) const noexcept {
        this->_Wait(_Old._Ptr, _Order);
    }

    using _Base::notify_all;
    using _Base::notify_one;

    constexpr atomic() noexcept = default;

    constexpr atomic(nullptr_t) noexcept : atomic() {}

    atomic(const shared_ptr<_Ty> _Value) noexcept : _Base(_Value._Ptr, _Value._Rep) {
        _Value._Incref();
    }

    atomic(const atomic&) = delete;
    void operator=(const atomic&) = delete;

    void operator=(shared_ptr<_Ty> _Value) noexcept {
        store(::std:: move(_Value));
    }

    ~atomic() {
        const auto _Rep = this->_Repptr._Unsafe_load_relaxed();
        if (_Rep) {
            _Rep->_Decref();
        }
    }
};

template <class _Ty>
struct atomic<weak_ptr<_Ty>> : private _Atomic_ptr_base<_Ty> {
private:
    using _Base = _Atomic_ptr_base<_Ty>;

public:
    using value_type = weak_ptr<_Ty>;

    static constexpr bool is_always_lock_free = false;

    [[nodiscard]] bool is_lock_free() const noexcept {
        return false;
    }

    void store(weak_ptr<_Ty> _Value, const memory_order _Order = memory_order_seq_cst) noexcept {
        _Check_store_memory_order(_Order);
        const auto _Rep = this->_Repptr._Lock_and_load();
        _Ty* const _Tmp = _Value._Ptr;
        _Value._Ptr     = this->_Ptr.load(memory_order_relaxed);
        this->_Ptr.store(_Tmp, memory_order_relaxed);
        this->_Repptr._Store_and_unlock(_Value._Rep);
        _Value._Rep = _Rep;
    }

    [[nodiscard]] weak_ptr<_Ty> load(const memory_order _Order = memory_order_seq_cst) const noexcept {
        _Check_load_memory_order(_Order);
        weak_ptr<_Ty> _Result;
        const auto _Rep = this->_Repptr._Lock_and_load();
        _Result._Ptr    = this->_Ptr.load(memory_order_relaxed);
        _Result._Rep    = _Rep;
        _Result._Incwref();
        this->_Repptr._Store_and_unlock(_Rep);
        return _Result;
    }

    operator weak_ptr<_Ty>() const noexcept {
        return load();
    }

    weak_ptr<_Ty> exchange(weak_ptr<_Ty> _Value, const memory_order _Order = memory_order_seq_cst) noexcept {
        _Check_memory_order(_Order);
        weak_ptr<_Ty> _Result;
        _Result._Rep = this->_Repptr._Lock_and_load();
        _Result._Ptr = this->_Ptr.load(memory_order_relaxed);
        this->_Ptr.store(_Value._Ptr, memory_order_relaxed);
        this->_Repptr._Store_and_unlock(_Value._Rep);
        _Value._Ptr = nullptr; 
        _Value._Rep = nullptr;
        return _Result;
    }

    bool compare_exchange_weak(weak_ptr<_Ty>& _Expected, weak_ptr<_Ty> _Desired, const memory_order _Success,
        const memory_order _Failure) noexcept {
        return compare_exchange_strong(_Expected, ::std:: move(_Desired), _Combine_cas_memory_orders(_Success, _Failure));
    }

    bool compare_exchange_strong(weak_ptr<_Ty>& _Expected, weak_ptr<_Ty> _Desired, const memory_order _Success,
        const memory_order _Failure) noexcept {
        return compare_exchange_strong(_Expected, ::std:: move(_Desired), _Combine_cas_memory_orders(_Success, _Failure));
    }

    bool compare_exchange_weak(
        weak_ptr<_Ty>& _Expected, weak_ptr<_Ty> _Desired, const memory_order _Order = memory_order_seq_cst) noexcept {
        return compare_exchange_strong(_Expected, ::std:: move(_Desired), _Order);
    }

    bool compare_exchange_strong(
        weak_ptr<_Ty>& _Expected, weak_ptr<_Ty> _Desired, const memory_order _Order = memory_order_seq_cst) noexcept {
        _Check_memory_order(_Order);
        auto _Rep = this->_Repptr._Lock_and_load();
        if (this->_Ptr.load(memory_order_relaxed) == _Expected._Ptr && _Rep == _Expected._Rep) {
            _Ty* const _Tmp = _Desired._Ptr;
            _Desired._Ptr   = this->_Ptr.load(memory_order_relaxed);
            this->_Ptr.store(_Tmp, memory_order_relaxed);
            ::std:: swap(_Rep, _Desired._Rep);
            this->_Repptr._Store_and_unlock(_Rep);
            return true;
        }
        const auto _Expected_rep = _Expected._Rep;
        _Expected._Ptr           = this->_Ptr.load(memory_order_relaxed);
        _Expected._Rep           = _Rep;
        _Expected._Incwref();
        this->_Repptr._Store_and_unlock(_Rep);
        if (_Expected_rep) {
            _Expected_rep->_Decwref();
        }
        return false;
    }

    void wait(weak_ptr<_Ty> _Old, memory_order _Order = memory_order_seq_cst) const noexcept {
        this->_Wait(_Old._Ptr, _Order);
    }

    using _Base::notify_all;
    using _Base::notify_one;

    constexpr atomic() noexcept = default;

    atomic(const weak_ptr<_Ty> _Value) noexcept : _Base(_Value._Ptr, _Value._Rep) {
        _Value._Incwref();
    }

    atomic(const atomic&) = delete;
    void operator=(const atomic&) = delete;

    void operator=(weak_ptr<_Ty> _Value) noexcept {
        store(::std:: move(_Value));
    }

    ~atomic() {
        const auto _Rep = this->_Repptr._Unsafe_load_relaxed();
        if (_Rep) {
            _Rep->_Decwref();
        }
    }
};
#line 4100 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"


template <class _Ty>
struct _Pointer_of_helper {};

template <_Has_member_pointer _Ty>
struct _Pointer_of_helper<_Ty> {
    using type = typename _Ty::pointer;
};


template <_Has_member_element_type _Ty>
    requires (!_Has_member_pointer<_Ty>)
struct _Pointer_of_helper<_Ty> {
    using type = typename _Ty::element_type*;
};

template <class _Ty>
    requires (!_Has_member_element_type<_Ty> && !_Has_member_pointer<_Ty>
        && _Has_member_element_type<pointer_traits<_Ty>>)
struct _Pointer_of_helper<_Ty> {
    using type = typename pointer_traits<_Ty>::element_type*;
};


template <class _Ty>
using _Pointer_of = typename _Pointer_of_helper<_Ty>::type;

template <class _Ty, class _Uty>
struct _Pointer_of_or_helper {
    using type = _Uty;
};


template <class _Ty, class _Uty>
    requires requires { typename _Pointer_of<_Ty>; }
struct _Pointer_of_or_helper<_Ty, _Uty> {
    using type = _Pointer_of<_Ty>;
};


template <class _Ty, class _Uty>
using _Pointer_of_or = typename _Pointer_of_or_helper<_Ty, _Uty>::type;


template <class _SmartPtr, class _Sp, class _Pointer, class... _ArgsT>
concept _Resettable_pointer = requires(_SmartPtr& _Smart_ptr, _Pointer _Ptr, _ArgsT&&... _Args) {
    _Smart_ptr.reset(static_cast<_Sp>(_Ptr), ::std:: forward<_ArgsT>(_Args)...);
};

template <class _SmartPtr, class _Pointer, class... _ArgsT>
class out_ptr_t {
    static_assert(!_Is_specialization_v<_SmartPtr, shared_ptr> || sizeof...(_ArgsT) != 0,
        "out_ptr_t with shared_ptr requires a deleter (N4892 [out.ptr.t]/3)");

public:
    explicit out_ptr_t(_SmartPtr& _Smart_ptr_, _ArgsT... _Args_) noexcept(
        is_nothrow_constructible_v<tuple<_ArgsT...>, _ArgsT...>) 
        : _Smart_ptr(_Smart_ptr_),
          _Mypair(_One_then_variadic_args_t{}, tuple<_ArgsT...>{::std:: forward<_ArgsT>(_Args_)...}) {}

    out_ptr_t(const out_ptr_t&) = delete;

    ~out_ptr_t() {
        if (!_Get_ptr()) {
            return;
        }

        ::std:: apply(
            [this](auto&&... _Args_) {
                using _Sp = _Pointer_of_or<_SmartPtr, _Pointer>;
                if constexpr (_Resettable_pointer<_SmartPtr, _Sp, _Pointer, _ArgsT...>) {
                    _Smart_ptr.reset(static_cast<_Sp>(_Get_ptr()), ::std:: forward<_ArgsT>(_Args_)...);
                } else {
                    static_assert(is_constructible_v<_SmartPtr, _Sp, _ArgsT...>, "(N4892 [out.ptr.t]/9.3)");
                    _Smart_ptr = _SmartPtr(static_cast<_Sp>(_Get_ptr()), ::std:: forward<_ArgsT>(_Args_)...);
                }
            },
            ::std:: move(_Get_args()));
    }

    operator _Pointer*() const noexcept {
        return ::std:: addressof(_Get_ptr());
    }

    operator void**() const noexcept requires(!is_same_v<_Pointer, void*>) {
        static_assert(is_pointer_v<_Pointer>, "conversion of out_ptr_t<Smart, Pointer, Args...> to void** requires "
                                              "Pointer to be a raw pointer (N4892 [out.ptr.t]/13)");
        return reinterpret_cast<void**>(::std:: addressof(_Get_ptr()));
    }

    
private:
    [[nodiscard]] _Pointer& _Get_ptr() const noexcept {
        return const_cast<_Pointer&>(_Mypair._Myval2);
    }
    

    [[nodiscard]] tuple<_ArgsT...>& _Get_args() noexcept {
        return _Mypair._Get_first();
    }

    _SmartPtr& _Smart_ptr;
    _Compressed_pair<tuple<_ArgsT...>, _Pointer> _Mypair;
};

template <class _Pointer = void, class _SmartPtr, class... _ArgsT>
[[nodiscard]] auto out_ptr(_SmartPtr& _Smart_ptr, _ArgsT&&... _Args) {
    if constexpr (is_void_v<_Pointer>) {
        return out_ptr_t<_SmartPtr, _Pointer_of<_SmartPtr>, _ArgsT&&...>(_Smart_ptr, ::std:: forward<_ArgsT>(_Args)...);
    } else {
        return out_ptr_t<_SmartPtr, _Pointer, _ArgsT&&...>(_Smart_ptr, ::std:: forward<_ArgsT>(_Args)...);
    }
}

template <class _SmartPtr, class _Pointer, class... _ArgsT>
class inout_ptr_t {
    static_assert(!_Is_specialization_v<_SmartPtr, shared_ptr>,
        "inout_ptr_t doesn't work with shared_ptr (N4892 [inout.ptr.t]/3)");

private:
    [[nodiscard]] static auto _Get_ptr_from_smart(_SmartPtr& _Smart_ptr) noexcept requires is_pointer_v<_SmartPtr> {
        return _Smart_ptr;
    }

    [[nodiscard]] static auto _Get_ptr_from_smart(_SmartPtr& _Smart_ptr) noexcept(noexcept(_Smart_ptr.get())) {
        return _Smart_ptr.get();
    }

public:
    explicit inout_ptr_t(_SmartPtr& _Smart_ptr_, _ArgsT... _Args_) noexcept(
        is_nothrow_constructible_v<tuple<_ArgsT...>, _ArgsT...>&& noexcept(
            _Get_ptr_from_smart(_Smart_ptr_))) 
        : _Smart_ptr(_Smart_ptr_),
          _Mypair(_One_then_variadic_args_t{}, tuple<_ArgsT...>{::std:: forward<_ArgsT>(_Args_)...},
              _Get_ptr_from_smart(_Smart_ptr_)) {}

    inout_ptr_t(const inout_ptr_t&) = delete;

    ~inout_ptr_t() {
        if (!_Get_ptr()) {
            return;
        }

        ::std:: apply(
            [this](auto&&... _Args_) {
                using _Sp = _Pointer_of_or<_SmartPtr, _Pointer>;
                if constexpr (is_pointer_v<_SmartPtr>) {
                    _Smart_ptr = _SmartPtr(static_cast<_Sp>(_Get_ptr()), ::std:: forward<_ArgsT>(_Args_)...);
                } else if constexpr (_Resettable_pointer<_SmartPtr, _Sp, _Pointer, _ArgsT...>) {
                    _Smart_ptr.release();
                    _Smart_ptr.reset(static_cast<_Sp>(_Get_ptr()), ::std:: forward<_ArgsT>(_Args_)...);
                } else {
                    static_assert(is_constructible_v<_SmartPtr, _Sp, _ArgsT...>, "(N4892 [inout.ptr.t]/11.4)");
                    _Smart_ptr.release();
                    _Smart_ptr = _SmartPtr(static_cast<_Sp>(_Get_ptr()), ::std:: forward<_ArgsT>(_Args_)...);
                }
            },
            ::std:: move(_Get_args()));
    }

    operator _Pointer*() const noexcept {
        return ::std:: addressof(_Get_ptr());
    }

    operator void**() const noexcept requires(!is_same_v<_Pointer, void*>) {
        static_assert(is_pointer_v<_Pointer>, "conversion of inout_ptr_t<Smart, Pointer, Args...> to void** requires "
                                              "Pointer to be a raw pointer (N4892 [inout.ptr.t]/15)");
        return reinterpret_cast<void**>(::std:: addressof(_Get_ptr()));
    }

    
private:
    [[nodiscard]] _Pointer& _Get_ptr() const noexcept {
        return const_cast<_Pointer&>(_Mypair._Myval2);
    }
    

    [[nodiscard]] tuple<_ArgsT...>& _Get_args() noexcept {
        return _Mypair._Get_first();
    }

    _SmartPtr& _Smart_ptr;
    _Compressed_pair<tuple<_ArgsT...>, _Pointer> _Mypair;
};

template <class _Pointer = void, class _SmartPtr, class... _ArgsT>
[[nodiscard]] auto inout_ptr(_SmartPtr& _Smart_ptr, _ArgsT&&... _Args) {
    if constexpr (is_void_v<_Pointer>) {
        return inout_ptr_t<_SmartPtr, _Pointer_of<_SmartPtr>, _ArgsT&&...>(_Smart_ptr, ::std:: forward<_ArgsT>(_Args)...);
    } else {
        return inout_ptr_t<_SmartPtr, _Pointer, _ArgsT&&...>(_Smart_ptr, ::std:: forward<_ArgsT>(_Args)...);
    }
}
#line 4295 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"


#line 4311 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"

}


#pragma warning(pop)
#pragma pack(pop)
#line 4318 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"
#line 4319 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory"
#line 14 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocale"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xfacet"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
class  _Facet_base { 
public:
    virtual  ~_Facet_base() noexcept {} 

    
    virtual void  _Incref() noexcept = 0;

    
    virtual _Facet_base*  _Decref() noexcept = 0;
};


#line 40 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xfacet"
void __cdecl _Facet_Register(_Facet_base*);
#line 42 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xfacet"
}


#pragma warning(pop)
#pragma pack(pop)
#line 48 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xfacet"
#line 49 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xfacet"
#line 16 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocale"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocinfo"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_xlocinfo_types.hpp"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


extern "C" {

struct _Collvec { 
    unsigned int _Page; 
    wchar_t* _LocaleName;
};

struct _Ctypevec { 
    unsigned int _Page; 
    const short* _Table;
    int _Delfl;
    wchar_t* _LocaleName;
};

struct _Cvtvec { 
    unsigned int _Page; 
    unsigned int _Mbcurmax;
    int _Isclocale; 
    unsigned char _Isleadbyte[32]; 
};

}


#pragma warning(pop)
#pragma pack(pop)
#line 47 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_xlocinfo_types.hpp"
#line 48 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_xlocinfo_types.hpp"
#line 12 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocinfo"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cctype"


#pragma once


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\ctype.h"


#pragma once


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


   int __cdecl _isctype(  int _C,   int _Type);
   int __cdecl _isctype_l(  int _C,   int _Type,   _locale_t _Locale);
    int __cdecl isalpha(  int _C);
   int __cdecl _isalpha_l(  int _C,   _locale_t _Locale);
    int __cdecl isupper(  int _C);
   int __cdecl _isupper_l(  int _C,   _locale_t _Locale);
    int __cdecl islower(  int _C);
   int __cdecl _islower_l(  int _C,   _locale_t _Locale);


    int __cdecl isdigit(  int _C);

   int __cdecl _isdigit_l(  int _C,   _locale_t _Locale);
   int __cdecl isxdigit(  int _C);
   int __cdecl _isxdigit_l(  int _C,   _locale_t _Locale);


    int __cdecl isspace(  int _C);

   int __cdecl _isspace_l(  int _C,   _locale_t _Locale);
   int __cdecl ispunct(  int _C);
   int __cdecl _ispunct_l(  int _C,   _locale_t _Locale);
   int __cdecl isblank(  int _C);
   int __cdecl _isblank_l(  int _C,   _locale_t _Locale);
    int __cdecl isalnum(  int _C);
   int __cdecl _isalnum_l(  int _C,   _locale_t _Locale);
   int __cdecl isprint(  int _C);
   int __cdecl _isprint_l(  int _C,   _locale_t _Locale);
   int __cdecl isgraph(  int _C);
   int __cdecl _isgraph_l(  int _C,   _locale_t _Locale);
   int __cdecl iscntrl(  int _C);
   int __cdecl _iscntrl_l(  int _C,   _locale_t _Locale);


    int __cdecl toupper(  int _C);


    int __cdecl tolower(  int _C);

    int __cdecl _tolower(  int _C);
   int __cdecl _tolower_l(  int _C,   _locale_t _Locale);
    int __cdecl _toupper(  int _C);
   int __cdecl _toupper_l(  int _C,   _locale_t _Locale);

   int __cdecl __isascii(  int _C);
   int __cdecl __toascii(  int _C);
   int __cdecl __iscsymf(  int _C);
   int __cdecl __iscsym(  int _C);


__inline int __cdecl __acrt_locale_get_ctype_array_value(
      unsigned short const * const _Locale_pctype_array,
              int                    const _Char_value,
                             int                    const _Mask
    )
{
    
    
    if (_Char_value >= -1 && _Char_value <= 255)
    {
        return _Locale_pctype_array[_Char_value] & _Mask;
    }

    return 0;
}


    #line 137 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\ctype.h"


        __forceinline int __cdecl __ascii_tolower(int const _C)
        {
            if (_C >= 'A' && _C <= 'Z')
            {
                return _C - ('A' - 'a');
            }
            return _C;
        }

        __forceinline int __cdecl __ascii_toupper(int const _C)
        {
            if (_C >= 'a' && _C <= 'z')
            {
                return _C - ('a' - 'A');
            }
            return _C;
        }

        __forceinline int __cdecl __ascii_iswalpha(int const _C)
        {
            return (_C >= 'A' && _C <= 'Z') || (_C >= 'a' && _C <= 'z');
        }

        __forceinline int __cdecl __ascii_iswdigit(int const _C)
        {
            return _C >= '0' && _C <= '9';
        }

        __forceinline int __cdecl __ascii_towlower(int const _C)
        {
            return __ascii_tolower(_C);
        }

        __forceinline int __cdecl __ascii_towupper(int const _C)
        {
            return __ascii_toupper(_C);
        }
    #line 189 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\ctype.h"


#line 206 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\ctype.h"

    __inline __crt_locale_data_public* __cdecl __acrt_get_locale_data_prefix(void const volatile* const _LocalePointers)
    {
        _locale_t const _TypedLocalePointers = (_locale_t)_LocalePointers;
        return (__crt_locale_data_public*)_TypedLocalePointers->locinfo;
    }

    
    __inline int __cdecl _chvalidchk_l(
              int       const _C,
              int       const _Mask,
          _locale_t const _Locale
        )
    {
        

        if (_Locale)
        {
            return __acrt_locale_get_ctype_array_value(__acrt_get_locale_data_prefix(_Locale)->_locale_pctype, _C, _Mask);
        }

        return (__acrt_locale_get_ctype_array_value(__pctype_func(), (_C), (_Mask)));
        #line 233 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\ctype.h"
    }

    
    __inline int __cdecl _ischartype_l(
              int       const _C,
              int       const _Mask,
          _locale_t const _Locale
        )
    {
        if (_Locale) {
            if (_C >= -1 && _C <= 255)
            {
                return __acrt_get_locale_data_prefix(_Locale)->_locale_pctype[_C] & _Mask;
            }

            if (__acrt_get_locale_data_prefix(_Locale)->_locale_mb_cur_max > 1)
            {
                return _isctype_l(_C, _Mask, _Locale);
            }

            return 0; 
        }

        return _chvalidchk_l(_C, _Mask, 0);
    }

    
#line 293 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\ctype.h"


#line 301 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\ctype.h"


#line 305 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\ctype.h"
} __pragma(pack(pop))

#pragma warning(pop) 
#line 309 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\ctype.h"
#line 13 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cctype"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
using :: isalnum;
using :: isalpha;
using :: iscntrl;
using :: isdigit;
using :: isgraph;
using :: islower;
using :: isprint;
using :: ispunct;
using :: isspace;
using :: isupper;
using :: isxdigit;
using :: tolower;
using :: toupper;

using :: isblank;
}


#pragma warning(pop)
#pragma pack(pop)

#line 45 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cctype"
#line 46 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cctype"
#line 13 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocinfo"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\clocale"


#pragma once


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\locale.h"


#pragma once


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


struct lconv
{
    char*    decimal_point;
    char*    thousands_sep;
    char*    grouping;
    char*    int_curr_symbol;
    char*    currency_symbol;
    char*    mon_decimal_point;
    char*    mon_thousands_sep;
    char*    mon_grouping;
    char*    positive_sign;
    char*    negative_sign;
    char     int_frac_digits;
    char     frac_digits;
    char     p_cs_precedes;
    char     p_sep_by_space;
    char     n_cs_precedes;
    char     n_sep_by_space;
    char     p_sign_posn;
    char     n_sign_posn;
    wchar_t* _W_decimal_point;
    wchar_t* _W_thousands_sep;
    wchar_t* _W_int_curr_symbol;
    wchar_t* _W_currency_symbol;
    wchar_t* _W_mon_decimal_point;
    wchar_t* _W_mon_thousands_sep;
    wchar_t* _W_positive_sign;
    wchar_t* _W_negative_sign;
};

struct tm;


     void __cdecl _lock_locales(void);
     void __cdecl _unlock_locales(void);

    
     int __cdecl _configthreadlocale(
          int _Flag
        );

        
     char* __cdecl setlocale(
                int         _Category,
          char const* _Locale
        );

    
     struct lconv* __cdecl localeconv(void);

    
     _locale_t __cdecl _get_current_locale(void);

    
     _locale_t __cdecl _create_locale(
            int         _Category,
          char const* _Locale
        );

     void __cdecl _free_locale(
          _locale_t _Locale
        );

    
     wchar_t* __cdecl _wsetlocale(
                int            _Category,
          wchar_t const* _Locale
        );

    
     _locale_t __cdecl _wcreate_locale(
            int            _Category,
          wchar_t const* _Locale
        );


     wchar_t**    __cdecl ___lc_locale_name_func(void);
     unsigned int __cdecl ___lc_codepage_func   (void);
     unsigned int __cdecl ___lc_collate_cp_func (void);


     char*    __cdecl _Getdays(void);

     
     char*    __cdecl _Getmonths(void);

     void*    __cdecl _Gettnames(void);

     
     wchar_t* __cdecl _W_Getdays(void);

     
     wchar_t* __cdecl _W_Getmonths(void);

     void*    __cdecl _W_Gettnames(void);

     
     size_t __cdecl _Strftime(
          char*           _Buffer,
                              size_t           _Max_size,
                            char const*      _Format,
                              struct tm const* _Timeptr,
                          void*            _Lc_time_arg);

     
     size_t __cdecl _Wcsftime(
          wchar_t*        _Buffer,
                              size_t           _Max_size,
                            wchar_t const*   _Format,
                              struct tm const* _Timeptr,
                          void*            _Lc_time_arg
        );

#line 179 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\locale.h"


} __pragma(pack(pop))

#pragma warning(pop) 
#line 185 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\locale.h"
#line 13 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\clocale"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
using :: lconv;
using :: localeconv;
using :: setlocale;
}


#pragma warning(pop)
#pragma pack(pop)

#line 33 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\clocale"
#line 34 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\clocale"
#line 14 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocinfo"


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


extern "C" {


 _Collvec __cdecl _Getcoll();
 _Ctypevec __cdecl _Getctype();
 _Cvtvec __cdecl _Getcvt();
 int __cdecl _Getdateorder();


   int __cdecl _Mbrtowc(
     wchar_t*, const char*, size_t _Max_multibyte, mbstate_t*, const _Cvtvec*);
#line 62 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocinfo"

 float __cdecl _Stof(const char*,     char**, long);
 double __cdecl _Stod(const char*,     char**, long);
 long double __cdecl _Stold(const char*,     char**, long);

 int __cdecl _Strcoll(const char*, const char*, const char*, const char*, const _Collvec*);
 size_t __cdecl _Strxfrm( 
                                                            char* _String1,
      char* _End1, const char*, const char*, const _Collvec*);
 int __cdecl _Tolower(int, const _Ctypevec*);
 int __cdecl _Toupper(int, const _Ctypevec*);
   int __cdecl
    _Wcrtomb(  char*, wchar_t, mbstate_t*, const _Cvtvec*);
 int __cdecl _Wcscoll(
    const wchar_t*, const wchar_t*, const wchar_t*, const wchar_t*, const _Collvec*);
 size_t __cdecl _Wcsxfrm(   
                                                          wchar_t* _String1,
      wchar_t* _End1, const wchar_t*, const wchar_t*, const _Collvec*);

 short __cdecl _Getwctype(wchar_t, const _Ctypevec*);
 const wchar_t* __cdecl _Getwctypes(
    const wchar_t*, const wchar_t*, short*, const _Ctypevec*);
 wchar_t __cdecl _Towlower(wchar_t, const _Ctypevec*);
 wchar_t __cdecl _Towupper(wchar_t, const _Ctypevec*);

}

extern "C" {
     char* __cdecl _Getdays();

     char* __cdecl _Getmonths();

 void* __cdecl _Gettnames();

   size_t __cdecl _Strftime(
      char*,   size_t _Maxsize,   const char*,   const tm*,   void*);

     wchar_t* __cdecl _W_Getdays();

     wchar_t* __cdecl _W_Getmonths();

 void* __cdecl _W_Gettnames();

   size_t __cdecl _Wcsftime(
      wchar_t*,   size_t _Maxsize,   const wchar_t*,   const tm*,   void*);
}


 _locale_t __cdecl _GetLocaleForCP(unsigned int);
#line 116 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocinfo"

namespace std {
class  _Timevec { 
public:
    explicit  _Timevec(void* _Ptr = nullptr) : _Timeptr(_Ptr) {}

     _Timevec(const _Timevec& _Right) : _Timeptr(nullptr) {
        *this = _Right;
    }

     ~_Timevec() noexcept {
        :: free(_Timeptr);
    }

    _Timevec&  operator=(const _Timevec& _Right) { 
        if (this != &_Right) {
            :: free(_Timeptr);
            _Timeptr                               = _Right._Timeptr;
            const_cast<_Timevec&>(_Right)._Timeptr = nullptr; 
        }

        return *this;
    }

    void*  _Getptr() const {
        return _Timeptr;
    }

private:
    void* _Timeptr; 
};

template <class _Elem>
class  _Yarn { 
public:
     _Yarn() noexcept : _Myptr(nullptr), _Nul(0) {}

     _Yarn(const _Yarn& _Right) noexcept : _Myptr(nullptr), _Nul(0) {
        *this = _Right;
    }

     _Yarn(const _Elem* _Right) noexcept : _Myptr(nullptr), _Nul(0) {
        *this = _Right;
    }

    _Yarn&  operator=(const _Yarn& _Right) noexcept {
        return *this = _Right._Myptr;
    }

    _Yarn&  operator=(const _Elem* _Right) noexcept {
        if (_Myptr != _Right) { 
            _Tidy();

            if (_Right) { 
                const _Elem* _Ptr = _Right;
                while (*_Ptr != _Elem{}) {
                    ++_Ptr;
                }

                const auto _Count = (++_Ptr - _Right) * sizeof(_Elem);


                _Myptr = static_cast<_Elem*>(:: malloc(_Count));
#line 182 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocinfo"

                if (_Myptr) {
                    :: memcpy(_Myptr, _Right, _Count);
                }
            }
        }

        return *this;
    }

     ~_Yarn() noexcept {
        _Tidy();
    }

    [[nodiscard]] bool  empty() const noexcept {
        return _Myptr == nullptr;
    }

      const _Elem*  c_str() const noexcept {
        return _Myptr ? _Myptr : &_Nul;
    }

    [[nodiscard]] bool  _Empty() const noexcept {
        return _Myptr == nullptr;
    }

      const _Elem*  _C_str() const noexcept {
        return _Myptr ? _Myptr : &_Nul;
    }

private:
    void  _Tidy() noexcept {
        if (_Myptr) {


            :: free(_Myptr);
#line 220 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocinfo"
        }

        _Myptr = nullptr;
    }

    _Elem* _Myptr; 
    _Elem _Nul; 
};

class  _Locinfo { 
public:
    using _Collvec  = ::_Collvec;
    using _Ctypevec = ::_Ctypevec;
    using _Cvtvec   = ::_Cvtvec;
    using _Timevec  = ::std:: _Timevec;

    static void __cdecl _Locinfo_ctor(_Locinfo*, const char*);
    static void __cdecl _Locinfo_ctor(_Locinfo*, int, const char*);
    static void __cdecl _Locinfo_dtor(_Locinfo*);
    static _Locinfo& __cdecl _Locinfo_Addcats(_Locinfo*, int, const char*);

     _Locinfo(const char* _Pch = "C")

        : _Lock(0)
#line 245 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocinfo"

    {
        if (_Pch) {
            _Locinfo_ctor(this, _Pch);
            return;
        }

        _Xruntime_error("bad locale name");
    }

     _Locinfo(int _Cat, const char* _Pch)

        : _Lock(0)
#line 259 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocinfo"

    {
        if (_Pch) {
            _Locinfo_ctor(this, _Cat, _Pch);
            return;
        }

        _Xruntime_error("bad locale name");
    }

     ~_Locinfo() noexcept {
        _Locinfo_dtor(this);
    }

    _Locinfo&  _Addcats(int _Cat, const char* _Pch) { 
        if (_Pch) {
            return _Locinfo_Addcats(this, _Cat, _Pch);
        }

        _Xruntime_error("bad locale name");
    }

    const char*  _Getname() const {
        return _Newlocname._C_str();
    }

    _Collvec  _Getcoll() const {
        return ::_Getcoll();
    }

    _Ctypevec  _Getctype() const {
        return ::_Getctype();
    }

    _Cvtvec  _Getcvt() const {
        return ::_Getcvt();
    }

    const lconv*  _Getlconv() const {
        return localeconv();
    }

    _Timevec  _Gettnames() const {
        return _Timevec(::_Gettnames());
    }

    const char*  _Getdays() const {
        const char* _Ptr = ::_Getdays();
        if (_Ptr) { 
            const_cast<_Locinfo*>(this)->_Days = _Ptr;
            :: free(const_cast<char*>(_Ptr));
        }

        return !_Days._Empty() ? _Days._C_str()
                               : ":Sun:Sunday:Mon:Monday:Tue:Tuesday:Wed:Wednesday"
                                 ":Thu:Thursday:Fri:Friday:Sat:Saturday";
    }

    const char*  _Getmonths() const {
        const char* _Ptr = ::_Getmonths();
        if (_Ptr) { 
            const_cast<_Locinfo*>(this)->_Months = _Ptr;
            :: free(const_cast<char*>(_Ptr));
        }

        return !_Months._Empty() ? _Months._C_str()
                                 : ":Jan:January:Feb:February:Mar:March"
                                   ":Apr:April:May:May:Jun:June"
                                   ":Jul:July:Aug:August:Sep:September"
                                   ":Oct:October:Nov:November:Dec:December";
    }

    const char*  _Getfalse() const {
        return "false";
    }

    const char*  _Gettrue() const {
        return "true";
    }

    int  _Getdateorder() const {
        return ::_Getdateorder();
    }

    _Timevec  _W_Gettnames() const {
        return _Timevec(::_W_Gettnames());
    }

    const unsigned short*  _W_Getdays() const {
        const wchar_t* _Ptr = ::_W_Getdays();
        if (_Ptr) { 
            const_cast<_Locinfo*>(this)->_W_Days = _Ptr;
            :: free(const_cast<wchar_t*>(_Ptr));
        }

        const wchar_t* _Ret;

        if (_W_Days._Empty()) {
            _Ret = L":Sun:Sunday:Mon:Monday:Tue:Tuesday:Wed:Wednesday:Thu:Thursday:Fri:Friday:Sat:Saturday";
        } else {
            _Ret = _W_Days._C_str();
        }

        return reinterpret_cast<const unsigned short*>(_Ret);
    }

    const unsigned short*  _W_Getmonths() const {
        const wchar_t* _Ptr = ::_W_Getmonths();
        if (_Ptr) { 
            const_cast<_Locinfo*>(this)->_W_Months = _Ptr;
            :: free(const_cast<wchar_t*>(_Ptr));
        }

        const wchar_t* _Ret;

        if (_W_Months._Empty()) {
            _Ret = L":Jan:January:Feb:February:Mar:March:Apr:April:May:May:Jun:June"
                   L":Jul:July:Aug:August:Sep:September:Oct:October:Nov:November:Dec:December";
        } else {
            _Ret = _W_Months._C_str();
        }

        return reinterpret_cast<const unsigned short*>(_Ret);
    }

    _Locinfo(const _Locinfo&) = delete;
    _Locinfo& operator=(const _Locinfo&) = delete;

private:


    _Lockit _Lock; 
#line 394 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocinfo"

    _Yarn<char> _Days; 
    _Yarn<char> _Months; 
    _Yarn<wchar_t> _W_Days; 
    _Yarn<wchar_t> _W_Months; 
    _Yarn<char> _Oldlocname; 
    _Yarn<char> _Newlocname; 
};

template <class _Elem>
int __cdecl _LStrcoll(const _Elem* _First1, const _Elem* _Last1, const _Elem* _First2, const _Elem* _Last2,
    const _Locinfo::_Collvec*) { 
    for (; _First1 != _Last1 && _First2 != _Last2; ++_First1, ++_First2) {
        if (*_First1 < *_First2) {
            return -1; 
        } else if (*_First2 < *_First1) {
            return +1; 
        }
    }

    return _First2 != _Last2 ? -1 : _First1 != _Last1 ? +1 : 0;
}

template <>
inline int __cdecl _LStrcoll(const char* _First1, const char* _Last1, const char* _First2, const char* _Last2,
    const _Locinfo::_Collvec* _Vector) { 
    return _Strcoll(_First1, _Last1, _First2, _Last2, _Vector);
}

template <>
inline int __cdecl _LStrcoll(const wchar_t* _First1, const wchar_t* _Last1, const wchar_t* _First2,
    const wchar_t* _Last2,
    const _Locinfo::_Collvec* _Vector) { 
    return _Wcscoll(_First1, _Last1, _First2, _Last2, _Vector);
}

template <class _Elem>
size_t __cdecl _LStrxfrm(_Elem* _First1, _Elem* _Last1, const _Elem* _First2, const _Elem* _Last2,
    const _Locinfo::_Collvec*) { 
    const ptrdiff_t _Count = _Last2 - _First2;
    if (_Count <= _Last1 - _First1) {
        :: memcpy(_First1, _First2, _Count * sizeof(_Elem));
    }

    return _Count;
}

template <>
inline size_t __cdecl _LStrxfrm(    char* _First1,
      char* _Last1, const char* _First2, const char* _Last2,
    const _Locinfo::_Collvec* _Vector) { 
    return _Strxfrm(_First1, _Last1, _First2, _Last2, _Vector);
}

template <>
inline size_t __cdecl _LStrxfrm(    wchar_t* _First1,
      wchar_t* _Last1, const wchar_t* _First2, const wchar_t* _Last2,
    const _Locinfo::_Collvec* _Vector) { 
    return _Wcsxfrm(_First1, _Last1, _First2, _Last2, _Vector);
}
}


#pragma warning(pop)
#pragma pack(pop)
#line 460 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocinfo"
#line 461 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocinfo"
#line 17 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocale"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
template <class _Dummy>
class _Locbase { 
public:
     static const int collate  = ((1 << (1)) >> 1);
     static const int ctype    = ((1 << (2)) >> 1);
     static const int monetary = ((1 << (3)) >> 1);
     static const int numeric  = ((1 << (4)) >> 1);
     static const int time     = ((1 << (5)) >> 1);
     static const int messages = ((1 << (6)) >> 1);
     static const int all      = (((1 << ((6 + 1))) >> 1) - 1);
     static const int none     = 0;
};

template <class _Dummy>
const int _Locbase<_Dummy>::collate;
template <class _Dummy>
const int _Locbase<_Dummy>::ctype;
template <class _Dummy>
const int _Locbase<_Dummy>::monetary;
template <class _Dummy>
const int _Locbase<_Dummy>::numeric;
template <class _Dummy>
const int _Locbase<_Dummy>::time;
template <class _Dummy>
const int _Locbase<_Dummy>::messages;
template <class _Dummy>
const int _Locbase<_Dummy>::all;
template <class _Dummy>
const int _Locbase<_Dummy>::none;

template <class _Elem>
class collate;

struct  _Crt_new_delete { 


};

class locale : public _Locbase<int>, public _Crt_new_delete { 
public:
    using category = int;

    class  id { 
    public:
         id(size_t _Val = 0) : _Id(_Val) {}

        id(const id&) = delete;
        id& operator=(const id&) = delete;

         operator size_t() { 
            if (_Id == 0) { 
                { ::std:: _Lockit _Lock(0);
                if (_Id == 0) {
                    _Id = static_cast<size_t>(++_Id_cnt);
                }
                }
            }
            return _Id;
        }

    private:
        size_t _Id; 

         static int _Id_cnt;
    };

    class _Locimp;

    class  facet : public _Facet_base, public _Crt_new_delete {
        
    private:
        friend struct _Facet_guard;

    public:
        static size_t __cdecl _Getcat(const facet** = nullptr, const locale* = nullptr) {
            
            return static_cast<size_t>(-1);
        }

        void  _Incref() noexcept override { 
            _InterlockedIncrement(reinterpret_cast<volatile long*>(&_Myrefs));
        }

        _Facet_base*  _Decref() noexcept override { 
            if (_InterlockedDecrement(reinterpret_cast<volatile long*>(&_Myrefs)) == 0) {
                return this;
            }

            return nullptr;
        }

    private:
        _Atomic_counter_t _Myrefs; 

    protected:
        explicit  facet(size_t _Initrefs = 0)
            : _Myrefs(static_cast<_Atomic_counter_t>(_Initrefs)) 
        {}

         ~facet() noexcept override {}

    public:
         facet(const facet&) = delete;
        facet&  operator=(const facet&) = delete;
    };

    struct [[nodiscard]] _Facet_guard {
        facet* _Target;
        ~_Facet_guard() {
            if (_Target) {
                delete _Target->_Decref();
            }
        }
    };

    class  _Locimp : public facet { 
    protected:
         ~_Locimp() noexcept {
            _Locimp_dtor(this);
        }

    private:
        static _Locimp* __cdecl _New_Locimp(bool _Transparent = false);
        static _Locimp* __cdecl _New_Locimp(const _Locimp& _Right);

        static void __cdecl _Locimp_dtor(_Locimp*);
        static void __cdecl _Locimp_Addfac(_Locimp*, facet*, size_t); 
        static void __cdecl _Locimp_ctor(_Locimp*, const _Locimp&);

        friend locale;

         _Locimp(bool _Transparent)
            : locale::facet(1), _Facetvec(nullptr), _Facetcount(0), _Catmask(none), _Xparent(_Transparent), _Name("*") {
        }

         _Locimp(const _Locimp& _Right)
            : locale::facet(1), _Facetvec(nullptr), _Facetcount(_Right._Facetcount), _Catmask(_Right._Catmask),
              _Xparent(_Right._Xparent), _Name(_Right._Name.c_str()) {
            _Locimp_ctor(this, _Right);
        }

        void  _Addfac(facet* _Pfacet, size_t _Id) { 
            _Locimp_Addfac(this, _Pfacet, _Id);
        }

        static _Locimp* __cdecl _Makeloc(
            const _Locinfo&, category, _Locimp*, const locale*); 

        static void __cdecl _Makewloc(
            const _Locinfo&, category, _Locimp*, const locale*); 


        static void __cdecl _Makeushloc(
            const _Locinfo&, category, _Locimp*, const locale*); 
#line 207 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocale"

        static void __cdecl _Makexloc(
            const _Locinfo&, category, _Locimp*, const locale*); 

        facet** _Facetvec; 
        size_t _Facetcount; 
        category _Catmask; 
        bool _Xparent; 
        _Yarn<char> _Name; 

         static _Locimp* _Clocptr;

    public:
        _Locimp&  operator=(const _Locimp&) = delete;
    };

    template <class _Elem, class _Traits, class _Alloc>
    bool operator()(
        const basic_string<_Elem, _Traits, _Alloc>& _Left, const basic_string<_Elem, _Traits, _Alloc>& _Right) const {
        
        const auto& _Coll_fac = ::std:: use_facet<::std:: collate<_Elem>>(*this);

        const _Elem* const _Left_data  = _Left.data();
        const _Elem* const _Right_data = _Right.data();
        return _Coll_fac.compare(_Left_data, _Left_data + _Left.size(), _Right_data, _Right_data + _Right.size()) < 0;
    }

    template <class _Facet>
    locale combine(const locale& _Loc) const { 
        _Facet* _Facptr;

        try {
        _Facptr = const_cast<_Facet*>(::std:: addressof(::std:: use_facet<_Facet>(_Loc)));
        } catch (...) {
        _Xruntime_error("locale::combine facet missing");
        }

        _Locimp* _Newimp = _Locimp::_New_Locimp(*_Ptr);
        _Newimp->_Addfac(_Facptr, _Facet::id);
        _Newimp->_Catmask = none;
        _Newimp->_Name    = "*";
        return locale(_Newimp);
    }

    template <class _Facet>
    locale(const locale& _Loc, const _Facet* _Facptr) : _Ptr(_Locimp::_New_Locimp(*_Loc._Ptr)) {
        if (_Facptr) { 
            _Ptr->_Addfac(const_cast<_Facet*>(_Facptr), _Facet::id);
            _Ptr->_Catmask = none;
            _Ptr->_Name    = "*";
        }
    }

    locale(_Uninitialized) {} 

    locale(const locale& _Right) noexcept : _Ptr(_Right._Ptr) {
        _Ptr->_Incref();
    }

    locale() noexcept : _Ptr(_Init(true)) {}


    locale(const locale& _Loc, const locale& _Other, category _Cat) : _Ptr(_Locimp::_New_Locimp(*_Loc._Ptr)) {
        
        if (_Cat != none) { 
            _Facet_guard _Guard{_Ptr};
            { _Locinfo _Lobj;
            _Locimp::_Makeloc(_Lobj, _Cat, _Ptr, &_Other);
            _Lobj._Addcats(_Loc._Ptr->_Catmask, _Loc.name().c_str());
            _Lobj._Addcats(_Other._Ptr->_Catmask, _Other.name().c_str());
            _Ptr->_Catmask = _Loc._Ptr->_Catmask | _Other._Ptr->_Catmask;
            _Ptr->_Name    = _Lobj._Getname();
            }
            _Guard._Target = nullptr;
        }
    }

private:
    void _Construct(const string& _Str, category _Cat) {
        
        bool _Bad = false;
        _Init();
        if (_Cat != none) { 
            _Facet_guard _Guard{_Ptr};
            { _Locinfo _Lobj(_Cat, _Str.c_str());
            if (_Badname(_Lobj)) {
                _Bad = true;
            } else { 
                _Locimp::_Makeloc(_Lobj, _Cat, _Ptr, nullptr);
                _Ptr->_Catmask = _Cat;
                _Ptr->_Name    = _Str.c_str();
            }
            }
            _Guard._Target = nullptr;
        }

        if (_Bad) { 
            delete _Ptr->_Decref();
            _Xruntime_error("bad locale name");
        }
    }

public:
    explicit locale(const char* _Locname, category _Cat = all) : _Ptr(_Locimp::_New_Locimp()) {
        
        
        if (_Locname) {
            _Construct(_Locname, _Cat);
            return;
        }

        _Xruntime_error("bad locale name");
    }

    locale(const locale& _Loc, const char* _Locname, category _Cat) : _Ptr(_Locimp::_New_Locimp(*_Loc._Ptr)) {
        
        
        if (_Locname) {
            _Construct(_Locname, _Cat);
            return;
        }

        _Xruntime_error("bad locale name");
    }

    explicit locale(const string& _Str, category _Cat = all) : _Ptr(_Locimp::_New_Locimp()) {
        
        _Construct(_Str, _Cat);
    }

    locale(const locale& _Loc, const string& _Str, category _Cat) : _Ptr(_Locimp::_New_Locimp(*_Loc._Ptr)) {
        
        _Construct(_Str, _Cat);
    }
#line 344 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocale"

    ~locale() noexcept {
        if (_Ptr) {
            delete _Ptr->_Decref();
        }
    }

    const locale& operator=(const locale& _Right) noexcept {
        if (_Ptr != _Right._Ptr) { 
            delete _Ptr->_Decref();
            _Ptr = _Right._Ptr;
            _Ptr->_Incref();
        }
        return *this;
    }

    string name() const {
        return _Ptr ? _Ptr->_Name.c_str() : string();
    }

      const char* c_str() const {
        return _Ptr ? _Ptr->_Name.c_str() : "";
    }

    const facet* _Getfacet(size_t _Id) const { 
        const facet* _Facptr = _Id < _Ptr->_Facetcount ? _Ptr->_Facetvec[_Id] : nullptr; 
        if (_Facptr || !_Ptr->_Xparent) {
            return _Facptr; 
        }

        
        locale::_Locimp* _Ptr0 = _Getgloballocale();
        if (_Id < _Ptr0->_Facetcount) {
            return _Ptr0->_Facetvec[_Id]; 
        }

        return nullptr; 
    }

    [[nodiscard]] bool operator==(const locale& _Loc) const { 
        return _Ptr == _Loc._Ptr || (name().compare("*") != 0 && name().compare(_Loc.name()) == 0);
    }


#line 392 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocale"

    static  const locale& __cdecl classic(); 

    static  locale __cdecl global(const locale&); 

    static  locale __cdecl empty(); 

private:
    locale(_Locimp* _Ptrimp) : _Ptr(_Ptrimp) {}

    static  _Locimp* __cdecl _Init(bool _Do_incref = false); 
    static  _Locimp* __cdecl _Getgloballocale();
    static  void __cdecl _Setgloballocale(void*);

    bool _Badname(const _Locinfo& _Lobj) { 
        return :: strcmp(_Lobj._Getname(), "*") == 0;
    }

    _Locimp* _Ptr; 
};

template <class _Facet>
struct _Facetptr { 
     static const locale::facet* _Psave;
};

template <class _Facet>
 const locale::facet* _Facetptr<_Facet>::_Psave = nullptr;

template <class _Facet>
const _Facet& __cdecl use_facet(const locale& _Loc) { 
    { ::std:: _Lockit _Lock(0); 
    const locale::facet* _Psave = _Facetptr<_Facet>::_Psave; 

    const size_t _Id         = _Facet::id;
    const locale::facet* _Pf = _Loc._Getfacet(_Id);

    if (!_Pf) {
        if (_Psave) {
            _Pf = _Psave; 
        } else if (_Facet::_Getcat(&_Psave, &_Loc) == static_cast<size_t>(-1)) {

            _Throw_bad_cast(); 


#line 438 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocale"
        } else { 
            auto _Pfmod = const_cast<locale::facet*>(_Psave);
            unique_ptr<_Facet_base> _Psave_guard(static_cast<_Facet_base*>(_Pfmod));


#line 445 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocale"
            _Facet_Register(_Pfmod);
#line 447 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocale"

            _Pfmod->_Incref();
            _Facetptr<_Facet>::_Psave = _Psave;
            _Pf                       = _Psave;

            (void) _Psave_guard.release();
        }
    }

    return static_cast<const _Facet&>(*_Pf); 
    }
} 

template <class _Elem>
char __cdecl _Maklocbyte(_Elem _Char, const _Locinfo::_Cvtvec&) {
    
    return static_cast<char>(static_cast<unsigned char>(_Char));
}

template <>
inline char __cdecl _Maklocbyte(wchar_t _Char, const _Locinfo::_Cvtvec& _Cvt) {
    
    char _Byte       = '\0';
    mbstate_t _Mbst1 = {};
    _Wcrtomb(&_Byte, _Char, &_Mbst1, &_Cvt);
    return _Byte;
}


template <>
inline char __cdecl _Maklocbyte(unsigned short _Char, const _Locinfo::_Cvtvec& _Cvt) {
    
    char _Byte       = '\0';
    mbstate_t _Mbst1 = {};
    _Wcrtomb(&_Byte, static_cast<wchar_t>(_Char), &_Mbst1, &_Cvt);
    return _Byte;
}
#line 485 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocale"

template <class _Elem>
_Elem __cdecl _Maklocchr(char _Byte, _Elem*, const _Locinfo::_Cvtvec&) {
    
    return static_cast<_Elem>(static_cast<unsigned char>(_Byte));
}

template <>
inline wchar_t __cdecl _Maklocchr(char _Byte, wchar_t*, const _Locinfo::_Cvtvec& _Cvt) {
    
    wchar_t _Wc      = L'\0';
    mbstate_t _Mbst1 = {};
    _Mbrtowc(&_Wc, &_Byte, 1, &_Mbst1, &_Cvt);
    return _Wc;
}


template <>
inline unsigned short __cdecl _Maklocchr(char _Byte, unsigned short*, const _Locinfo::_Cvtvec& _Cvt) {
    
    unsigned short _Wc = 0;
    mbstate_t _Mbst1   = {};
    _Mbrtowc(reinterpret_cast<wchar_t*>(&_Wc), &_Byte, 1, &_Mbst1, &_Cvt);
    return _Wc;
}
#line 511 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocale"

template <class _Elem>
_Elem* __cdecl _Maklocstr(const char* _Ptr, _Elem*, const _Locinfo::_Cvtvec&) {
    
    size_t _Count = :: strlen(_Ptr) + 1;

    _Elem* _Ptrdest = static_cast<_Elem*>(calloc(_Count, sizeof(_Elem)));

    if (!_Ptrdest) {
        _Xbad_alloc();
    }

    for (_Elem* _Ptrnext = _Ptrdest; 0 < _Count; --_Count, ++_Ptrnext, ++_Ptr) {
        *_Ptrnext = static_cast<_Elem>(static_cast<unsigned char>(*_Ptr));
    }

    return _Ptrdest;
}

template <>
inline wchar_t* __cdecl _Maklocstr(const char* _Ptr, wchar_t*, const _Locinfo::_Cvtvec& _Cvt) {
    
    size_t _Count;
    size_t _Count1;
    size_t _Wchars;
    const char* _Ptr1;
    int _Bytes;
    wchar_t _Wc;
    mbstate_t _Mbst1 = {};

    _Count1 = :: strlen(_Ptr) + 1;
    for (_Count = _Count1, _Wchars = 0, _Ptr1 = _Ptr; 0 < _Count; _Count -= _Bytes, _Ptr1 += _Bytes, ++_Wchars) {
        if ((_Bytes = _Mbrtowc(&_Wc, _Ptr1, _Count, &_Mbst1, &_Cvt)) <= 0) {
            break;
        }
    }

    ++_Wchars; 

    wchar_t* _Ptrdest = static_cast<wchar_t*>(calloc(_Wchars, sizeof(wchar_t)));

    if (!_Ptrdest) {
        _Xbad_alloc();
    }

    wchar_t* _Ptrnext = _Ptrdest;
    mbstate_t _Mbst2  = {};

    for (; 0 < _Wchars; _Count -= _Bytes, _Ptr += _Bytes, --_Wchars, ++_Ptrnext) {
        if ((_Bytes = _Mbrtowc(_Ptrnext, _Ptr, _Count1, &_Mbst2, &_Cvt)) <= 0) {
            break;
        }
    }

    *_Ptrnext = L'\0';

    return _Ptrdest;
}


template <>
inline unsigned short* __cdecl _Maklocstr(const char* _Ptr, unsigned short*, const _Locinfo::_Cvtvec& _Cvt) {
    
    size_t _Count;
    size_t _Count1;
    size_t _Wchars;
    const char* _Ptr1;
    int _Bytes;
    unsigned short _Wc;
    mbstate_t _Mbst1 = {};

    _Count1 = :: strlen(_Ptr) + 1;
    for (_Count = _Count1, _Wchars = 0, _Ptr1 = _Ptr; 0 < _Count; _Count -= _Bytes, _Ptr1 += _Bytes, ++_Wchars) {
        if ((_Bytes = _Mbrtowc(reinterpret_cast<wchar_t*>(&_Wc), _Ptr1, _Count, &_Mbst1, &_Cvt)) <= 0) {
            break;
        }
    }

    ++_Wchars; 

    wchar_t* _Ptrdest = static_cast<wchar_t*>(calloc(_Wchars, sizeof(wchar_t)));

    if (!_Ptrdest) {
        _Xbad_alloc();
    }

    wchar_t* _Ptrnext = _Ptrdest;
    mbstate_t _Mbst2  = {};
    for (; 0 < _Wchars; _Count -= _Bytes, _Ptr += _Bytes, --_Wchars, ++_Ptrnext) {
        if ((_Bytes = _Mbrtowc(_Ptrnext, _Ptr, _Count1, &_Mbst2, &_Cvt)) <= 0) {
            break;
        }
    }

    *_Ptrnext = L'\0';
    return reinterpret_cast<unsigned short*>(_Ptrdest);
}
#line 609 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocale"

class  codecvt_base : public locale::facet { 
public:
    enum { 
        ok,
        partial,
        error,
        noconv
    };
    using result = int;

     codecvt_base(size_t _Refs = 0) : locale::facet(_Refs) {}

    bool  always_noconv() const noexcept {
        
        return do_always_noconv();
    }

    int  max_length() const noexcept {
        
        return do_max_length();
    }

    int  encoding() const noexcept {
        return do_encoding();
    }

     ~codecvt_base() noexcept {}

protected:
    virtual bool  do_always_noconv() const noexcept {
        
        return false;
    }

    virtual int  do_max_length() const noexcept {
        
        return 1;
    }

    virtual int  do_encoding() const noexcept {
        return 1; 
    }
};

template <class _Elem, class _Byte, class _Statype>
class codecvt : public codecvt_base { 
public:
    
    
    static_assert(!0 || is_same_v<codecvt, codecvt<char, char, mbstate_t>>,
        "Unsupported facet specialization; see N4800 27.3.1.1.1 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this diagnostic.");

    using intern_type = _Elem;
    using extern_type = _Byte;
    using state_type  = _Statype;

    result  in(_Statype& _State, const _Byte* _First1, const _Byte* _Last1, const _Byte*& _Mid1,
        _Elem* _First2, _Elem* _Last2, _Elem*& _Mid2) const { 
        return do_in(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
    }

    result  out(_Statype& _State, const _Elem* _First1, const _Elem* _Last1, const _Elem*& _Mid1,
        _Byte* _First2, _Byte* _Last2, _Byte*& _Mid2) const { 
        return do_out(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
    }

    result  unshift(_Statype& _State, _Byte* _First2, _Byte* _Last2, _Byte*& _Mid2) const {
        
        return do_unshift(_State, _First2, _Last2, _Mid2);
    }

    int  length(_Statype& _State, const _Byte* _First1, const _Byte* _Last1, size_t _Count) const {
        
        
        return do_length(_State, _First1, _Last1, _Count);
    }

     static locale::id id; 

    explicit  codecvt(size_t _Refs = 0) : codecvt_base(_Refs) {
        _Init(_Locinfo());
    }

    explicit  codecvt(const _Locinfo& _Lobj, size_t _Refs = 0) : codecvt_base(_Refs) {
        _Init(_Lobj);
    }

    static size_t __cdecl _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
        
        if (_Ppf && !*_Ppf) {
            *_Ppf = new codecvt(_Locinfo(_Ploc->c_str()));
        }

        return 2;
    }

protected:
     ~codecvt() noexcept override {}

    void  _Init(const _Locinfo&) {} 

    bool  do_always_noconv() const noexcept override {
        
        return is_same_v<_Byte, _Elem>;
    }

    virtual result  do_in(_Statype&, const _Byte* _First1, const _Byte* _Last1, const _Byte*& _Mid1,
        _Elem* _First2, _Elem* _Last2, _Elem*& _Mid2) const { 
        _Mid1 = _First1;
        _Mid2 = _First2;
        if constexpr (is_same_v<_Byte, _Elem>) {
            return noconv; 
        } else {
            
            for (; _Mid1 != _Last1; ++_Mid1, ++_Mid2) {
                if (_Mid2 == _Last2) {
                    return partial;
                }
                *_Mid2 = static_cast<_Elem>(*_Mid1);
            }

            return ok;
        }
    }

    virtual result  do_out(_Statype&, const _Elem* _First1, const _Elem* _Last1, const _Elem*& _Mid1,
        _Byte* _First2, _Byte* _Last2, _Byte*& _Mid2) const { 
        _Mid1 = _First1;
        _Mid2 = _First2;
        if constexpr (is_same_v<_Byte, _Elem>) {
            return noconv; 
        } else {
            
            for (; _Mid1 != _Last1; ++_Mid1, ++_Mid2) {
                if (_Mid2 == _Last2) {
                    return partial;
                }
                *_Mid2 = static_cast<_Byte>(*_Mid1);
            }

            return ok;
        }
    }

    virtual result  do_unshift(_Statype&, _Byte* _First2, _Byte*, _Byte*& _Mid2) const {
        
        _Mid2 = _First2;
        return noconv; 
    }

    virtual int  do_length(
        _Statype&, const _Byte* _First1, const _Byte* _Last1, size_t _Count) const {
        
        
        const auto _Dist = static_cast<size_t>((::std:: min)(_Last1 - _First1, ptrdiff_t{2147483647}));
        return static_cast<int>((::std:: min)(_Count, _Dist));
    }
};


template <class _Elem, class _Byte, class _Statype>
 locale::id codecvt<_Elem, _Byte, _Statype>::id;


template <class _CvtTy, class _Byte, class _Statype>
[[nodiscard]] int _Codecvt_do_length(
    const _CvtTy& _Cvt, _Statype& _State, const _Byte* _First1, const _Byte* _Last1, size_t _Count) {
    
    
    __pragma(warning(push)) __pragma(warning(disable : 4996))
    using _Elem = typename _CvtTy::intern_type;
    __pragma(warning(pop))

    _Adl_verify_range(_First1, _Last1);
    const auto _Old_first1 = _First1;

    while (_Count > 0 && _First1 != _Last1) { 
        const _Byte* _Mid1;
        _Elem* _Mid2;
        _Elem _Ch;

        
        __pragma(warning(push)) __pragma(warning(disable : 4996))
        const auto _Result = _Cvt._CvtTy::do_in(_State, _First1, _Last1, _Mid1, &_Ch, &_Ch + 1, _Mid2);
        __pragma(warning(pop))

        if (_Result != codecvt_base::ok) {
            if (_Result == codecvt_base::noconv) {
                _First1 += (::std:: min)(static_cast<size_t>(_Last1 - _First1), _Count);
            }

            break; 
        }

        if (_Mid2 == &_Ch + 1) {
            --_Count; 
        }

        _First1 = _Mid1;
    }

    return static_cast<int>((::std:: min)(_First1 - _Old_first1, ptrdiff_t{2147483647}));
}

enum _Codecvt_mode { _Consume_header = 4, _Generate_header = 2 };

template <>
class  [[deprecated("warning STL4020: " "std::codecvt<char16_t, char, mbstate_t>, std::codecvt<char32_t, char, mbstate_t>, " "std::codecvt_byname<char16_t, char, mbstate_t>, and std::codecvt_byname<char32_t, char, mbstate_t> " "are deprecated in C++20 and replaced by specializations with a second argument of type char8_t. " "You can define _SILENCE_CXX20_CODECVT_FACETS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]]
    codecvt<char16_t, char, mbstate_t> : public codecvt_base {
    
public:
    using intern_type = char16_t;
    using extern_type = char;
    using state_type  = mbstate_t;

    result  in(mbstate_t& _State, const char* _First1, const char* _Last1, const char*& _Mid1,
        char16_t* _First2, char16_t* _Last2, char16_t*& _Mid2) const {
        
        return do_in(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
    }

    result  out(mbstate_t& _State, const char16_t* _First1, const char16_t* _Last1,
        const char16_t*& _Mid1, char* _First2, char* _Last2, char*& _Mid2) const {
        
        return do_out(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
    }

    result  unshift(mbstate_t& _State, char* _First2, char* _Last2, char*& _Mid2) const {
        
        return do_unshift(_State, _First2, _Last2, _Mid2);
    }

    int  length(mbstate_t& _State, const char* _First1, const char* _Last1, size_t _Count) const {
        
        
        return do_length(_State, _First1, _Last1, _Count);
    }

     static locale::id id;

    explicit  codecvt(size_t _Refs = 0)
        : codecvt_base(_Refs), _Maxcode(0x10ffff), _Mode(_Consume_header) {
        { _Locinfo _Lobj;
        _Init(_Lobj);
        }
    }

    explicit  codecvt(const _Locinfo& _Lobj, size_t _Refs = 0)
        : codecvt_base(_Refs), _Maxcode(0x10ffff), _Mode(_Consume_header) {
        _Init(_Lobj);
    }

     codecvt(
        const _Locinfo& _Lobj, unsigned long _Maxcode_arg, _Codecvt_mode _Mode_arg, size_t _Refs = 0)
        : codecvt_base(_Refs), _Maxcode(_Maxcode_arg), _Mode(_Mode_arg) {
        _Init(_Lobj);
    }

    static size_t __cdecl _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
        
        if (_Ppf && !*_Ppf) {
            __pragma(warning(push)) __pragma(warning(disable : 4996))
            *_Ppf = new codecvt(_Locinfo(_Ploc->c_str()));
            __pragma(warning(pop))
        }

        return 2;
    }

protected:
     ~codecvt() noexcept override {}

    void  _Init(const _Locinfo&) {} 

    virtual result  do_in(mbstate_t& _State, const char* _First1, const char* _Last1,
        const char*& _Mid1, char16_t* _First2, char16_t* _Last2, char16_t*& _Mid2) const {
        
        unsigned short* _Pstate = reinterpret_cast<unsigned short*>(&_State);
        _Mid1                   = _First1;
        _Mid2                   = _First2;

        while (_Mid1 != _Last1 && _Mid2 != _Last2) { 
            unsigned char _By = static_cast<unsigned char>(*_Mid1);
            unsigned long _Ch;
            int _Nextra;
            int _Nskip;

            if (*_Pstate > 1) {
                if (_By < 0x80 || 0xc0 <= _By) {
                    return codecvt::error; 
                }

                
                ++_Mid1;
                *_Mid2++ = static_cast<char16_t>(*_Pstate | (_By & 0x3f));
                *_Pstate = 1;
                continue;
            }

            if (_By < 0x80u) {
                _Ch     = _By;
                _Nextra = 0;
            } else if (_By < 0xc0u) { 
                ++_Mid1;
                return codecvt::error;
            } else if (_By < 0xe0u) {
                _Ch     = static_cast<unsigned long>(_By & 0x1f);
                _Nextra = 1;
            } else if (_By < 0xf0u) {
                _Ch     = static_cast<unsigned long>(_By & 0x0f);
                _Nextra = 2;
            } else if (_By < 0xf8u) {
                _Ch     = static_cast<unsigned long>(_By & 0x07);
                _Nextra = 3;
            } else {
                _Ch     = static_cast<unsigned long>(_By & 0x03);
                _Nextra = _By < 0xfc ? 4 : 5;
            }

            _Nskip  = _Nextra < 3 ? 0 : 1; 
            _First1 = _Mid1; 

            if (_Nextra == 0) {
                ++_Mid1;
            } else if (_Last1 - _Mid1 < _Nextra + 1 - _Nskip) {
                break; 
            } else {
                for (++_Mid1; _Nskip < _Nextra; --_Nextra, ++_Mid1) {
                    if ((_By = static_cast<unsigned char>(*_Mid1)) < 0x80u || 0xc0u <= _By) {
                        return codecvt::error; 
                    } else {
                        _Ch = _Ch << 6 | (_By & 0x3f);
                    }
                }
            }

            if (0 < _Nskip) {
                _Ch <<= 6; 
            }

            if ((_Maxcode < 0x10ffffu ? _Maxcode : 0x10ffffu) < _Ch) {
                return codecvt::error; 
            }

            if (0xffffu < _Ch) { 
                unsigned short _Ch0 = static_cast<unsigned short>(0xd800 | (_Ch >> 10) - 0x0040);

                *_Mid2++ = static_cast<char16_t>(_Ch0);
                *_Pstate = static_cast<unsigned short>(0xdc00 | (_Ch & 0x03ff));
                continue;
            }

            if (_Nskip != 0) {
                if (_Mid1 == _Last1) { 
                    _Mid1 = _First1;
                    break;
                }

                if ((_By = static_cast<unsigned char>(*_Mid1++)) < 0x80u || 0xc0u <= _By) {
                    return codecvt::error; 
                }

                _Ch |= _By & 0x3f; 
            }

            if (*_Pstate == 0u) { 
                *_Pstate = 1;

                if ((_Mode & _Consume_header) != 0 && _Ch == 0xfeffu) { 
                    const result _Ans = do_in(_State, _Mid1, _Last1, _Mid1, _First2, _Last2, _Mid2);

                    if (_Ans == codecvt::partial) { 
                        *_Pstate = 0;
                        _Mid1    = _First1;
                    }

                    return _Ans;
                }
            }

            *_Mid2++ = static_cast<char16_t>(_Ch);
        }

        return _First1 == _Mid1 ? codecvt::partial : codecvt::ok;
    }

    virtual result  do_out(mbstate_t& _State, const char16_t* _First1, const char16_t* _Last1,
        const char16_t*& _Mid1, char* _First2, char* _Last2, char*& _Mid2) const {
        
        unsigned short* _Pstate = reinterpret_cast<unsigned short*>(&_State);
        _Mid1                   = _First1;
        _Mid2                   = _First2;

        while (_Mid1 != _Last1 && _Mid2 != _Last2) { 
            unsigned long _Ch;
            const unsigned short _Ch1 = static_cast<unsigned short>(*_Mid1);
            bool _Save                = false;

            if (1 < *_Pstate) { 
                if (_Ch1 < 0xdc00u || 0xe000u <= _Ch1) {
                    return codecvt::error; 
                }

                _Ch = static_cast<unsigned long>((*_Pstate << 10) | (_Ch1 - 0xdc00));
            } else if (0xd800u <= _Ch1 && _Ch1 < 0xdc00u) { 
                _Ch   = static_cast<unsigned long>((_Ch1 - 0xd800 + 0x0040) << 10);
                _Save = true; 
            } else {
                _Ch = _Ch1; 
            }

            char _By;
            int _Nextra;

            if (_Ch < 0x0080u) {
                _By     = static_cast<char>(_Ch);
                _Nextra = 0;
            } else if (_Ch < 0x0800u) {
                _By     = static_cast<char>(0xc0 | _Ch >> 6);
                _Nextra = 1;
            } else if (_Ch < 0x10000u) {
                _By     = static_cast<char>(0xe0 | _Ch >> 12);
                _Nextra = 2;
            } else {
                _By     = static_cast<char>(0xf0 | _Ch >> 18);
                _Nextra = 3;
            }

            int _Nput = _Nextra < 3 ? _Nextra + 1 : _Save ? 1 : 3;

            if (_Last2 - _Mid2 < _Nput) {
                break; 
            }

            if (*_Pstate == 0u && (_Mode & _Generate_header) != 0) {
                if (_Last2 - _Mid2 < 3 + _Nput) {
                    break; 
                }

                
                *_Mid2++ = '\xef';
                *_Mid2++ = '\xbb';
                *_Mid2++ = '\xbf';
            }

            ++_Mid1;
            if (_Save || _Nextra < 3) { 
                *_Mid2++ = _By;
                --_Nput;
            }

            for (; 0 < _Nput; --_Nput) {
                *_Mid2++ = static_cast<char>((_Ch >> 6 * --_Nextra & 0x3f) | 0x80);
            }

            *_Pstate = static_cast<unsigned short>(_Save ? _Ch >> 10 : 1);
        }

        return _First1 == _Mid1 ? codecvt::partial : codecvt::ok;
    }

    virtual result  do_unshift(mbstate_t& _State, char* _First2, char*, char*& _Mid2) const {
        
        unsigned short* _Pstate = reinterpret_cast<unsigned short*>(&_State);
        _Mid2                   = _First2;

        return 1u < *_Pstate ? codecvt::error : codecvt::ok; 
    }

    friend int _Codecvt_do_length<>(const codecvt&, mbstate_t&, const char*, const char*, size_t);

    virtual int  do_length(
        mbstate_t& _State, const char* _First1, const char* _Last1, size_t _Count) const {
        return _Codecvt_do_length(*this, _State, _First1, _Last1, _Count);
    }

    bool  do_always_noconv() const noexcept override {
        
        return false;
    }

    int  do_max_length() const noexcept override {
        

        if ((_Mode & _Consume_header) != 0) {
            return 9; 
        }

        if ((_Mode & _Generate_header) != 0) {
            return 7; 
        }

        return 6; 
    }

    int do_encoding() const noexcept override {
        return 0; 
    }

private:
    unsigned long _Maxcode; 
    _Codecvt_mode _Mode; 
};

template <>
class  [[deprecated("warning STL4020: " "std::codecvt<char16_t, char, mbstate_t>, std::codecvt<char32_t, char, mbstate_t>, " "std::codecvt_byname<char16_t, char, mbstate_t>, and std::codecvt_byname<char32_t, char, mbstate_t> " "are deprecated in C++20 and replaced by specializations with a second argument of type char8_t. " "You can define _SILENCE_CXX20_CODECVT_FACETS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]]
    codecvt<char32_t, char, mbstate_t> : public codecvt_base {
    
public:
    using intern_type = char32_t;
    using extern_type = char;
    using state_type  = mbstate_t;

    result  in(mbstate_t& _State, const char* _First1, const char* _Last1, const char*& _Mid1,
        char32_t* _First2, char32_t* _Last2, char32_t*& _Mid2) const {
        
        return do_in(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
    }

    result  out(mbstate_t& _State, const char32_t* _First1, const char32_t* _Last1,
        const char32_t*& _Mid1, char* _First2, char* _Last2, char*& _Mid2) const {
        
        return do_out(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
    }

    result  unshift(mbstate_t& _State, char* _First2, char* _Last2, char*& _Mid2) const {
        
        return do_unshift(_State, _First2, _Last2, _Mid2);
    }

    int  length(mbstate_t& _State, const char* _First1, const char* _Last1, size_t _Count) const {
        
        
        return do_length(_State, _First1, _Last1, _Count);
    }

     static locale::id id;

    explicit  codecvt(size_t _Refs = 0)
        : codecvt_base(_Refs), _Maxcode(0xffffffff), _Mode(_Consume_header) {
        { _Locinfo _Lobj;
        _Init(_Lobj);
        }
    }

    explicit  codecvt(const _Locinfo& _Lobj, size_t _Refs = 0)
        : codecvt_base(_Refs), _Maxcode(0xffffffff), _Mode(_Consume_header) {
        _Init(_Lobj);
    }

     codecvt(
        const _Locinfo& _Lobj, unsigned long _Maxcode_arg, _Codecvt_mode _Mode_arg, size_t _Refs = 0)
        : codecvt_base(_Refs), _Maxcode(_Maxcode_arg), _Mode(_Mode_arg) {
        _Init(_Lobj);
    }

    static size_t __cdecl _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
        
        if (_Ppf && !*_Ppf) {
            __pragma(warning(push)) __pragma(warning(disable : 4996))
            *_Ppf = new codecvt(_Locinfo(_Ploc->c_str()));
            __pragma(warning(pop))
        }

        return 2;
    }

protected:
     ~codecvt() noexcept override {}

    void  _Init(const _Locinfo&) {} 

    virtual result  do_in(mbstate_t& _State, const char* _First1, const char* _Last1,
        const char*& _Mid1, char32_t* _First2, char32_t* _Last2, char32_t*& _Mid2) const {
        
        char* _Pstate = reinterpret_cast<char*>(&_State);
        _Mid1         = _First1;
        _Mid2         = _First2;

        while (_Mid1 != _Last1 && _Mid2 != _Last2) { 
            unsigned char _By = static_cast<unsigned char>(*_Mid1);
            unsigned long _Ch;
            int _Nextra;

            if (_By < 0x80u) {
                _Ch     = _By;
                _Nextra = 0;
            } else if (_By < 0xc0u) { 
                ++_Mid1;
                return codecvt::error;
            } else if (_By < 0xe0u) {
                _Ch     = static_cast<unsigned long>(_By & 0x1f);
                _Nextra = 1;
            } else if (_By < 0xf0u) {
                _Ch     = static_cast<unsigned long>(_By & 0x0f);
                _Nextra = 2;
            } else if (_By < 0xf8u) {
                _Ch     = static_cast<unsigned long>(_By & 0x07);
                _Nextra = 3;
            } else {
                _Ch     = static_cast<unsigned long>(_By & 0x03);
                _Nextra = _By < 0xfc ? 4 : 5;
            }

            if (_Nextra == 0) {
                ++_Mid1;
            } else if (_Last1 - _Mid1 < _Nextra + 1) {
                break; 
            } else {
                for (++_Mid1; 0 < _Nextra; --_Nextra, ++_Mid1) {
                    if ((_By = static_cast<unsigned char>(*_Mid1)) < 0x80u || 0xc0u <= _By) {
                        return codecvt::error; 
                    } else {
                        _Ch = _Ch << 6 | (_By & 0x3f);
                    }
                }
            }

            if (*_Pstate == 0) { 
                *_Pstate = 1;

                if ((_Mode & _Consume_header) != 0 && _Ch == 0xfeffu) { 
                    const result _Ans = do_in(_State, _Mid1, _Last1, _Mid1, _First2, _Last2, _Mid2);

                    if (_Ans == codecvt::partial) { 
                        *_Pstate = 0;
                        _Mid1    = _First1;
                    }
                    return _Ans;
                }
            }

            if (_Maxcode < _Ch) {
                return codecvt::error; 
            }

            *_Mid2++ = static_cast<char32_t>(_Ch);
        }

        return _First1 == _Mid1 ? codecvt::partial : codecvt::ok;
    }

    virtual result  do_out(mbstate_t& _State, const char32_t* _First1, const char32_t* _Last1,
        const char32_t*& _Mid1, char* _First2, char* _Last2, char*& _Mid2) const {
        
        char* _Pstate = reinterpret_cast<char*>(&_State);
        _Mid1         = _First1;
        _Mid2         = _First2;

        while (_Mid1 != _Last1 && _Mid2 != _Last2) { 
            char _By;
            int _Nextra;
            unsigned long _Ch = static_cast<unsigned long>(*_Mid1);

            if (_Maxcode < _Ch) {
                return codecvt::error;
            }

            if (_Ch < 0x0080u) {
                _By     = static_cast<char>(_Ch);
                _Nextra = 0;
            } else if (_Ch < 0x0800u) {
                _By     = static_cast<char>(0xc0 | _Ch >> 6);
                _Nextra = 1;
            } else if (_Ch < 0x00010000u) {
                _By     = static_cast<char>(0xe0 | _Ch >> 12);
                _Nextra = 2;
            } else if (_Ch < 0x00200000u) {
                _By     = static_cast<char>(0xf0 | _Ch >> 18);
                _Nextra = 3;
            } else if (_Ch < 0x04000000u) {
                _By     = static_cast<char>(0xf8 | _Ch >> 24);
                _Nextra = 4;
            } else {
                _By     = static_cast<char>(0xfc | (_Ch >> 30 & 0x03));
                _Nextra = 5;
            }

            if (*_Pstate == 0) { 
                *_Pstate = 1;
                if ((_Mode & _Generate_header) != 0) {
                    if (_Last2 - _Mid2 < 3 + 1 + _Nextra) {
                        return codecvt::partial; 
                    }

                    
                    *_Mid2++ = '\xef';
                    *_Mid2++ = '\xbb';
                    *_Mid2++ = '\xbf';
                }
            }

            if (_Last2 - _Mid2 < 1 + _Nextra) {
                break; 
            }

            ++_Mid1;
            for (*_Mid2++ = _By; 0 < _Nextra;) {
                *_Mid2++ = static_cast<char>((_Ch >> 6 * --_Nextra & 0x3f) | 0x80);
            }
        }
        return _First1 == _Mid1 ? codecvt::partial : codecvt::ok;
    }

    virtual result  do_unshift(mbstate_t&, char* _First2, char*, char*& _Mid2) const {
        
        _Mid2 = _First2;
        return codecvt::noconv;
    }

    friend int _Codecvt_do_length<>(const codecvt&, mbstate_t&, const char*, const char*, size_t);

    virtual int  do_length(
        mbstate_t& _State, const char* _First1, const char* _Last1, size_t _Count) const {
        return _Codecvt_do_length(*this, _State, _First1, _Last1, _Count);
    }

    bool  do_always_noconv() const noexcept override {
        
        return false;
    }

    int  do_max_length() const noexcept override {
        
        return (_Mode & (_Consume_header | _Generate_header)) != 0 ? 9 : 6;
    }

    int  do_encoding() const noexcept override {
        
        return (_Mode & (_Consume_header | _Generate_header)) != 0 ? -1
                                                                   : 0; 
    }

private:
    unsigned long _Maxcode; 
    _Codecvt_mode _Mode; 
};


template <class _From, class _To>
struct [[nodiscard]] _Codecvt_guard {
    const _From* const& _First1;
    const _From*& _Mid1;
    _To* const& _First2;
    _To*& _Mid2;

    _Codecvt_guard(const _From* const& _First1_, const _From*& _Mid1_, _To* const& _First2_, _To*& _Mid2_)
        : _First1{_First1_}, _Mid1{_Mid1_}, _First2{_First2_}, _Mid2{_Mid2_} {}

    _Codecvt_guard(const _Codecvt_guard&) = delete;
    _Codecvt_guard& operator=(const _Codecvt_guard&) = delete;

    ~_Codecvt_guard() {
        _Mid1 = _First1;
        _Mid2 = _First2;
    }
};

template <>
class codecvt<char16_t, char8_t, mbstate_t> : public codecvt_base {
    
public:
    using intern_type = char16_t;
    using extern_type = char8_t;
    using state_type  = mbstate_t;

    result in(mbstate_t& _State, const char8_t* _First1, const char8_t* _Last1, const char8_t*& _Mid1,
        char16_t* _First2, char16_t* _Last2, char16_t*& _Mid2) const {
        
        return do_in(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
    }

    result out(mbstate_t& _State, const char16_t* _First1, const char16_t* _Last1, const char16_t*& _Mid1,
        char8_t* _First2, char8_t* _Last2, char8_t*& _Mid2) const {
        
        return do_out(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
    }

    result unshift(mbstate_t& _State, char8_t* _First2, char8_t* _Last2, char8_t*& _Mid2) const {
        
        return do_unshift(_State, _First2, _Last2, _Mid2);
    }

    int length(mbstate_t& _State, const char8_t* _First1, const char8_t* _Last1, size_t _Count) const {
        
        
        return do_length(_State, _First1, _Last1, _Count);
    }

     static locale::id id;

    explicit codecvt(size_t _Refs = 0) : codecvt_base(_Refs) {} 
    explicit codecvt(const _Locinfo&, size_t _Refs = 0) : codecvt_base(_Refs) {} 

    static size_t _Getcat(const locale::facet** _Ppf = nullptr, const locale* = nullptr) {
        
        if (_Ppf && !*_Ppf) {
            *_Ppf = new codecvt;
        }

        return 2;
    }

protected:
     ~codecvt() noexcept override = default;

    virtual result  do_in(mbstate_t&, const char8_t* _First1, const char8_t* _Last1,
        const char8_t*& _Mid1, char16_t* _First2, char16_t* _Last2, char16_t*& _Mid2) const {
        
        _Adl_verify_range(_First1, _Last1);
        _Adl_verify_range(_First2, _Last2);

        _Codecvt_guard<char8_t, char16_t> _Guard{_First1, _Mid1, _First2, _Mid2};

        for (; _First1 != _Last1; ++_First1, ++_First2) {
            if (_First2 == _Last2) {
                return partial;
            }

            char8_t _Lead_byte = *_First1;
            if (_Lead_byte < 0b1000'0000u) { 
                *_First2 = static_cast<char16_t>(_Lead_byte);
                continue;
            }

            int _Trailing_count = 1;
            if (_Lead_byte < 0b1110'0000u) {
                if (_Lead_byte < 0b1100'0000u) { 
                    return error;
                }

                
                _Lead_byte &= 0b0001'1111u;
            } else if (_Lead_byte < 0b1111'0000u) { 
                _Lead_byte &= 0b0000'1111u;
                _Trailing_count = 2;
            } else if (_Lead_byte < 0b1111'1000u) { 
                if (_Last2 - _First2 < 2) { 
                    return partial;
                }

                _Lead_byte &= 0b0000'0111u;
                _Trailing_count = 3;
            } else { 
                return error;
            }

            if (_Last1 - _First1 < _Trailing_count + 1) { 
                return partial;
            }

            const char8_t* _Peek = _First1;
            char32_t _Code_point = _Lead_byte;
            do {
                const char8_t _By = *++_Peek;
                if ((_By & 0b1100'0000u) != 0b1000'0000u) { 
                    return error;
                }

                _Code_point = (_Code_point << 6) | (_By & 0b11'1111u);
            } while (--_Trailing_count != 0);

            if (_Code_point < 0x10000u) {
                if (_Code_point >= 0xd800u && _Code_point < 0xe000u) { 
                    return error;
                }
                
                *_First2 = static_cast<char16_t>(_Code_point);
            } else if (_Code_point >= 0x110000u) { 
                return error;
            } else {
                
                _Code_point -= 0x10000u;
                
                *_First2 = static_cast<char16_t>(0xd800u | (_Code_point >> 10));
                
                *++_First2 = static_cast<char16_t>(0xdc00u | (_Code_point & 0b11'1111'1111u));
            }

            _First1 = _Peek;
        }

        return ok;
    }

    virtual result  do_out(mbstate_t&, const char16_t* _First1, const char16_t* _Last1,
        const char16_t*& _Mid1, char8_t* _First2, char8_t* _Last2, char8_t*& _Mid2) const {
        
        _Adl_verify_range(_First1, _Last1);
        _Adl_verify_range(_First2, _Last2);

        _Codecvt_guard<char16_t, char8_t> _Guard{_First1, _Mid1, _First2, _Mid2};

        for (; _First1 != _Last1; ++_First1, ++_First2) {
            if (_First2 == _Last2) { 
                return partial;
            }

            char32_t _Code_point = *_First1;
            if (_Code_point < 0x80u) { 
                *_First2 = static_cast<char8_t>(_Code_point);
                continue;
            }

            int _Trailing_count = 1;
            if (_Code_point < 0x800u) { 
                *_First2 = static_cast<char8_t>(0b1100'0000u | (_Code_point >> 6));
            } else if (_Code_point < 0xd800u || _Code_point >= 0xe000u) { 
                *_First2        = static_cast<char8_t>(0b1110'0000u | (_Code_point >> 12));
                _Trailing_count = 2;
            } else if (_Code_point < 0xdc00u) { 
                if (_Last1 - _First1 < 2) { 
                    return partial;
                }

                const char16_t _Low_surrogate = *++_First1;
                if (_Low_surrogate < 0xdc00u || _Low_surrogate >= 0xe000u) { 
                    --_First1;
                    return error;
                }
                _Code_point = 0x10000u + (((_Code_point & 0b11'1111'1111u) << 10) | (_Low_surrogate & 0b11'1111'1111u));

                
                *_First2        = static_cast<char8_t>(0b1111'0000u | (_Code_point >> 18));
                _Trailing_count = 3;
            } else { 
                return error;
            }

            if (_Last2 - _First2 < _Trailing_count + 1) { 
                if (_Trailing_count > 2) { 
                    --_First1;
                }
                return partial;
            }

            do {
                --_Trailing_count;
                *++_First2 = static_cast<char8_t>(0b1000'0000u | ((_Code_point >> (6 * _Trailing_count)) & 0b11'1111u));
            } while (_Trailing_count != 0);
        }

        return ok;
    }

    virtual result  do_unshift(mbstate_t&, char8_t* _First2, char8_t*, char8_t*& _Mid2) const {
        
        _Mid2 = _First2;
        return noconv; 
    }

    virtual int  do_length(
        mbstate_t&, const char8_t* _First1, const char8_t* _Last1, size_t _Count) const {
        
        
        _Adl_verify_range(_First1, _Last1);

        const auto _Old_first1 = _First1;

        for (; _First1 != _Last1 && _Count > 0u; ++_First1, --_Count) {
            char32_t _Code_point = *_First1;
            if (_Code_point < 0b1000'0000u) { 
                continue;
            }

            int _Trailing_count = 1;
            if (_Code_point < 0b1110'0000u) {
                if (_Code_point < 0b1100'0000u) { 
                    break;
                }

                
                _Code_point &= 0b0001'1111u;
            } else if (_Code_point < 0b1111'0000u) { 
                _Code_point &= 0b0000'1111u;
                _Trailing_count = 2;
            } else if (_Code_point < 0b1111'1000u) { 
                if (_Count < 2u) { 
                    break;
                }

                _Code_point &= 0b0000'0111u;
                _Trailing_count = 3;
            } else { 
                break;
            }

            if (_Last1 - _First1 < _Trailing_count + 1) { 
                break;
            }

            const char8_t* _Peek = _First1;
            bool _Done           = false;
            do {
                const char8_t _By = *++_Peek;
                if ((_By & 0b1100'0000u) != 0b1000'0000u) { 
                    _Done = true;
                    break;
                }

                _Code_point = (_Code_point << 6) | (_By & 0b11'1111u);
            } while (--_Trailing_count != 0);

            if (_Done) {
                break;
            }

            if (_Code_point < 0x10000u) { 
                if (_Code_point >= 0xd800u && _Code_point < 0xe0000u) { 
                    break;
                }
            } else if (_Code_point < 0x110000u) { 
                --_Count;
            } else { 
                break;
            }

            _First1 = _Peek;
        }

        return static_cast<int>((::std:: min)(_First1 - _Old_first1, ptrdiff_t{2147483647}));
    }

    bool  do_always_noconv() const noexcept override {
        
        return false;
    }

    int  do_max_length() const noexcept override {
        
        return 4; 
    }

    int  do_encoding() const noexcept override {
        
        return 0; 
    }
};

template <>
class codecvt<char32_t, char8_t, mbstate_t> : public codecvt_base {
    
public:
    using intern_type = char32_t;
    using extern_type = char8_t;
    using state_type  = mbstate_t;

    result in(mbstate_t& _State, const char8_t* _First1, const char8_t* _Last1, const char8_t*& _Mid1,
        char32_t* _First2, char32_t* _Last2, char32_t*& _Mid2) const {
        
        return do_in(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
    }

    result out(mbstate_t& _State, const char32_t* _First1, const char32_t* _Last1, const char32_t*& _Mid1,
        char8_t* _First2, char8_t* _Last2, char8_t*& _Mid2) const {
        
        return do_out(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
    }

    result unshift(mbstate_t& _State, char8_t* _First2, char8_t* _Last2, char8_t*& _Mid2) const {
        
        return do_unshift(_State, _First2, _Last2, _Mid2);
    }

    int length(mbstate_t& _State, const char8_t* _First1, const char8_t* _Last1, size_t _Count) const {
        
        
        return do_length(_State, _First1, _Last1, _Count);
    }

     static locale::id id;

    explicit codecvt(size_t _Refs = 0) : codecvt_base(_Refs) {} 
    explicit codecvt(const _Locinfo&, size_t _Refs = 0) : codecvt_base(_Refs) {} 

    static size_t __cdecl _Getcat(const locale::facet** _Ppf = nullptr, const locale* = nullptr) {
        
        if (_Ppf && !*_Ppf) {
            *_Ppf = new codecvt;
        }

        return 2;
    }

protected:
     ~codecvt() noexcept override = default;

    virtual result  do_in(mbstate_t&, const char8_t* _First1, const char8_t* _Last1,
        const char8_t*& _Mid1, char32_t* _First2, char32_t* _Last2, char32_t*& _Mid2) const {
        
        _Adl_verify_range(_First1, _Last1);
        _Adl_verify_range(_First2, _Last2);

        _Codecvt_guard<char8_t, char32_t> _Guard{_First1, _Mid1, _First2, _Mid2};

        for (; _First1 != _Last1; ++_First1, ++_First2) {
            if (_First2 == _Last2) {
                return partial;
            }

            char8_t _Lead_byte = *_First1;
            if (_Lead_byte < 0b1000'0000u) { 
                *_First2 = _Lead_byte;
                continue;
            }

            int _Trailing_count = 1;
            if (_Lead_byte < 0b1110'0000u) {
                if (_Lead_byte < 0b1100'0000u) { 
                    return partial;
                }

                
                _Lead_byte &= 0b0001'1111u;
            } else if (_Lead_byte < 0b1111'0000u) { 
                _Lead_byte &= 0b0000'1111u;
                _Trailing_count = 2;
            } else if (_Lead_byte < 0b1111'1000u) { 
                _Lead_byte &= 0b0000'0111u;
                _Trailing_count = 3;
            } else { 
                return error;
            }

            if (_Last1 - _First1 < _Trailing_count + 1) { 
                return partial;
            }

            const char8_t* _Peek = _First1;
            char32_t _Code_point = _Lead_byte;
            do {
                const char8_t _By = *++_Peek;
                if ((_By & 0b1100'0000u) != 0b1000'0000u) { 
                    return error;
                }

                _Code_point = (_Code_point << 6) | (_By & 0b11'1111u);
            } while (--_Trailing_count != 0);

            if (_Code_point >= 0xd800u && (_Code_point < 0xe000u || _Code_point >= 0x110000u)) {
                
                return error;
            }

            _First1  = _Peek;
            *_First2 = _Code_point;
        }

        return ok;
    }

    virtual result  do_out(mbstate_t&, const char32_t* _First1, const char32_t* _Last1,
        const char32_t*& _Mid1, char8_t* _First2, char8_t* _Last2, char8_t*& _Mid2) const {
        
        _Adl_verify_range(_First1, _Last1);
        _Adl_verify_range(_First2, _Last2);

        _Codecvt_guard<char32_t, char8_t> _Guard{_First1, _Mid1, _First2, _Mid2};

        for (; _First1 != _Last1; ++_First1, ++_First2) {
            if (_First2 == _Last2) { 
                return partial;
            }

            const char32_t _Code_point = *_First1;
            if (_Code_point < 0x80u) { 
                *_First2 = static_cast<char8_t>(_Code_point);
                continue;
            }

            int _Trailing_count = 1;
            if (_Code_point < 0x800u) { 
                *_First2 = static_cast<char8_t>(0b1100'0000u | (_Code_point >> 6));
            } else if (_Code_point < 0x10000u) { 
                if (_Code_point >= 0xd800u && _Code_point < 0xe000u) { 
                    return error;
                }

                *_First2        = static_cast<char8_t>(0b1110'0000u | (_Code_point >> 12));
                _Trailing_count = 2;
            } else if (_Code_point < 0x110000u) { 
                *_First2        = static_cast<char8_t>(0b1111'0000u | (_Code_point >> 18));
                _Trailing_count = 3;
            } else { 
                return error;
            }

            if (_Last2 - _First2 < _Trailing_count + 1) { 
                return partial;
            }

            do {
                --_Trailing_count;
                *++_First2 = static_cast<char8_t>(0b1000'0000u | ((_Code_point >> (6 * _Trailing_count)) & 0b11'1111u));
            } while (_Trailing_count != 0);
        }

        return ok;
    }

    virtual result  do_unshift(mbstate_t&, char8_t* _First2, char8_t*, char8_t*& _Mid2) const {
        
        _Mid2 = _First2;
        return noconv; 
    }

    virtual int  do_length(
        mbstate_t&, const char8_t* _First1, const char8_t* _Last1, size_t _Count) const {
        
        
        _Adl_verify_range(_First1, _Last1);

        const auto _Old_first1 = _First1;

        for (; _First1 != _Last1 && _Count > 0u; ++_First1, --_Count) {
            char32_t _Code_point = *_First1;
            if (_Code_point < 0b1000'0000u) { 
                continue;
            }

            int _Trailing_count = 1;
            if (_Code_point < 0b1110'0000u) {
                if (_Code_point < 0b1100'0000u) { 
                    break;
                }

                
                _Code_point &= 0b0001'1111u;
            } else if (_Code_point < 0b1111'0000u) { 
                _Code_point &= 0b0000'1111u;
                _Trailing_count = 2;
            } else if (_Code_point < 0b1111'1000u) { 
                _Code_point &= 0b0000'0111u;
                _Trailing_count = 3;
            } else { 
                break;
            }

            if (_Last1 - _First1 < _Trailing_count + 1) { 
                break;
            }

            const char8_t* _Peek = _First1;
            bool _Done           = false;
            do {
                const char8_t _By = *++_Peek;
                if ((_By & 0b1100'0000u) != 0b1000'0000u) { 
                    _Done = true;
                    break;
                }

                _Code_point = (_Code_point << 6) | (_By & 0b11'1111u);
            } while (--_Trailing_count != 0);

            if (_Done || (_Code_point >= 0xd800u && (_Code_point < 0xe000u || _Code_point >= 0x110000u))) {
                
                break;
            }

            _First1 = _Peek;
        }

        return static_cast<int>((::std:: min)(_First1 - _Old_first1, ptrdiff_t{2147483647}));
    }

    bool  do_always_noconv() const noexcept override {
        
        return false;
    }

    int  do_max_length() const noexcept override {
        
        return 4;
    }

    int  do_encoding() const noexcept override {
        
        return 0; 
    }
};
#line 1907 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocale"

template <>
class  codecvt<wchar_t, char, mbstate_t> : public codecvt_base {
    
public:
    using intern_type = wchar_t;
    using extern_type = char;
    using state_type  = mbstate_t;

    result  in(mbstate_t& _State, const char* _First1, const char* _Last1, const char*& _Mid1,
        wchar_t* _First2, wchar_t* _Last2, wchar_t*& _Mid2) const {
        
        return do_in(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
    }

    result  out(mbstate_t& _State, const wchar_t* _First1, const wchar_t* _Last1,
        const wchar_t*& _Mid1, char* _First2, char* _Last2, char*& _Mid2) const {
        
        return do_out(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
    }

    result  unshift(mbstate_t& _State, char* _First2, char* _Last2, char*& _Mid2) const {
        
        return do_unshift(_State, _First2, _Last2, _Mid2);
    }

    int  length(mbstate_t& _State, const char* _First1, const char* _Last1, size_t _Count) const {
        
        
        return do_length(_State, _First1, _Last1, _Count);
    }

     static locale::id id;

    explicit  codecvt(size_t _Refs = 0) : codecvt_base(_Refs) {
        { _Locinfo _Lobj;
        _Init(_Lobj);
        }
    }

    explicit  codecvt(const _Locinfo& _Lobj, size_t _Refs = 0) : codecvt_base(_Refs) {
        _Init(_Lobj);
    }

    static size_t __cdecl _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
        
        if (_Ppf && !*_Ppf) {
            *_Ppf = new codecvt(_Locinfo(_Ploc->c_str()));
        }

        return 2;
    }

protected:
     ~codecvt() noexcept override {}

    void  _Init(const _Locinfo& _Lobj) { 
        _Cvt = _Lobj._Getcvt();
    }

    virtual result  do_in(mbstate_t&, const char* _First1, const char* _Last1, const char*& _Mid1,
        wchar_t* _First2, wchar_t* _Last2, wchar_t*& _Mid2) const {
        
        mbstate_t _Mystate{};
        _Adl_verify_range(_First1, _Last1);
        _Adl_verify_range(_First2, _Last2);
        _Mid1 = _First1;
        _Mid2 = _First2;
        for (;;) {
            if (_Mid1 == _Last1) {
                return ok;
            }

            if (_Mid2 == _Last2) {
                return partial;
            }

            int _Bytes = _Mbrtowc(_Mid2, _Mid1, static_cast<size_t>(_Last1 - _Mid1), &_Mystate, &_Cvt);
            switch (_Bytes) {
            case -2: 
                return partial;

            case -1: 
                return error;

            case 0: 
                _Bytes = 1;
                

            default: 
                _Mid1 += _Bytes;
                ++_Mid2;
                break;
            }
        }
    }

    virtual result  do_out(mbstate_t& _State, const wchar_t* _First1, const wchar_t* _Last1,
        const wchar_t*& _Mid1, char* _First2, char* _Last2, char*& _Mid2) const {
        
        _Adl_verify_range(_First1, _Last1);
        _Adl_verify_range(_First2, _Last2);
        _Mid1 = _First1;
        _Mid2 = _First2;
        int _Bytes;

        while (_Mid1 != _Last1 && _Mid2 != _Last2) {
            if (5 <= _Last2 - _Mid2) {
                if ((_Bytes = _Wcrtomb(_Mid2, *_Mid1, &_State, &_Cvt)) < 0) {
                    return error; 
                } else {
                    ++_Mid1;
                    _Mid2 += _Bytes;
                }
            } else { 
                char _Buf[5];
                mbstate_t _Stsave = _State;

                if ((_Bytes = _Wcrtomb(_Buf, *_Mid1, &_State, &_Cvt)) < 0) {
                    return error; 
                } else if (_Last2 - _Mid2 < _Bytes) { 
                    _State = _Stsave;
                    break;
                } else { 
                    :: memcpy(_Mid2, _Buf, static_cast<size_t>(_Bytes));
                    ++_Mid1;
                    _Mid2 += _Bytes;
                }
            }
        }

        return _Mid1 == _Last1 ? ok : partial;
    }

    virtual result  do_unshift(mbstate_t& _State, char* _First2, char* _Last2, char*& _Mid2) const {
        
        _Adl_verify_range(_First2, _Last2);
        _Mid2       = _First2;
        result _Ans = ok;
        int _Bytes;
        char _Buf[5];
        mbstate_t _Stsave = _State;

        if ((_Bytes = _Wcrtomb(_Buf, L'\0', &_State, &_Cvt)) <= 0) {
            _Ans = error; 
        } else if (_Last2 - _Mid2 < --_Bytes) { 
            _State = _Stsave;
            _Ans   = partial;
        } else if (0 < _Bytes) { 
            :: memcpy(_Mid2, _Buf, static_cast<size_t>(_Bytes));
            _Mid2 += _Bytes;
        }
        return _Ans;
    }

    virtual int  do_length(
        mbstate_t& _State, const char* _First1, const char* _Last1, size_t _Count) const {
        
        
        _Adl_verify_range(_First1, _Last1);
        const auto _Old_first1 = _First1;

        for (; _Count > 0u && _First1 != _Last1; --_Count) {
            wchar_t _Ch;
            int _Bytes = _Mbrtowc(&_Ch, _First1, static_cast<size_t>(_Last1 - _First1), &_State, &_Cvt);
            if (_Bytes < 0) { 
                break;
            }

            if (_Bytes == 0) { 
                _Bytes = 1;
            }

            
            _First1 += _Bytes;
        }

        return static_cast<int>((::std:: min)(_First1 - _Old_first1, ptrdiff_t{2147483647}));
    }

    bool  do_always_noconv() const noexcept override {
        
        return false;
    }

    int  do_max_length() const noexcept override {
        
        return static_cast<int>(_Cvt._Mbcurmax);
    }

    int  do_encoding() const noexcept override {
        
        return _Cvt._Mbcurmax == 1; 
    }

private:
    _Locinfo::_Cvtvec _Cvt; 
};


template <>
class  codecvt<unsigned short, char, mbstate_t> : public codecvt_base {
    
public:
    using intern_type = unsigned short;
    using extern_type = char;
    using state_type  = mbstate_t;

    result  in(mbstate_t& _State, const char* _First1, const char* _Last1, const char*& _Mid1,
        unsigned short* _First2, unsigned short* _Last2, unsigned short*& _Mid2) const {
        
        return do_in(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
    }

    result  out(mbstate_t& _State, const unsigned short* _First1, const unsigned short* _Last1,
        const unsigned short*& _Mid1, char* _First2, char* _Last2, char*& _Mid2) const {
        
        return do_out(_State, _First1, _Last1, _Mid1, _First2, _Last2, _Mid2);
    }

    result  unshift(mbstate_t& _State, char* _First2, char* _Last2, char*& _Mid2) const {
        
        return do_unshift(_State, _First2, _Last2, _Mid2);
    }

    int  length(mbstate_t& _State, const char* _First1, const char* _Last1, size_t _Count) const {
        
        
        return do_length(_State, _First1, _Last1, _Count);
    }

     static locale::id id;

    explicit  codecvt(size_t _Refs = 0) : codecvt_base(_Refs) {
        { _Locinfo _Lobj;
        _Init(_Lobj);
        }
    }

    explicit  codecvt(const _Locinfo& _Lobj, size_t _Refs = 0) : codecvt_base(_Refs) {
        _Init(_Lobj);
    }

    static size_t __cdecl _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
        
        if (_Ppf && !*_Ppf) {
            *_Ppf = new codecvt(_Locinfo(_Ploc->c_str()));
        }

        return 2;
    }

protected:
     ~codecvt() noexcept override {}

    void  _Init(const _Locinfo& _Lobj) { 
        _Cvt = _Lobj._Getcvt();
    }

    virtual result  do_in(mbstate_t&, const char* _First1, const char* _Last1, const char*& _Mid1,
        unsigned short* _First2, unsigned short* _Last2, unsigned short*& _Mid2) const {
        
        mbstate_t _Mystate{};
        _Adl_verify_range(_First1, _Last1);
        _Adl_verify_range(_First2, _Last2);
        _Mid1 = _First1;
        _Mid2 = _First2;
        for (;;) {
            if (_Mid1 == _Last1) {
                return ok;
            }

            if (_Mid2 == _Last2) {
                return partial;
            }

            int _Bytes = _Mbrtowc(
                reinterpret_cast<wchar_t*>(_Mid2), _Mid1, static_cast<size_t>(_Last1 - _Mid1), &_Mystate, &_Cvt);
            switch (_Bytes) {
            case -2: 
                return partial;

            case -1: 
                return error;

            case 0: 
                _Bytes = 1;
                

            default: 
                _Mid1 += _Bytes;
                ++_Mid2;
                break;
            }
        }
    }

    virtual result  do_out(mbstate_t& _State, const unsigned short* _First1,
        const unsigned short* _Last1, const unsigned short*& _Mid1, char* _First2, char* _Last2, char*& _Mid2) const {
        
        _Adl_verify_range(_First1, _Last1);
        _Adl_verify_range(_First2, _Last2);
        _Mid1 = _First1;
        _Mid2 = _First2;
        int _Bytes;

        while (_Mid1 != _Last1 && _Mid2 != _Last2) {
            if (5 <= _Last2 - _Mid2) {
                if ((_Bytes = _Wcrtomb(_Mid2, *_Mid1, &_State, &_Cvt)) < 0) {
                    return error; 
                } else {
                    ++_Mid1;
                    _Mid2 += _Bytes;
                }
            } else { 
                char _Buf[5];
                mbstate_t _Stsave = _State;

                if ((_Bytes = _Wcrtomb(_Buf, *_Mid1, &_State, &_Cvt)) < 0) {
                    return error; 
                } else if (_Last2 - _Mid2 < _Bytes) { 
                    _State = _Stsave;
                    break;
                } else { 
                    :: memcpy(_Mid2, _Buf, static_cast<size_t>(_Bytes));
                    ++_Mid1;
                    _Mid2 += _Bytes;
                }
            }
        }

        return _Mid1 == _Last1 ? ok : partial;
    }

    virtual result  do_unshift(mbstate_t& _State, char* _First2, char* _Last2, char*& _Mid2) const {
        
        _Adl_verify_range(_First2, _Last2);
        _Mid2       = _First2;
        result _Ans = ok;
        int _Bytes;
        char _Buf[5];
        mbstate_t _Stsave = _State;

        if ((_Bytes = _Wcrtomb(_Buf, L'\0', &_State, &_Cvt)) <= 0) {
            _Ans = error; 
        } else if (_Last2 - _Mid2 < --_Bytes) { 
            _State = _Stsave;
            _Ans   = partial;
        } else if (0 < _Bytes) { 
            :: memcpy(_Mid2, _Buf, static_cast<size_t>(_Bytes));
            _Mid2 += _Bytes;
        }

        return _Ans;
    }

    virtual int  do_length(
        mbstate_t& _State, const char* _First1, const char* _Last1, size_t _Count) const {
        
        
        _Adl_verify_range(_First1, _Last1);
        const auto _Old_first1 = _First1;

        for (; _Count > 0u && _First1 != _Last1; --_Count) {
            wchar_t _Ch;
            int _Bytes = _Mbrtowc(&_Ch, _First1, static_cast<size_t>(_Last1 - _First1), &_State, &_Cvt);
            if (_Bytes < 0) { 
                break;
            }

            if (_Bytes == 0) { 
                _Bytes = 1;
            }

            
            _First1 += _Bytes;
        }

        return static_cast<int>((::std:: min)(_First1 - _Old_first1, ptrdiff_t{2147483647}));
    }

    bool  do_always_noconv() const noexcept override {
        
        return false;
    }

    int  do_max_length() const noexcept override {
        
        return static_cast<int>(_Cvt._Mbcurmax);
    }

    int  do_encoding() const noexcept override {
        
        return _Cvt._Mbcurmax == 1u; 
    }

private:
    _Locinfo::_Cvtvec _Cvt; 
};
#line 2307 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocale"

template <class _Elem, class _Byte, class _Statype>
class codecvt_byname : public codecvt<_Elem, _Byte, _Statype> { 
public:
    static_assert(!0
                      || _Is_any_of_v<codecvt_byname,

                          codecvt_byname<char16_t, char8_t, mbstate_t>, codecvt_byname<char32_t, char8_t, mbstate_t>,
#line 2316 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocale"
                          codecvt_byname<char, char, mbstate_t>, codecvt_byname<wchar_t, char, mbstate_t>>,
        "Unsupported facet specialization; see N4800 27.3.1.1.1 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this diagnostic.");

    explicit  codecvt_byname(const char* _Locname, size_t _Refs = 0)
        : codecvt<_Elem, _Byte, _Statype>(_Locinfo(_Locname), _Refs) {} 

    explicit  codecvt_byname(const string& _Str, size_t _Refs = 0)
        : codecvt<_Elem, _Byte, _Statype>(_Locinfo(_Str.c_str()), _Refs) {} 

protected:
     ~codecvt_byname() noexcept override {}
};


struct  ctype_base : locale::facet { 
    enum { 
        alnum  = 0x04 | 0x02 | 0x01 | 0x100,
        alpha  = 0x02 | 0x01 | 0x100,
        cntrl  = 0x20,
        digit  = 0x04,
        graph  = 0x04 | 0x02 | 0x10 | 0x01 | 0x100,
        lower  = 0x02,
        print  = 0x04 | 0x02 | 0x10 | 0x40 | 0x01 | 0x100 | 0x80,
        punct  = 0x10,
        space  = 0x08 | 0x40,
        upper  = 0x01,
        xdigit = 0x80,
        blank  = 0x08 | 0x40
    };
    using mask = short; 

     ctype_base(size_t _Refs = 0) : locale::facet(_Refs) {}

     ~ctype_base() noexcept override {}
};


template <class _Elem>
class ctype : public ctype_base { 
public:
    
    static_assert(!0 || _Always_false<_Elem>, "Unsupported facet specialization; see N4800 27.3.1.1.1 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this diagnostic.");

    using char_type = _Elem;

    bool  is(mask _Maskval, _Elem _Ch) const { 
        return do_is(_Maskval, _Ch);
    }

    const _Elem*  is(const _Elem* _First, const _Elem* _Last,
        mask* _Dest) const { 
        return do_is(_First, _Last, _Dest);
    }

    const _Elem*  scan_is(mask _Maskval, const _Elem* _First,
        const _Elem* _Last) const { 
        return do_scan_is(_Maskval, _First, _Last);
    }

    const _Elem*  scan_not(mask _Maskval, const _Elem* _First,
        const _Elem* _Last) const { 
        return do_scan_not(_Maskval, _First, _Last);
    }

    _Elem  tolower(_Elem _Ch) const { 
        return do_tolower(_Ch);
    }

    const _Elem*  tolower(
        _Elem* _First, const _Elem* _Last) const { 
        return do_tolower(_First, _Last);
    }

    _Elem  toupper(_Elem _Ch) const { 
        return do_toupper(_Ch);
    }

    const _Elem*  toupper(
        _Elem* _First, const _Elem* _Last) const { 
        return do_toupper(_First, _Last);
    }

    _Elem  widen(char _Byte) const { 
        return do_widen(_Byte);
    }

    const char*  widen(const char* _First, const char* _Last,
        _Elem* _Dest) const { 
        return do_widen(_First, _Last, _Dest);
    }

    char  narrow(_Elem _Ch, char _Dflt = '\0') const { 
        return do_narrow(_Ch, _Dflt);
    }

    const _Elem*  narrow(const _Elem* _First, const _Elem* _Last, char _Dflt,
        char* _Dest) const { 
        return do_narrow(_First, _Last, _Dflt, _Dest);
    }

     static locale::id id;

    explicit  ctype(size_t _Refs = 0) : ctype_base(_Refs) {
        { _Locinfo _Lobj;
        _Init(_Lobj);
        }
    }

     ctype(const _Locinfo& _Lobj, size_t _Refs = 0) : ctype_base(_Refs) {
        _Init(_Lobj);
    }

    static size_t __cdecl _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
        if (_Ppf && !*_Ppf) {
            *_Ppf = new ctype<_Elem>(_Locinfo(_Ploc->c_str()));
        }

        return 2;
    }

protected:
     ~ctype() noexcept override {
        if (_Ctype._Delfl) {
            :: free(const_cast<short*>(_Ctype._Table));
        }

        :: free(_Ctype._LocaleName);
    }

    void  _Init(const _Locinfo& _Lobj) { 
        _Ctype = _Lobj._Getctype();
        _Cvt   = _Lobj._Getcvt();
    }

    virtual bool  do_is(
        mask _Maskval, _Elem _Ch) const { 
        return (_Ctype._Table[static_cast<unsigned char>(narrow(_Ch))] & _Maskval) != 0;
    }

    virtual const _Elem*  do_is(const _Elem* _First, const _Elem* _Last,
        mask* _Dest) const { 
        _Adl_verify_range(_First, _Last);
        for (; _First != _Last; ++_First, ++_Dest) {
            *_Dest = _Ctype._Table[static_cast<unsigned char>(narrow(*_First))];
        }

        return _First;
    }

    virtual const _Elem*  do_scan_is(mask _Maskval, const _Elem* _First,
        const _Elem* _Last) const { 
        _Adl_verify_range(_First, _Last);
        while (_First != _Last && !is(_Maskval, *_First)) {
            ++_First;
        }

        return _First;
    }

    virtual const _Elem*  do_scan_not(mask _Maskval, const _Elem* _First,
        const _Elem* _Last) const { 
        _Adl_verify_range(_First, _Last);
        while (_First != _Last && is(_Maskval, *_First)) {
            ++_First;
        }

        return _First;
    }

    virtual _Elem  do_tolower(_Elem _Ch) const { 
        unsigned char _Byte = static_cast<unsigned char>(narrow(_Ch, '\0'));
        if (_Byte == '\0') {
            return _Ch;
        }

        return widen(static_cast<char>(_Tolower(_Byte, &_Ctype)));
    }

    virtual const _Elem*  do_tolower(_Elem* _First,
        const _Elem* _Last) const { 
        _Adl_verify_range(_First, _Last);
        for (; _First != _Last; ++_First) { 
            unsigned char _Byte = static_cast<unsigned char>(narrow(*_First, '\0'));
            if (_Byte != '\0') {
                *_First = (widen(static_cast<char>(_Tolower(_Byte, &_Ctype))));
            }
        }
        return _First;
    }

    virtual _Elem  do_toupper(_Elem _Ch) const { 
        unsigned char _Byte = static_cast<unsigned char>(narrow(_Ch, '\0'));
        if (_Byte == '\0') {
            return _Ch;
        }

        return widen(static_cast<char>(_Toupper(_Byte, &_Ctype)));
    }

    virtual const _Elem*  do_toupper(_Elem* _First,
        const _Elem* _Last) const { 
        _Adl_verify_range(_First, _Last);
        for (; _First != _Last; ++_First) { 
            unsigned char _Byte = static_cast<unsigned char>(narrow(*_First, '\0'));
            if (_Byte != '\0') {
                *_First = (widen(static_cast<char>(_Toupper(_Byte, &_Ctype))));
            }
        }

        return _First;
    }

    virtual _Elem  do_widen(char _Byte) const { 
        return _Maklocchr(_Byte, static_cast<_Elem*>(nullptr), _Cvt);
    }

    virtual const char*  do_widen(
        const char* _First, const char* _Last, _Elem* _Dest) const { 
        _Adl_verify_range(_First, _Last);
        for (; _First != _Last; ++_First, ++_Dest) {
            *_Dest = _Maklocchr(*_First, static_cast<_Elem*>(nullptr), _Cvt);
        }

        return _First;
    }

    char  _Donarrow(_Elem _Ch, char _Dflt) const { 
        char _Byte;
        if (_Ch == _Elem{}) {
            return '\0';
        }

        if ((_Byte = _Maklocbyte(_Ch, _Cvt)) == '\0') {
            return _Dflt;
        }

        return _Byte;
    }

    virtual char  do_narrow(_Elem _Ch, char _Dflt) const { 
        return _Donarrow(_Ch, _Dflt);
    }

    virtual const _Elem*  do_narrow(const _Elem* _First, const _Elem* _Last, char _Dflt,
        char* _Dest) const { 
        _Adl_verify_range(_First, _Last);
        for (; _First != _Last; ++_First, ++_Dest) {
            *_Dest = _Donarrow(*_First, _Dflt);
        }

        return _First;
    }

private:
    _Locinfo::_Ctypevec _Ctype; 
    _Locinfo::_Cvtvec _Cvt; 
};


template <class _Elem>
locale::id ctype<_Elem>::id;


template <>
class  ctype<char> : public ctype_base { 
public:
    using _Elem     = char;
    using char_type = _Elem;

    bool  is(mask _Maskval, _Elem _Ch) const { 
        return (_Ctype._Table[static_cast<unsigned char>(_Ch)] & _Maskval) != 0;
    }

    const _Elem*  is(const _Elem* _First, const _Elem* _Last,
        mask* _Dest) const { 
        _Adl_verify_range(_First, _Last);
        for (; _First != _Last; ++_First, ++_Dest) {
            *_Dest = _Ctype._Table[static_cast<unsigned char>(*_First)];
        }

        return _First;
    }

    const _Elem*  scan_is(mask _Maskval, const _Elem* _First,
        const _Elem* _Last) const { 
        _Adl_verify_range(_First, _Last);
        while (_First != _Last && !is(_Maskval, *_First)) {
            ++_First;
        }

        return _First;
    }

    const _Elem*  scan_not(mask _Maskval, const _Elem* _First,
        const _Elem* _Last) const { 
        _Adl_verify_range(_First, _Last);
        while (_First != _Last && is(_Maskval, *_First)) {
            ++_First;
        }

        return _First;
    }

    _Elem  tolower(_Elem _Ch) const { 
        return do_tolower(_Ch);
    }

    const _Elem*  tolower(
        _Elem* _First, const _Elem* _Last) const { 
        return do_tolower(_First, _Last);
    }

    _Elem  toupper(_Elem _Ch) const { 
        return do_toupper(_Ch);
    }

    const _Elem*  toupper(
        _Elem* _First, const _Elem* _Last) const { 
        return do_toupper(_First, _Last);
    }

    _Elem  widen(char _Byte) const { 
        return do_widen(_Byte);
    }

    const _Elem*  widen(const char* _First, const char* _Last,
        _Elem* _Dest) const { 
        return do_widen(_First, _Last, _Dest);
    }

    _Elem  narrow(_Elem _Ch, char _Dflt = '\0') const { 
        return do_narrow(_Ch, _Dflt);
    }

    const _Elem*  narrow(const _Elem* _First, const _Elem* _Last, char _Dflt,
        char* _Dest) const { 
        return do_narrow(_First, _Last, _Dflt, _Dest);
    }

     static locale::id id;

    explicit  ctype(const mask* _Table = nullptr, bool _Deletetable = false,
        size_t _Refs = 0)
        : ctype_base(_Refs) { 
        { _Locinfo _Lobj;
        _Init(_Lobj);
        }

        _Tidy(); 
        if (_Table) { 
            _Ctype._Table = _Table;
            _Ctype._Delfl = _Deletetable ? -1 : 0;
        } else { 
            _Ctype._Table = classic_table();
            _Ctype._Delfl = 0;
        }
    }

     ctype(const _Locinfo& _Lobj, size_t _Refs = 0) : ctype_base(_Refs) {
        _Init(_Lobj);
    }

    static size_t __cdecl _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
        if (_Ppf && !*_Ppf) {
            *_Ppf = new ctype<_Elem>(_Locinfo(_Ploc->c_str()));
        }

        return 2;
    }

    const mask*  table() const noexcept {
        return _Ctype._Table;
    }

    static const mask* __cdecl classic_table() noexcept {
        return ::std:: use_facet<ctype>(locale::classic()).table();
    }

     static const size_t table_size = 1 << 8; 

protected:
     ~ctype() noexcept override {
        _Tidy();
    }

    void  _Init(const _Locinfo& _Lobj) { 
        _Ctype = _Lobj._Getctype();
    }

    void  _Tidy() noexcept { 
        if (0 < _Ctype._Delfl) {
            :: free(const_cast<short*>(_Ctype._Table));
        } else if (_Ctype._Delfl < 0) {
            delete[] _Ctype._Table;
        }

        :: free(_Ctype._LocaleName);
    }

    virtual _Elem  do_tolower(_Elem _Ch) const { 
        return static_cast<_Elem>(_Tolower(static_cast<unsigned char>(_Ch), &_Ctype));
    }

    virtual const _Elem*  do_tolower(_Elem* _First,
        const _Elem* _Last) const { 
        _Adl_verify_range(_First, _Last);
        for (; _First != _Last; ++_First) {
            *_First = static_cast<_Elem>(_Tolower(static_cast<unsigned char>(*_First), &_Ctype));
        }

        return _First;
    }

    virtual _Elem  do_toupper(_Elem _Ch) const { 
        return static_cast<_Elem>(_Toupper(static_cast<unsigned char>(_Ch), &_Ctype));
    }

    virtual const _Elem*  do_toupper(_Elem* _First,
        const _Elem* _Last) const { 
        _Adl_verify_range(_First, _Last);
        for (; _First != _Last; ++_First) {
            *_First = static_cast<_Elem>(_Toupper(static_cast<unsigned char>(*_First), &_Ctype));
        }

        return _First;
    }

    virtual _Elem  do_widen(char _Byte) const { 
        return _Byte;
    }

    virtual const _Elem*  do_widen(
        const char* _First, const char* _Last, _Elem* _Dest) const { 
        _Adl_verify_range(_First, _Last);
        :: memcpy(_Dest, _First, static_cast<size_t>(_Last - _First));
        return _Last;
    }

    virtual _Elem  do_narrow(_Elem _Ch, char) const { 
        return _Ch;
    }

    virtual const _Elem*  do_narrow(const _Elem* _First, const _Elem* _Last, char,
        char* _Dest) const { 
        _Adl_verify_range(_First, _Last);
        :: memcpy(_Dest, _First, static_cast<size_t>(_Last - _First));
        return _Last;
    }

private:
    _Locinfo::_Ctypevec _Ctype; 
};

template <>
class  ctype<wchar_t>
    : public ctype_base { 
public:
    using _Elem     = wchar_t;
    using char_type = _Elem;

    bool  is(mask _Maskval, _Elem _Ch) const { 
        return do_is(_Maskval, _Ch);
    }

    const _Elem*  is(const _Elem* _First, const _Elem* _Last,
        mask* _Dest) const { 
        return do_is(_First, _Last, _Dest);
    }

    const _Elem*  scan_is(mask _Maskval, const _Elem* _First,
        const _Elem* _Last) const { 
        return do_scan_is(_Maskval, _First, _Last);
    }

    const _Elem*  scan_not(mask _Maskval, const _Elem* _First,
        const _Elem* _Last) const { 
        return do_scan_not(_Maskval, _First, _Last);
    }

    _Elem  tolower(_Elem _Ch) const { 
        return do_tolower(_Ch);
    }

    const _Elem*  tolower(
        _Elem* _First, const _Elem* _Last) const { 
        return do_tolower(_First, _Last);
    }

    _Elem  toupper(_Elem _Ch) const { 
        return do_toupper(_Ch);
    }

    const _Elem*  toupper(
        _Elem* _First, const _Elem* _Last) const { 
        return do_toupper(_First, _Last);
    }

    _Elem  widen(char _Byte) const { 
        return do_widen(_Byte);
    }

    const char*  widen(const char* _First, const char* _Last,
        _Elem* _Dest) const { 
        return do_widen(_First, _Last, _Dest);
    }

    char  narrow(_Elem _Ch, char _Dflt = '\0') const { 
        return do_narrow(_Ch, _Dflt);
    }

    const _Elem*  narrow(const _Elem* _First, const _Elem* _Last, char _Dflt,
        char* _Dest) const { 
        return do_narrow(_First, _Last, _Dflt, _Dest);
    }

     static locale::id id;

    explicit  ctype(size_t _Refs = 0) : ctype_base(_Refs) {
        { _Locinfo _Lobj;
        _Init(_Lobj);
        }
    }

     ctype(const _Locinfo& _Lobj, size_t _Refs = 0) : ctype_base(_Refs) {
        _Init(_Lobj);
    }

    static size_t __cdecl _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
        if (_Ppf && !*_Ppf) {
            *_Ppf = new ctype<_Elem>(_Locinfo(_Ploc->c_str()));
        }

        return 2;
    }

protected:
     ~ctype() noexcept override {
        if (_Ctype._Delfl) {
            :: free(const_cast<short*>(_Ctype._Table));
        }

        :: free(_Ctype._LocaleName);
    }

    void  _Init(const _Locinfo& _Lobj) { 
        _Ctype = _Lobj._Getctype();
        _Cvt   = _Lobj._Getcvt();
    }

    virtual bool  do_is(
        mask _Maskval, _Elem _Ch) const { 
        return (:: _Getwctype(_Ch, &_Ctype) & _Maskval) != 0;
    }

    virtual const _Elem*  do_is(const _Elem* _First, const _Elem* _Last,
        mask* _Dest) const { 
        _Adl_verify_range(_First, _Last);
        return :: _Getwctypes(_First, _Last, _Dest, &_Ctype);
    }

    virtual const _Elem*  do_scan_is(mask _Maskval, const _Elem* _First,
        const _Elem* _Last) const { 
        _Adl_verify_range(_First, _Last);
        while (_First != _Last && !is(_Maskval, *_First)) {
            ++_First;
        }

        return _First;
    }

    virtual const _Elem*  do_scan_not(mask _Maskval, const _Elem* _First,
        const _Elem* _Last) const { 
        _Adl_verify_range(_First, _Last);
        while (_First != _Last && is(_Maskval, *_First)) {
            ++_First;
        }

        return _First;
    }

    virtual _Elem  do_tolower(_Elem _Ch) const { 
        return _Towlower(_Ch, &_Ctype);
    }

    virtual const _Elem*  do_tolower(_Elem* _First,
        const _Elem* _Last) const { 
        _Adl_verify_range(_First, _Last);
        for (; _First != _Last; ++_First) {
            *_First = _Towlower(*_First, &_Ctype);
        }

        return _First;
    }

    virtual _Elem  do_toupper(_Elem _Ch) const { 
        return _Towupper(_Ch, &_Ctype);
    }

    virtual const _Elem*  do_toupper(_Elem* _First,
        const _Elem* _Last) const { 
        _Adl_verify_range(_First, _Last);
        for (; _First != _Last; ++_First) {
            *_First = _Towupper(*_First, &_Ctype);
        }

        return _First;
    }

    _Elem  _Dowiden(char _Byte) const { 
        mbstate_t _Mbst = {};
        wchar_t _Wc;
        return _Mbrtowc(&_Wc, &_Byte, 1, &_Mbst, &_Cvt) < 0 ? static_cast<wchar_t>(((wint_t)(0xFFFF))) : _Wc;
    }

    virtual _Elem  do_widen(char _Byte) const { 
        return _Dowiden(_Byte);
    }

    virtual const char*  do_widen(
        const char* _First, const char* _Last, _Elem* _Dest) const { 
        _Adl_verify_range(_First, _Last);
        for (; _First != _Last; ++_First, ++_Dest) {
            *_Dest = _Dowiden(*_First);
        }

        return _First;
    }

    char  _Donarrow(_Elem _Ch, char _Dflt) const { 
        char _Buf[5];
        mbstate_t _Mbst = {};
        return _Wcrtomb(_Buf, _Ch, &_Mbst, &_Cvt) != 1 ? _Dflt : _Buf[0];
    }

    virtual char  do_narrow(_Elem _Ch, char _Dflt) const { 
        return _Donarrow(_Ch, _Dflt);
    }

    virtual const _Elem*  do_narrow(const _Elem* _First, const _Elem* _Last, char _Dflt,
        char* _Dest) const { 
        _Adl_verify_range(_First, _Last);
        for (; _First != _Last; ++_First, ++_Dest) {
            *_Dest = _Donarrow(*_First, _Dflt);
        }

        return _First;
    }

private:
    _Locinfo::_Ctypevec _Ctype; 
    _Locinfo::_Cvtvec _Cvt; 
};


template <>
class  ctype<unsigned short>
    : public ctype_base { 
public:
    using _Elem     = unsigned short;
    using char_type = _Elem;

    bool  is(mask _Maskval, _Elem _Ch) const { 
        return do_is(_Maskval, _Ch);
    }

    const _Elem*  is(const _Elem* _First, const _Elem* _Last,
        mask* _Dest) const { 
        return do_is(_First, _Last, _Dest);
    }

    const _Elem*  scan_is(mask _Maskval, const _Elem* _First,
        const _Elem* _Last) const { 
        return do_scan_is(_Maskval, _First, _Last);
    }

    const _Elem*  scan_not(mask _Maskval, const _Elem* _First,
        const _Elem* _Last) const { 
        return do_scan_not(_Maskval, _First, _Last);
    }

    _Elem  tolower(_Elem _Ch) const { 
        return do_tolower(_Ch);
    }

    const _Elem*  tolower(
        _Elem* _First, const _Elem* _Last) const { 
        return do_tolower(_First, _Last);
    }

    _Elem  toupper(_Elem _Ch) const { 
        return do_toupper(_Ch);
    }

    const _Elem*  toupper(
        _Elem* _First, const _Elem* _Last) const { 
        return do_toupper(_First, _Last);
    }

    _Elem  widen(char _Byte) const { 
        return do_widen(_Byte);
    }

    const char*  widen(const char* _First, const char* _Last,
        _Elem* _Dest) const { 
        return do_widen(_First, _Last, _Dest);
    }

    char  narrow(_Elem _Ch, char _Dflt = '\0') const { 
        return do_narrow(_Ch, _Dflt);
    }

    const _Elem*  narrow(const _Elem* _First, const _Elem* _Last, char _Dflt,
        char* _Dest) const { 
        return do_narrow(_First, _Last, _Dflt, _Dest);
    }

     static locale::id id;

    explicit  ctype(size_t _Refs = 0) : ctype_base(_Refs) {
        { _Locinfo _Lobj;
        _Init(_Lobj);
        }
    }

     ctype(const _Locinfo& _Lobj, size_t _Refs = 0) : ctype_base(_Refs) {
        _Init(_Lobj);
    }

    static size_t __cdecl _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
        if (_Ppf && !*_Ppf) {
            *_Ppf = new ctype<_Elem>(_Locinfo(_Ploc->c_str()));
        }

        return 2;
    }

protected:
     ~ctype() noexcept override {
        if (_Ctype._Delfl) {
            :: free(const_cast<short*>(_Ctype._Table));
        }

        :: free(_Ctype._LocaleName);
    }

    void  _Init(const _Locinfo& _Lobj) { 
        _Ctype = _Lobj._Getctype();
        _Cvt   = _Lobj._Getcvt();
    }

    virtual bool  do_is(
        mask _Maskval, _Elem _Ch) const { 
        return (:: _Getwctype(_Ch, &_Ctype) & _Maskval) != 0;
    }

    virtual const _Elem*  do_is(const _Elem* _First, const _Elem* _Last,
        mask* _Dest) const { 
        _Adl_verify_range(_First, _Last);
        return reinterpret_cast<const _Elem*>(:: _Getwctypes(
            reinterpret_cast<const wchar_t*>(_First), reinterpret_cast<const wchar_t*>(_Last), _Dest, &_Ctype));
    }

    virtual const _Elem*  do_scan_is(mask _Maskval, const _Elem* _First,
        const _Elem* _Last) const { 
        _Adl_verify_range(_First, _Last);
        while (_First != _Last && !is(_Maskval, *_First)) {
            ++_First;
        }

        return _First;
    }

    virtual const _Elem*  do_scan_not(mask _Maskval, const _Elem* _First,
        const _Elem* _Last) const { 
        _Adl_verify_range(_First, _Last);
        while (_First != _Last && is(_Maskval, *_First)) {
            ++_First;
        }

        return _First;
    }

    virtual _Elem  do_tolower(_Elem _Ch) const { 
        return _Towlower(_Ch, &_Ctype);
    }

    virtual const _Elem*  do_tolower(_Elem* _First,
        const _Elem* _Last) const { 
        _Adl_verify_range(_First, _Last);
        for (; _First != _Last; ++_First) {
            *_First = _Towlower(*_First, &_Ctype);
        }

        return _First;
    }

    virtual _Elem  do_toupper(_Elem _Ch) const { 
        return _Towupper(_Ch, &_Ctype);
    }

    virtual const _Elem*  do_toupper(_Elem* _First,
        const _Elem* _Last) const { 
        _Adl_verify_range(_First, _Last);
        for (; _First != _Last; ++_First) {
            *_First = _Towupper(*_First, &_Ctype);
        }

        return _First;
    }

    _Elem  _Dowiden(char _Byte) const { 
        mbstate_t _Mbst = {};
        unsigned short _Wc;

        if (_Mbrtowc(reinterpret_cast<wchar_t*>(&_Wc), &_Byte, 1, &_Mbst, &_Cvt) < 0) {
            return static_cast<unsigned short>(((wint_t)(0xFFFF)));
        }

        return _Wc;
    }

    virtual _Elem  do_widen(char _Byte) const { 
        return _Dowiden(_Byte);
    }

    virtual const char*  do_widen(
        const char* _First, const char* _Last, _Elem* _Dest) const { 
        _Adl_verify_range(_First, _Last);
        for (; _First != _Last; ++_First, ++_Dest) {
            *_Dest = _Dowiden(*_First);
        }

        return _First;
    }

    char  _Donarrow(_Elem _Ch, char _Dflt) const { 
        char _Buf[5];
        mbstate_t _Mbst = {};
        return _Wcrtomb(_Buf, _Ch, &_Mbst, &_Cvt) != 1 ? _Dflt : _Buf[0];
    }

    virtual char  do_narrow(_Elem _Ch, char _Dflt) const { 
        return _Donarrow(_Ch, _Dflt);
    }

    virtual const _Elem*  do_narrow(const _Elem* _First, const _Elem* _Last, char _Dflt,
        char* _Dest) const { 
        _Adl_verify_range(_First, _Last);
        for (; _First != _Last; ++_First, ++_Dest) {
            *_Dest = _Donarrow(*_First, _Dflt);
        }

        return _First;
    }

private:
    _Locinfo::_Ctypevec _Ctype; 
    _Locinfo::_Cvtvec _Cvt; 
};
#line 3201 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocale"

template <class _Elem>
class ctype_byname : public ctype<_Elem> { 
public:
    static_assert(!0 || _Is_any_of_v<_Elem, char, wchar_t>, "Unsupported facet specialization; see N4800 27.3.1.1.1 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this diagnostic.");

    explicit  ctype_byname(const char* _Locname, size_t _Refs = 0)
        : ctype<_Elem>(_Locinfo(_Locname), _Refs) {} 

    explicit  ctype_byname(const string& _Str, size_t _Refs = 0)
        : ctype<_Elem>(_Locinfo(_Str.c_str()), _Refs) {} 

protected:
     ~ctype_byname() noexcept override {}
};

enum class _Case_sensitive : bool { _Nope, _Yes };

template <class _InIt, class _Elem>
int __cdecl _Getloctxt(
    _InIt& _First, _InIt& _Last, size_t _Numfields, const _Elem* _Ptr, const _Case_sensitive _Matching) {
    
    for (size_t _Off = 0; _Ptr[_Off] != _Elem{}; ++_Off) {
        if (_Ptr[_Off] == _Ptr[0]) {
            ++_Numfields; 
        }
    }

    string _Str(_Numfields, '\0'); 
    const ctype<_Elem>& _CType = ::std:: use_facet<ctype<_Elem>>(locale{});

    int _Ans = -2; 
    for (size_t _Column = 1;; ++_Column, (void) ++_First, _Ans = -1) { 
        bool _Prefix  = false; 
        size_t _Off   = 0; 
        size_t _Field = 0; 

        for (; _Field < _Numfields; ++_Field) { 
            while (_Ptr[_Off] != _Elem{} && _Ptr[_Off] != _Ptr[0]) { 
                ++_Off;
            }

            if (_Str[_Field] != '\0') {
                _Off += _Str[_Field]; 
            } else if (_Ptr[_Off += _Column] == _Ptr[0]
                       || _Ptr[_Off] == _Elem{}) { 
                _Str[_Field] = static_cast<char>(_Column < 127 ? _Column : 127); 
                _Ans         = static_cast<int>(_Field); 
            } else if (_First == _Last
                       || (_Matching == _Case_sensitive::_Yes
                               ? _Ptr[_Off] != *_First
                               : _CType.tolower(_Ptr[_Off]) != _CType.tolower(static_cast<_Elem>(*_First)))) {
                _Str[_Field] = static_cast<char>(_Column < 127 ? _Column : 127); 
            } else {
                _Prefix = true; 
            }
        }

        if (!_Prefix || _First == _Last) {
            break; 
        }
    }
    return _Ans; 
}


#line 3271 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocale"
}


#pragma warning(pop)
#pragma pack(pop)
#line 3277 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocale"
#line 3278 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocale"
#line 14 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xiosbase"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
template <class _Dummy>
class _Iosb { 
public:
    enum _Dummy_enum { _Dummy_enum_val = 1 }; 
    enum _Fmtflags { 
        _Fmtmask = 0xffff,
        _Fmtzero = 0
    };

    static constexpr _Fmtflags skipws     = static_cast<_Fmtflags>(0x0001);
    static constexpr _Fmtflags unitbuf    = static_cast<_Fmtflags>(0x0002);
    static constexpr _Fmtflags uppercase  = static_cast<_Fmtflags>(0x0004);
    static constexpr _Fmtflags showbase   = static_cast<_Fmtflags>(0x0008);
    static constexpr _Fmtflags showpoint  = static_cast<_Fmtflags>(0x0010);
    static constexpr _Fmtflags showpos    = static_cast<_Fmtflags>(0x0020);
    static constexpr _Fmtflags left       = static_cast<_Fmtflags>(0x0040);
    static constexpr _Fmtflags right      = static_cast<_Fmtflags>(0x0080);
    static constexpr _Fmtflags internal   = static_cast<_Fmtflags>(0x0100);
    static constexpr _Fmtflags dec        = static_cast<_Fmtflags>(0x0200);
    static constexpr _Fmtflags oct        = static_cast<_Fmtflags>(0x0400);
    static constexpr _Fmtflags hex        = static_cast<_Fmtflags>(0x0800);
    static constexpr _Fmtflags scientific = static_cast<_Fmtflags>(0x1000);
    static constexpr _Fmtflags fixed      = static_cast<_Fmtflags>(0x2000);

    static constexpr _Fmtflags hexfloat = static_cast<_Fmtflags>(0x3000); 

    static constexpr _Fmtflags boolalpha   = static_cast<_Fmtflags>(0x4000);
    static constexpr _Fmtflags _Stdio      = static_cast<_Fmtflags>(0x8000);
    static constexpr _Fmtflags adjustfield = static_cast<_Fmtflags>(0x01C0); 
    static constexpr _Fmtflags basefield   = static_cast<_Fmtflags>(0x0E00); 
    static constexpr _Fmtflags floatfield  = static_cast<_Fmtflags>(0x3000); 

    enum _Iostate { 
        _Statmask = 0x17
    };

    static constexpr _Iostate goodbit = static_cast<_Iostate>(0x0);
    static constexpr _Iostate eofbit  = static_cast<_Iostate>(0x1);
    static constexpr _Iostate failbit = static_cast<_Iostate>(0x2);
    static constexpr _Iostate badbit  = static_cast<_Iostate>(0x4);

    enum _Openmode { 
        _Openmask = 0xff
    };

    static constexpr _Openmode in         = static_cast<_Openmode>(0x01);
    static constexpr _Openmode out        = static_cast<_Openmode>(0x02);
    static constexpr _Openmode ate        = static_cast<_Openmode>(0x04);
    static constexpr _Openmode app        = static_cast<_Openmode>(0x08);
    static constexpr _Openmode trunc      = static_cast<_Openmode>(0x10);
    static constexpr _Openmode _Nocreate  = static_cast<_Openmode>(0x40);
    static constexpr _Openmode _Noreplace = static_cast<_Openmode>(0x80);
    static constexpr _Openmode binary     = static_cast<_Openmode>(0x20);

    enum _Seekdir { 
        _Seekbeg,
        _Seekcur,
        _Seekend
    };

    static constexpr _Seekdir beg = _Seekbeg;
    static constexpr _Seekdir cur = _Seekcur;
    static constexpr _Seekdir end = _Seekend;

    enum { 
        _Openprot = 0x40
    };

    static constexpr int _Default_open_prot = 0x40; 
};

template <class _Dummy>
const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::skipws;
template <class _Dummy>
const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::unitbuf;
template <class _Dummy>
const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::uppercase;
template <class _Dummy>
const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::showbase;
template <class _Dummy>
const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::showpoint;
template <class _Dummy>
const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::showpos;
template <class _Dummy>
const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::left;
template <class _Dummy>
const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::right;
template <class _Dummy>
const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::internal;
template <class _Dummy>
const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::dec;
template <class _Dummy>
const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::oct;
template <class _Dummy>
const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::hex;
template <class _Dummy>
const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::scientific;
template <class _Dummy>
const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::fixed;

template <class _Dummy>
const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::hexfloat; 

template <class _Dummy>
const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::boolalpha;
template <class _Dummy>
const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::_Stdio;
template <class _Dummy>
const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::adjustfield;
template <class _Dummy>
const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::basefield;
template <class _Dummy>
const typename _Iosb<_Dummy>::_Fmtflags _Iosb<_Dummy>::floatfield;

template <class _Dummy>
const typename _Iosb<_Dummy>::_Iostate _Iosb<_Dummy>::goodbit;
template <class _Dummy>
const typename _Iosb<_Dummy>::_Iostate _Iosb<_Dummy>::eofbit;
template <class _Dummy>
const typename _Iosb<_Dummy>::_Iostate _Iosb<_Dummy>::failbit;
template <class _Dummy>
const typename _Iosb<_Dummy>::_Iostate _Iosb<_Dummy>::badbit;

template <class _Dummy>
const typename _Iosb<_Dummy>::_Openmode _Iosb<_Dummy>::in;
template <class _Dummy>
const typename _Iosb<_Dummy>::_Openmode _Iosb<_Dummy>::out;
template <class _Dummy>
const typename _Iosb<_Dummy>::_Openmode _Iosb<_Dummy>::ate;
template <class _Dummy>
const typename _Iosb<_Dummy>::_Openmode _Iosb<_Dummy>::app;
template <class _Dummy>
const typename _Iosb<_Dummy>::_Openmode _Iosb<_Dummy>::trunc;
template <class _Dummy>
const typename _Iosb<_Dummy>::_Openmode _Iosb<_Dummy>::_Nocreate;
template <class _Dummy>
const typename _Iosb<_Dummy>::_Openmode _Iosb<_Dummy>::_Noreplace;
template <class _Dummy>
const typename _Iosb<_Dummy>::_Openmode _Iosb<_Dummy>::binary;

template <class _Dummy>
const typename _Iosb<_Dummy>::_Seekdir _Iosb<_Dummy>::beg;
template <class _Dummy>
const typename _Iosb<_Dummy>::_Seekdir _Iosb<_Dummy>::cur;
template <class _Dummy>
const typename _Iosb<_Dummy>::_Seekdir _Iosb<_Dummy>::end;

class  ios_base : public _Iosb<int> { 
public:
    using fmtflags = int;
    using iostate  = int;
    using openmode = int;
    using seekdir  = int;


#line 181 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xiosbase"

    enum event { 
        erase_event,
        imbue_event,
        copyfmt_event
    };

    using event_callback = void(__cdecl*)(event, ios_base&, int);


#line 195 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xiosbase"

    class failure : public system_error { 
    public:
        explicit failure(const string& _Message, const error_code& _Errcode = make_error_code(io_errc::stream))
            : system_error(_Errcode, _Message) {} 

        explicit failure(const char* _Message, const error_code& _Errcode = make_error_code(io_errc::stream))
            : system_error(_Errcode, _Message) {} 


#line 210 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xiosbase"
    };

    class  Init { 
    public:
         Init() { 
            _Init_ctor(this);
        }

         ~Init() noexcept { 
            _Init_dtor(this);
        }

    private:
        static void __cdecl _Init_ctor(Init*);
        static void __cdecl _Init_dtor(Init*);

         static int _Init_cnt; 

        static int& __cdecl _Init_cnt_func();
    };

    explicit  operator bool() const {
        return !fail();
    }

    [[nodiscard]] bool  operator!() const {
        return fail();
    }

    void  clear(iostate _State, bool _Reraise) { 
        _State &= _Statmask;
        _Mystate             = _State;
        const auto _Filtered = _State & _Except;
        if (_Filtered) {
            if (_Reraise) {
                throw;
            }

            const char* _Msg;
            if (_Filtered & ios_base::badbit) {
                _Msg = "ios_base::badbit set";
            } else if (_Filtered & ios_base::failbit) {
                _Msg = "ios_base::failbit set";
            } else {
                _Msg = "ios_base::eofbit set";
            }

            throw failure(_Msg);
        }
    }

    void  clear(iostate _State = goodbit) { 
        clear(_State, false);
    }


#line 270 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xiosbase"

    [[nodiscard]] iostate  rdstate() const {
        return _Mystate;
    }

    void  setstate(
        iostate _State, bool _Exreraise) { 
        clear(rdstate() | _State, _Exreraise);
    }

    void  setstate(iostate _State) { 
        clear(rdstate() | _State, false);
    }


#line 289 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xiosbase"

    [[nodiscard]] bool  good() const {
        return rdstate() == ios_base::goodbit;
    }

    [[nodiscard]] bool  eof() const {
        return rdstate() & ios_base::eofbit;
    }

    [[nodiscard]] bool  fail() const {
        return rdstate() & (ios_base::badbit | ios_base::failbit);
    }

    [[nodiscard]] bool  bad() const {
        return rdstate() & ios_base::badbit;
    }

    [[nodiscard]] iostate  exceptions() const {
        return _Except;
    }

    void  exceptions(iostate _Newexcept) { 
        _Except = _Newexcept & _Statmask;
        clear(rdstate());
    }


#line 320 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xiosbase"

    [[nodiscard]] fmtflags  flags() const {
        return _Fmtfl;
    }

    fmtflags  flags(fmtflags _Newfmtflags) { 
        const fmtflags _Oldfmtflags = _Fmtfl;
        _Fmtfl                      = _Newfmtflags & _Fmtmask;
        return _Oldfmtflags;
    }

    fmtflags  setf(fmtflags _Newfmtflags) { 
        const ios_base::fmtflags _Oldfmtflags = _Fmtfl;
        _Fmtfl |= _Newfmtflags & _Fmtmask;
        return _Oldfmtflags;
    }

    fmtflags  setf(
        fmtflags _Newfmtflags, fmtflags _Mask) { 
        const ios_base::fmtflags _Oldfmtflags = _Fmtfl;
        _Fmtfl                                = (_Oldfmtflags & ~_Mask) | (_Newfmtflags & _Mask & _Fmtmask);
        return _Oldfmtflags;
    }

    void  unsetf(fmtflags _Mask) { 
        _Fmtfl &= ~_Mask;
    }

    [[nodiscard]] streamsize  precision() const {
        return _Prec;
    }

    streamsize  precision(streamsize _Newprecision) { 
        const streamsize _Oldprecision = _Prec;
        _Prec                          = _Newprecision;
        return _Oldprecision;
    }

    [[nodiscard]] streamsize  width() const {
        return _Wide;
    }

    streamsize  width(streamsize _Newwidth) { 
        const streamsize _Oldwidth = _Wide;
        _Wide                      = _Newwidth;
        return _Oldwidth;
    }

    [[nodiscard]] locale  getloc() const { 
        return *_Ploc;
    }

    locale  imbue(const locale& _Loc) { 
        locale _Oldlocale = *_Ploc;
        *_Ploc            = _Loc;
        _Callfns(imbue_event);
        return _Oldlocale;
    }

    [[nodiscard]] static int __cdecl xalloc() { 
        { ::std:: _Lockit _Lock(2); 
        return _Index++;
        }
    }

    [[nodiscard]] long&  iword(int _Idx) {
        return _Findarr(_Idx)._Lo;
    }

    [[nodiscard]] void*&  pword(int _Idx) {
        return _Findarr(_Idx)._Vp;
    }

    void  register_callback(event_callback _Pfn,
        int _Idx) { 
        _Calls = new _Fnarray(_Idx, _Pfn, _Calls);
    }

    ios_base&  copyfmt(const ios_base& _Other) { 
        if (this != ::std:: addressof(_Other)) { 
            _Tidy();
            *_Ploc          = *_Other._Ploc;
            _Fmtfl          = _Other._Fmtfl;
            _Prec           = _Other._Prec;
            _Wide           = _Other._Wide;
            _Iosarray* _Ptr = _Other._Arr;

            for (_Arr = nullptr; _Ptr; _Ptr = _Ptr->_Next) {
                if (_Ptr->_Lo != 0 || _Ptr->_Vp) { 
                    iword(_Ptr->_Index) = _Ptr->_Lo;
                    pword(_Ptr->_Index) = _Ptr->_Vp;
                }
            }

            for (_Fnarray* _Pfa = _Other._Calls; _Pfa; _Pfa = _Pfa->_Next) {
                register_callback(_Pfa->_Pfn, _Pfa->_Index);
            }

            _Callfns(copyfmt_event); 
            exceptions(_Other._Except); 
        }
        return *this;
    }

    static bool __cdecl sync_with_stdio(
        bool _Newsync = true) { 
        { ::std:: _Lockit _Lock(2); 
        const bool _Oldsync = _Sync;
        _Sync               = _Newsync;
        return _Oldsync;
        }
    }

    void  swap(ios_base& _Right) {
        if (this != ::std:: addressof(_Right)) {
            ::std:: swap(_Mystate, _Right._Mystate);
            ::std:: swap(_Except, _Right._Except);
            ::std:: swap(_Fmtfl, _Right._Fmtfl);
            ::std:: swap(_Prec, _Right._Prec);
            ::std:: swap(_Wide, _Right._Wide);

            ::std:: swap(_Arr, _Right._Arr);
            ::std:: swap(_Calls, _Right._Calls);
            ::std:: swap(_Ploc, _Right._Ploc);
        }
    }

    virtual  ~ios_base() noexcept {
        _Ios_base_dtor(this);
    }

    static void __cdecl _Addstd(ios_base*); 

    size_t _Stdstr{0}; 

protected:
     ios_base() {}

    void  _Init() { 
        _Ploc   = nullptr;
        _Stdstr = 0;
        _Except = goodbit;
        _Fmtfl  = skipws | dec;
        _Prec   = 6;
        _Wide   = 0;
        _Arr    = nullptr;
        _Calls  = nullptr;
        clear(goodbit);
        _Ploc = new locale;
    }

private:
    struct _Iosarray : _Crt_new_delete { 
    public:
         _Iosarray(int _Idx, _Iosarray* _Link)
            : _Next(_Link), _Index(_Idx), _Lo(0), _Vp(nullptr) {} 

        _Iosarray* _Next; 
        int _Index; 
        long _Lo; 
        void* _Vp; 
    };

    struct _Fnarray : _Crt_new_delete { 
         _Fnarray(int _Idx, event_callback _Pnew, _Fnarray* _Link)
            : _Next(_Link), _Index(_Idx), _Pfn(_Pnew) {} 

        _Fnarray* _Next; 
        int _Index; 
        event_callback _Pfn; 
    };

    void  _Callfns(event _Ev) { 
        for (_Fnarray* _Pfa = _Calls; _Pfa; _Pfa = _Pfa->_Next) {
            (*_Pfa->_Pfn)(_Ev, *this, _Pfa->_Index);
        }
    }

    _Iosarray&  _Findarr(int _Idx) { 
        _Iosarray* _Ptr1;
        _Iosarray* _Ptr2;

        for (_Ptr1 = _Arr, _Ptr2 = nullptr; _Ptr1; _Ptr1 = _Ptr1->_Next) {
            if (_Ptr1->_Index == _Idx) {
                return *_Ptr1; 
            } else if (!_Ptr2 && _Ptr1->_Lo == 0 && !_Ptr1->_Vp) {
                _Ptr2 = _Ptr1; 
            }
        }

        if (_Ptr2) { 
            _Ptr2->_Index = _Idx;
            return *_Ptr2;
        }

        _Arr = new _Iosarray(_Idx, _Arr); 
        return *_Arr;
    }

    void  _Tidy() noexcept { 
        _Callfns(erase_event);
        _Iosarray* _Ptr1;
        _Iosarray* _Ptr2;

        for (_Ptr1 = _Arr; _Ptr1; _Ptr1 = _Ptr2) { 
            _Ptr2 = _Ptr1->_Next;
            delete _Ptr1;
        }
        _Arr = nullptr;

        _Fnarray* _Pfa1;
        _Fnarray* _Pfa2;
        for (_Pfa1 = _Calls; _Pfa1; _Pfa1 = _Pfa2) { 
            _Pfa2 = _Pfa1->_Next;
            delete _Pfa1;
        }
        _Calls = nullptr;
    }

    iostate _Mystate; 
    iostate _Except; 
    fmtflags _Fmtfl; 
    streamsize _Prec; 
    streamsize _Wide; 
    _Iosarray* _Arr{nullptr}; 
    _Fnarray* _Calls{nullptr}; 
    locale* _Ploc{nullptr}; 

     static int _Index;
     static bool _Sync;

    static void __cdecl _Ios_base_dtor(ios_base*);

public:
    ios_base(const ios_base&) = delete;
    ios_base& operator=(const ios_base&) = delete;
};
}


#pragma warning(pop)
#pragma pack(pop)
#line 563 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xiosbase"
#line 564 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xiosbase"
#line 12 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\streambuf"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
template <class _Elem, class _Traits>
class basic_streambuf { 
protected:
     basic_streambuf() : _Plocale(new locale) {
        _Init();
    }

     basic_streambuf(_Uninitialized) {}

     basic_streambuf(const basic_streambuf& _Right) : _Plocale(new locale(_Right.getloc())) {
        _Init();
        setp(_Right.pbase(), _Right.pptr(), _Right.epptr());
        setg(_Right.eback(), _Right.gptr(), _Right.egptr());
    }

    basic_streambuf&  operator=(const basic_streambuf& _Right) {
        if (this != ::std:: addressof(_Right)) {
            setp(_Right.pbase(), _Right.pptr(), _Right.epptr());
            setg(_Right.eback(), _Right.gptr(), _Right.egptr());
            pubimbue(_Right.getloc());
        }
        return *this;
    }

    void  swap(basic_streambuf& _Right) {
        if (this != ::std:: addressof(_Right)) {
            _Elem* _Pfirst0 = pbase();
            _Elem* _Pnext0  = pptr();
            _Elem* _Pend    = epptr();
            _Elem* _Gfirst0 = eback();
            _Elem* _Gnext0  = gptr();
            _Elem* _Gend    = egptr();

            setp(_Right.pbase(), _Right.pptr(), _Right.epptr());
            _Right.setp(_Pfirst0, _Pnext0, _Pend);

            setg(_Right.eback(), _Right.gptr(), _Right.egptr());
            _Right.setg(_Gfirst0, _Gnext0, _Gend);

            ::std:: swap(_Plocale, _Right._Plocale);
        }
    }

public:
    using char_type   = _Elem;
    using traits_type = _Traits;

    virtual  ~basic_streambuf() noexcept {
        delete _Plocale;
    }

    using int_type = typename _Traits::int_type;
    using pos_type = typename _Traits::pos_type;
    using off_type = typename _Traits::off_type;

    pos_type  pubseekoff(off_type _Off, ios_base::seekdir _Way,
        ios_base::openmode _Mode = ios_base::in | ios_base::out) { 
        return seekoff(_Off, _Way, _Mode);
    }


#line 87 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\streambuf"

    pos_type  pubseekpos(pos_type _Pos,
        ios_base::openmode _Mode = ios_base::in | ios_base::out) { 
        return seekpos(_Pos, _Mode);
    }


#line 99 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\streambuf"

    basic_streambuf*  pubsetbuf(_Elem* _Buffer,
        streamsize _Count) { 
        return setbuf(_Buffer, _Count);
    }

    locale  pubimbue(const locale& _Newlocale) { 
        locale _Oldlocale = *_Plocale;
        imbue(_Newlocale);
        *_Plocale = _Newlocale;
        return _Oldlocale;
    }

    locale  getloc() const { 
        return *_Plocale;
    }

    streamsize  in_avail() {
        streamsize _Res = _Gnavail();
        return 0 < _Res ? _Res : showmanyc();
    }

    int  pubsync() { 
        return sync();
    }

    int_type  sbumpc() { 
        return 0 < _Gnavail() ? _Traits::to_int_type(*_Gninc()) : uflow();
    }

    int_type  sgetc() { 
        return 0 < _Gnavail() ? _Traits::to_int_type(*gptr()) : underflow();
    }

    streamsize  sgetn(_Elem* _Ptr,
        streamsize _Count) { 
        return xsgetn(_Ptr, _Count);
    }

    int_type  snextc() { 
        return 1 < _Gnavail()                                 ? _Traits::to_int_type(*_Gnpreinc())
             : _Traits::eq_int_type(_Traits::eof(), sbumpc()) ? _Traits::eof()
                                                              : sgetc();
    }

    int_type  sputbackc(_Elem _Ch) { 
        if (gptr() && eback() < gptr() && _Traits::eq(_Ch, gptr()[-1])) {
            return _Traits::to_int_type(*_Gndec());
        }

        return pbackfail(_Traits::to_int_type(_Ch));
    }


#line 161 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\streambuf"

    int_type  sungetc() { 
        return gptr() && eback() < gptr() ? _Traits::to_int_type(*_Gndec()) : pbackfail();
    }

    int_type  sputc(_Elem _Ch) { 
        return 0 < _Pnavail() ? _Traits::to_int_type(*_Pninc() = _Ch) : overflow(_Traits::to_int_type(_Ch));
    }

    streamsize  sputn(const _Elem* _Ptr,
        streamsize _Count) { 
        return xsputn(_Ptr, _Count);
    }

    virtual void  _Lock() {} 

    virtual void  _Unlock() {} 

protected:
    _Elem*  eback() const {
        return *_IGfirst;
    }

    _Elem*  gptr() const {
        return *_IGnext;
    }

    _Elem*  pbase() const {
        return *_IPfirst;
    }

    _Elem*  pptr() const {
        return *_IPnext;
    }

    _Elem*  egptr() const {
        return *_IGnext + *_IGcount;
    }

    void  gbump(int _Off) { 
        *_IGcount -= _Off;
        *_IGnext += _Off;
    }

    void  setg(_Elem* _First, _Elem* _Next, _Elem* _Last) { 
        *_IGfirst = _First;
        *_IGnext  = _Next;
        *_IGcount = static_cast<int>(_Last - _Next);
    }

    _Elem*  epptr() const {
        return *_IPnext + *_IPcount;
    }

    _Elem*  _Gndec() { 
        ++*_IGcount;
        return --*_IGnext;
    }

    _Elem*  _Gninc() { 
        --*_IGcount;
        return (*_IGnext)++;
    }

    _Elem*  _Gnpreinc() { 
        --*_IGcount;
        return ++(*_IGnext);
    }

    streamsize  _Gnavail() const { 
        return *_IGnext ? *_IGcount : 0;
    }

    void  pbump(int _Off) { 
        *_IPcount -= _Off;
        *_IPnext += _Off;
    }

    void  setp(_Elem* _First, _Elem* _Last) { 
        *_IPfirst = _First;
        *_IPnext  = _First;
        *_IPcount = static_cast<int>(_Last - _First);
    }

    void  setp(
        _Elem* _First, _Elem* _Next, _Elem* _Last) { 
        *_IPfirst = _First;
        *_IPnext  = _Next;
        *_IPcount = static_cast<int>(_Last - _Next);
    }

    _Elem*  _Pninc() { 
        --*_IPcount;
        return (*_IPnext)++;
    }

    streamsize  _Pnavail() const { 
        return *_IPnext ? *_IPcount : 0;
    }

    void  _Init() { 
        _IGfirst = &_Gfirst;
        _IPfirst = &_Pfirst;
        _IGnext  = &_Gnext;
        _IPnext  = &_Pnext;
        _IGcount = &_Gcount;
        _IPcount = &_Pcount;
        setp(nullptr, nullptr);
        setg(nullptr, nullptr, nullptr);
    }

    void  _Init(_Elem** _Gf, _Elem** _Gn, int* _Gc, _Elem** _Pf, _Elem** _Pn, int* _Pc) {
        
        _IGfirst = _Gf;
        _IPfirst = _Pf;
        _IGnext  = _Gn;
        _IPnext  = _Pn;
        _IGcount = _Gc;
        _IPcount = _Pc;
    }

    virtual int_type  overflow(int_type = _Traits::eof()) { 
        return _Traits::eof();
    }

    virtual int_type  pbackfail(int_type = _Traits::eof()) {
        
        return _Traits::eof();
    }

    virtual streamsize  showmanyc() {
        return 0;
    }

    virtual int_type  underflow() { 
        return _Traits::eof();
    }

    virtual int_type  uflow() { 
        return _Traits::eq_int_type(_Traits::eof(), underflow()) ? _Traits::eof() : _Traits::to_int_type(*_Gninc());
    }

    virtual streamsize  xsgetn(_Elem* _Ptr, streamsize _Count) { 
        const streamsize _Start_count = _Count;

        while (0 < _Count) {
            streamsize _Size = _Gnavail();
            if (0 < _Size) { 
                if (_Count < _Size) {
                    _Size = _Count;
                }

                _Traits::copy(_Ptr, gptr(), static_cast<size_t>(_Size));
                _Ptr += _Size;
                _Count -= _Size;
                gbump(static_cast<int>(_Size));
            } else {
                const int_type _Meta = uflow();
                if (_Traits::eq_int_type(_Traits::eof(), _Meta)) {
                    break; 
                }

                
                *_Ptr++ = _Traits::to_char_type(_Meta);
                --_Count;
            }
        }

        return _Start_count - _Count;
    }

    virtual streamsize  xsputn(const _Elem* _Ptr, streamsize _Count) {
        
        const streamsize _Start_count = _Count;
        while (0 < _Count) {
            streamsize _Size = _Pnavail();
            if (0 < _Size) { 
                if (_Count < _Size) {
                    _Size = _Count;
                }

                _Traits::copy(pptr(), _Ptr, static_cast<size_t>(_Size));
                _Ptr += _Size;
                _Count -= _Size;
                pbump(static_cast<int>(_Size));
            } else if (_Traits::eq_int_type(_Traits::eof(), overflow(_Traits::to_int_type(*_Ptr)))) {
                break; 
            } else { 
                ++_Ptr;
                --_Count;
            }
        }

        return _Start_count - _Count;
    }

    virtual pos_type  seekoff(
        off_type, ios_base::seekdir, ios_base::openmode = ios_base::in | ios_base::out) {
        
        return pos_type(off_type(-1));
    }

    virtual pos_type  seekpos(pos_type, ios_base::openmode = ios_base::in | ios_base::out) {
        
        return pos_type(off_type(-1));
    }

    virtual basic_streambuf*  setbuf(_Elem*, streamsize) {
        
        return this;
    }

    virtual int  sync() { 
        return 0;
    }

    virtual void  imbue(const locale&) {} 

private:
    _Elem* _Gfirst; 
    _Elem* _Pfirst; 
    _Elem** _IGfirst; 
    _Elem** _IPfirst; 
    _Elem* _Gnext; 
    _Elem* _Pnext; 
    _Elem** _IGnext; 
    _Elem** _IPnext; 

    int _Gcount; 
    int _Pcount; 
    int* _IGcount; 
    int* _IPcount; 

protected:
    locale* _Plocale; 
};


#line 409 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\streambuf"
}


#pragma warning(pop)
#pragma pack(pop)
#line 416 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\streambuf"
#line 417 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\streambuf"
#line 17 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocnum"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


extern "C" {

extern  float __cdecl _Stofx(
    const char*,     char**, long, int*);
extern  double __cdecl _Stodx(
    const char*,     char**, long, int*);
extern  long double __cdecl _Stoldx(
    const char*,     char**, long, int*);
extern  long __cdecl _Stolx(
    const char*,     char**, int, int*);
extern  unsigned long __cdecl _Stoulx(
    const char*,     char**, int, int*);
extern  long long __cdecl _Stollx(
    const char*,     char**, int, int*);
extern  unsigned long long __cdecl _Stoullx(
    const char*,     char**, int, int*);

}

namespace std {

inline double _Stodx_v2(const char* _Str, char** _Endptr, int _Pten, int* _Perr) { 
    int& _Errno_ref = (*_errno()); 
    const int _Orig = _Errno_ref;

    _Errno_ref  = 0;
    double _Val = :: strtod(_Str, _Endptr);
    *_Perr      = _Errno_ref;
    _Errno_ref  = _Orig;

    if (_Pten != 0) {
        _Val *= :: pow(10.0, static_cast<double>(_Pten));
    }

    return _Val;
}

inline float _Stofx_v2(const char* _Str, char** _Endptr, int _Pten, int* _Perr) { 
    int& _Errno_ref = (*_errno()); 
    const int _Orig = _Errno_ref;

    _Errno_ref = 0;
    float _Val = :: strtof(_Str, _Endptr);
    *_Perr     = _Errno_ref;
    _Errno_ref = _Orig;

    if (_Pten != 0) {
        _Val *= :: powf(10.0f, static_cast<float>(_Pten));
    }

    return _Val;
}

template <class _Elem, size_t _Base_size>
size_t _Find_elem(const _Elem (&_Base)[_Base_size],
    const _Elem _Ch) { 
                       
    return static_cast<size_t>(_Find_unchecked(_Base, _Base + (_Base_size - 1), _Ch) - _Base);
}

inline wchar_t* _Maklocwcs(const wchar_t* _Ptr) { 
    const size_t _Count = :: wcslen(_Ptr) + 1;

    wchar_t* _Ptrdest = static_cast<wchar_t*>(calloc(_Count, sizeof(wchar_t)));

    if (!_Ptrdest) {
        _Xbad_alloc();
    }

    :: wmemcpy(_Ptrdest, _Ptr, _Count);
    return _Ptrdest;
}

template <class _Elem>
class numpunct : public locale::facet { 
private:
    friend _Tidy_guard<numpunct>;

public:
    static_assert(!0 || _Is_any_of_v<_Elem, char, wchar_t, unsigned short>,
        "Unsupported facet specialization; see N4800 27.3.1.1.1 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this diagnostic.");

    using string_type = basic_string<_Elem, char_traits<_Elem>, allocator<_Elem>>;
    using char_type   = _Elem;

      static locale::id id; 

    _Elem decimal_point() const {
        return do_decimal_point();
    }

    _Elem thousands_sep() const {
        return do_thousands_sep();
    }

    string grouping() const {
        return do_grouping();
    }

    string_type falsename() const {
        return do_falsename();
    }

    string_type truename() const {
        return do_truename();
    }

    explicit numpunct(size_t _Refs = 0) : locale::facet(_Refs) { 
        { _Locinfo _Lobj;
        _Init(_Lobj);
        if (_Kseparator == 0) {
            _Kseparator = 
                _Maklocchr(',', static_cast<_Elem*>(nullptr), _Lobj._Getcvt());
        }
        }
    }

    numpunct(const _Locinfo& _Lobj, size_t _Refs = 0, bool _Isdef = false) : locale::facet(_Refs) {
        _Init(_Lobj, _Isdef);
    }

    static size_t _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
        
        if (_Ppf && !*_Ppf) {
            *_Ppf = new numpunct<_Elem>(_Locinfo(_Ploc->c_str()), 0, true);
        }
        return 4;
    }

protected:
     ~numpunct() noexcept override {
        _Tidy();
    }

    numpunct(const char* _Locname, size_t _Refs = 0, bool _Isdef = false) : locale::facet(_Refs) {
        { _Locinfo _Lobj(_Locname);
        _Init(_Lobj, _Isdef);
        }
    }

    template <class _Elem2>
    void _Getvals(_Elem2, const lconv* _Ptr, _Locinfo::_Cvtvec _Cvt) { 
        _Dp         = _Maklocchr(_Ptr->decimal_point[0], static_cast<_Elem2*>(nullptr), _Cvt);
        _Kseparator = _Maklocchr(_Ptr->thousands_sep[0], static_cast<_Elem2*>(nullptr), _Cvt);
    }

    void _Getvals(wchar_t, const lconv* _Ptr, _Locinfo::_Cvtvec) { 
        _Dp         = static_cast<_Elem>(_Ptr->_W_decimal_point[0]);
        _Kseparator = static_cast<_Elem>(_Ptr->_W_thousands_sep[0]);
    }

    void _Init(const _Locinfo& _Lobj, bool _Isdef = false) { 
        const lconv* _Ptr      = _Lobj._Getlconv();
        _Locinfo::_Cvtvec _Cvt = _Lobj._Getcvt(); 

        _Grouping  = nullptr;
        _Falsename = nullptr;
        _Truename  = nullptr;

        _Tidy_guard<numpunct> _Guard{this};
        _Grouping      = _Maklocstr(_Isdef ? "" : _Ptr->grouping, static_cast<char*>(nullptr), _Lobj._Getcvt());
        _Falsename     = _Maklocstr(_Lobj._Getfalse(), static_cast<_Elem*>(nullptr), _Cvt);
        _Truename      = _Maklocstr(_Lobj._Gettrue(), static_cast<_Elem*>(nullptr), _Cvt);
        _Guard._Target = nullptr;

        if (_Isdef) { 
            
            _Dp         = _Maklocchr('.', static_cast<_Elem*>(nullptr), _Cvt);
            _Kseparator = _Maklocchr(',', static_cast<_Elem*>(nullptr), _Cvt);
        } else {
            _Getvals(_Elem{}, _Ptr, _Cvt);
        }
    }

    virtual _Elem  do_decimal_point() const {
        return _Dp;
    }

    virtual _Elem  do_thousands_sep() const {
        return _Kseparator;
    }

    virtual string  do_grouping() const {
        return string(_Grouping);
    }

    virtual string_type  do_falsename() const {
        return string_type(_Falsename);
    }

    virtual string_type  do_truename() const {
        return string_type(_Truename);
    }

private:
    void _Tidy() noexcept { 
        :: free(const_cast<char*>(_Grouping));
        :: free(const_cast<_Elem*>(_Falsename));
        :: free(const_cast<_Elem*>(_Truename));
    }

    const char* _Grouping; 
    _Elem _Dp; 
    _Elem _Kseparator; 
    const _Elem* _Falsename; 
    const _Elem* _Truename; 
};

template <class _Elem>
class numpunct_byname : public numpunct<_Elem> { 
public:
    static_assert(!0 || _Is_any_of_v<_Elem, char, wchar_t>, "Unsupported facet specialization; see N4800 27.3.1.1.1 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this diagnostic.");

    explicit numpunct_byname(const char* _Locname, size_t _Refs = 0)
        : numpunct<_Elem>(_Locname, _Refs) {} 

    explicit numpunct_byname(const string& _Str, size_t _Refs = 0)
        : numpunct<_Elem>(_Str.c_str(), _Refs) {} 

protected:
     ~numpunct_byname() noexcept override {}
};


template <class _Elem>
 locale::id numpunct<_Elem>::id;


#line 261 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocnum"

template <class _Elem, class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem>>>
class num_get : public locale::facet { 
public:
    static_assert(!0 || _Is_any_of_v<_Elem, char, wchar_t, unsigned short>,
        "Unsupported facet specialization; see N4800 27.3.1.1.1 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this diagnostic.");

    static size_t __cdecl _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
        
        if (_Ppf && !*_Ppf) {
            *_Ppf = new num_get<_Elem, _InIt>(_Locinfo(_Ploc->c_str()));
        }

        return 4;
    }

     static locale::id id; 

protected:
     ~num_get() noexcept override {}

    void _Init(const _Locinfo&) {} 

public:
    explicit  num_get(size_t _Refs = 0) : locale::facet(_Refs) { 
        { _Locinfo _Lobj;
        _Init(_Lobj);
        }
    }

     num_get(const _Locinfo& _Lobj, size_t _Refs = 0) : locale::facet(_Refs) {
        _Init(_Lobj);
    }

    using char_type = _Elem;
    using iter_type = _InIt;

    _InIt  get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
        bool& _Val) const { 
        return do_get(_First, _Last, _Iosbase, _State, _Val);
    }

    _InIt  get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
        unsigned short& _Val) const { 
        return do_get(_First, _Last, _Iosbase, _State, _Val);
    }

    _InIt  get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
        unsigned int& _Val) const { 
        return do_get(_First, _Last, _Iosbase, _State, _Val);
    }

    _InIt  get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
        long& _Val) const { 
        return do_get(_First, _Last, _Iosbase, _State, _Val);
    }

    _InIt  get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
        unsigned long& _Val) const { 
        return do_get(_First, _Last, _Iosbase, _State, _Val);
    }

    _InIt  get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
        long long& _Val) const { 
        return do_get(_First, _Last, _Iosbase, _State, _Val);
    }

    _InIt  get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
        unsigned long long& _Val) const { 
        return do_get(_First, _Last, _Iosbase, _State, _Val);
    }

    _InIt  get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
        float& _Val) const { 
        return do_get(_First, _Last, _Iosbase, _State, _Val);
    }

    _InIt  get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
        double& _Val) const { 
        return do_get(_First, _Last, _Iosbase, _State, _Val);
    }

    _InIt  get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
        long double& _Val) const { 
        return do_get(_First, _Last, _Iosbase, _State, _Val);
    }

    _InIt  get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
        void*& _Val) const { 
        return do_get(_First, _Last, _Iosbase, _State, _Val);
    }

protected:
    virtual _InIt  do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
        bool& _Val) const { 
        _Adl_verify_range(_First, _Last);
        if (_Iosbase.flags() & ios_base::boolalpha) { 
            const auto& _Punct_fac = ::std:: use_facet<numpunct<_Elem>>(_Iosbase.getloc());
            basic_string<_Elem> _Str(static_cast<size_t>(1), _Elem{});
            _Str += _Punct_fac.falsename();
            _Str.push_back(_Elem{});
            _Str += _Punct_fac.truename(); 
            switch (_Getloctxt(_First, _Last, 2, _Str.c_str(), _Case_sensitive::_Yes)) {
            case 0:
                _Val = false;
                break;
            case 1:
                _Val = true;
                break;
            default:
                _Val   = false;
                _State = ios_base::failbit;
                break;
            }
        } else { 
            char _Ac[32];
            const int _Base = _Getifld(_Ac, _First, _Last, _Iosbase.flags(), _Iosbase.getloc()); 
            if (_Ac[0] == '\0') { 
                                  
                                  
                _Val   = false;
                _State = ios_base::failbit;
            } else {
                char* _Ep;
                int _Errno;
                const long _Ans = :: _Stolx(_Ac, &_Ep, _Base, &_Errno); 
                if (_Ep == _Ac || _Errno != 0) {
                    _Val   = true;
                    _State = ios_base::failbit;
                } else {
                    _Val = _Ans != 0;
                    if (_Ans != 0 && _Ans != 1) {
                        _State = ios_base::failbit;
                    }
                }
            }
        }

        if (_First == _Last) {
            _State |= ios_base::eofbit;
        }

        return _First;
    }

    virtual _InIt  do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
        unsigned short& _Val) const { 
        _Adl_verify_range(_First, _Last);
        char _Ac[32];
        const int _Base = _Getifld(_Ac, _First, _Last, _Iosbase.flags(), _Iosbase.getloc()); 
        if (_Ac[0] == '\0') { 
            _State = ios_base::failbit;
            _Val   = 0;
        } else {
            const bool _Minus   = _Ac[0] == '-';
            const char* _Digits = _Ac;
            
            
            if (_Minus) { 
                ++_Digits;
            }

            char* _Ep;
            int _Errno;
            const unsigned long _Tmp = :: _Stoulx(_Digits, &_Ep, _Base, &_Errno); 
            _Val                     = static_cast<unsigned short>(_Tmp);
            if (_Ep == _Digits || _Errno != 0 || _Tmp > 0xffff) {
                _State = ios_base::failbit;
                _Val   = 0xffff;
            } else if (_Minus) { 
                                 
                _Val = static_cast<unsigned short>(0 - _Val);
            }
        }

        if (_First == _Last) {
            _State |= ios_base::eofbit;
        }

        return _First;
    }

    virtual _InIt  do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
        unsigned int& _Val) const { 
        static_assert(sizeof(unsigned int) == sizeof(unsigned long),
            "Bad overflow assumptions due to sizeof(unsigned int) != sizeof(unsigned long)");
        unsigned long _Tmp;
        _First = num_get::do_get(_First, _Last, _Iosbase, _State, _Tmp); 
        _Val   = _Tmp;
        return _First;
    }

    virtual _InIt  do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
        long& _Val) const { 
        _Adl_verify_range(_First, _Last);
        char _Ac[32];
        const int _Base = _Getifld(_Ac, _First, _Last, _Iosbase.flags(), _Iosbase.getloc()); 
        if (_Ac[0] == '\0') { 
            _State = ios_base::failbit;
            _Val   = 0;
        } else {
            char* _Ep;
            int _Errno;
            _Val = :: _Stolx(_Ac, &_Ep, _Base, &_Errno); 
            if (_Ep == _Ac || _Errno != 0) {
                _State = ios_base::failbit;
            }
        }

        if (_First == _Last) {
            _State |= ios_base::eofbit;
        }

        return _First;
    }

    virtual _InIt  do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
        unsigned long& _Val) const { 
        _Adl_verify_range(_First, _Last);
        char _Ac[32];
        const int _Base = _Getifld(_Ac, _First, _Last, _Iosbase.flags(), _Iosbase.getloc()); 
        if (_Ac[0] == '\0') { 
            _State = ios_base::failbit;
            _Val   = 0;
        } else {
            char* _Ep;
            int _Errno;
            _Val = :: _Stoulx(_Ac, &_Ep, _Base, &_Errno); 
            if (_Ep == _Ac || _Errno != 0) {
                _State = ios_base::failbit;
            }
        }

        if (_First == _Last) {
            _State |= ios_base::eofbit;
        }

        return _First;
    }

    virtual _InIt  do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
        long long& _Val) const { 
        _Adl_verify_range(_First, _Last);
        char _Ac[32];
        const int _Base = _Getifld(_Ac, _First, _Last, _Iosbase.flags(), _Iosbase.getloc());
        if (_Ac[0] == '\0') { 
            _State = ios_base::failbit;
            _Val   = 0;
        } else {
            char* _Ep;
            int _Errno;
            _Val = :: _Stollx(_Ac, &_Ep, _Base, &_Errno); 
            if (_Ep == _Ac || _Errno != 0) {
                _State = ios_base::failbit;
            }
        }

        if (_First == _Last) {
            _State |= ios_base::eofbit;
        }

        return _First;
    }

    virtual _InIt  do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
        unsigned long long& _Val) const { 
        _Adl_verify_range(_First, _Last);
        char _Ac[32];
        const int _Base = _Getifld(_Ac, _First, _Last, _Iosbase.flags(), _Iosbase.getloc());
        if (_Ac[0] == '\0') { 
            _State = ios_base::failbit;
            _Val   = 0;
        } else {
            int _Errno;
            char* _Ep;
            _Val = :: _Stoullx(_Ac, &_Ep, _Base, &_Errno); 
            if (_Ep == _Ac || _Errno != 0) {
                _State = ios_base::failbit;
            }
        }

        if (_First == _Last) {
            _State |= ios_base::eofbit;
        }

        return _First;
    }


    virtual _InIt  do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
        float& _Val) const { 
        _Adl_verify_range(_First, _Last);
        char _Ac[(8 + 768 + 16)];
        int _Hexexp     = 1000000000;
        const int _Base = _Getffld(_Ac, _First, _Last, _Iosbase, &_Hexexp); 
        if (_Ac[0] == '\0') { 
            _State = ios_base::failbit;
            _Val   = 0.0f;
        } else {
            int _Errno;
            char* _Ep;
            _Val = _Stofx_v2(_Ac, &_Ep, _Base, &_Errno); 
            if (_Ep == _Ac || _Errno != 0) {
                _State = ios_base::failbit;
                _Val   = 0.0f;
            } else if (_Hexexp != 1000000000 && _Hexexp != 0) {
                _Val = :: ldexpf(_Val, 4 * _Hexexp);
            }
        }

        if (_First == _Last) {
            _State |= ios_base::eofbit;
        }

        return _First;
    }

    virtual _InIt  do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
        double& _Val) const { 
        _Adl_verify_range(_First, _Last);
        char _Ac[(8 + 768 + 16)];
        int _Hexexp     = 1000000000;
        const int _Base = _Getffld(_Ac, _First, _Last, _Iosbase, &_Hexexp); 
        if (_Ac[0] == '\0') { 
            _State = ios_base::failbit;
            _Val   = 0.0;
        } else {
            int _Errno;
            char* _Ep;
            _Val = _Stodx_v2(_Ac, &_Ep, _Base, &_Errno); 
            if (_Ep == _Ac || _Errno != 0) {
                _State = ios_base::failbit;
                _Val   = 0.0;
            } else if (_Hexexp != 1000000000 && _Hexexp != 0) {
                _Val = :: ldexp(_Val, 4 * _Hexexp);
            }
        }

        if (_First == _Last) {
            _State |= ios_base::eofbit;
        }

        return _First;
    }


    virtual _InIt  do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
        long double& _Val) const { 
        static_assert(sizeof(double) == sizeof(long double), "Bad assumption: sizeof(double) == sizeof(long double).");
        double _Result;
        _First = num_get::do_get(_First, _Last, _Iosbase, _State, _Result); 
        _Val   = _Result;
        return _First;
    }

    virtual _InIt  do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
        void*& _Val) const { 
        _Adl_verify_range(_First, _Last);
        char _Ac[32];
        const int _Base = _Getifld(_Ac, _First, _Last, ios_base::hex, _Iosbase.getloc()); 
        if (_Ac[0] == '\0') { 
            _State = ios_base::failbit;
            _Val   = nullptr;
        } else {
            int _Errno;
            char* _Ep;


            _Val = reinterpret_cast<void*>(:: _Stoulx(_Ac, &_Ep, _Base, &_Errno));
#line 641 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocnum"
            if (_Ep == _Ac || _Errno != 0) {
                _State = ios_base::failbit;
                _Val   = nullptr;
            }
        }

        if (_First == _Last) {
            _State |= ios_base::eofbit;
        }

        return _First;
    }

private:
    int __cdecl _Getifld(char* _Ac, _InIt& _First, _InIt& _Last, ios_base::fmtflags _Basefield,
        const locale& _Loc) const { 
        const auto& _Punct_fac  = ::std:: use_facet<numpunct<_Elem>>(_Loc);
        const string _Grouping  = _Punct_fac.grouping();
        const _Elem _Kseparator = _Grouping.empty() ? _Elem{} : _Punct_fac.thousands_sep();

        constexpr int _Numget_signoff = 22;
        constexpr int _Numget_xoff    = 24;
        static constexpr char _Src[]  = "0123456789ABCDEFabcdef-+Xx";
        _Elem _Atoms[sizeof(_Src)];
        const ctype<_Elem>& _Ctype_fac = ::std:: use_facet<ctype<_Elem>>(_Loc);
        _Ctype_fac.widen(::std:: begin(_Src), ::std:: end(_Src), _Atoms);

        char* _Ptr = _Ac;

        if (_First != _Last) {
            if (*_First == _Atoms[_Numget_signoff + 1]) { 
                *_Ptr++ = '+';
                ++_First;
            } else if (*_First == _Atoms[_Numget_signoff]) { 
                *_Ptr++ = '-';
                ++_First;
            }
        }

        _Basefield &= ios_base::basefield;

        int _Base;
        if (_Basefield == ios_base::oct) {
            _Base = 8;
        } else if (_Basefield == ios_base::hex) {
            _Base = 16;
        } else if (_Basefield == ios_base::_Fmtzero) {
            _Base = 0;
        } else {
            _Base = 10;
        }

        bool _Seendigit = false; 
        bool _Nonzero   = false; 

        if (_First != _Last && *_First == _Atoms[0]) { 
            _Seendigit = true;
            ++_First;
            if (_First != _Last && (*_First == _Atoms[_Numget_xoff + 1] || *_First == _Atoms[_Numget_xoff])
                && (_Base == 0 || _Base == 16)) {
                _Base      = 16;
                _Seendigit = false;
                ++_First;
            } else if (_Base == 0) {
                _Base = 8;
            }
        }

        const auto _Dlen = static_cast<size_t>(_Base == 0 || _Base == 10 ? 10 : _Base == 8 ? 8 : 16 + 6);
        string _Groups(1, static_cast<char>(_Seendigit));
        size_t _Group = 0;

        for (char* const _Pe = &_Ac[32 - 1]; _First != _Last; ++_First) { 
            size_t _Idx = _Find_elem(_Atoms, *_First);
            if (_Idx < _Dlen) { 
                *_Ptr = _Src[_Idx];
                if ((_Nonzero || *_Ptr != '0') && _Ptr < _Pe) {
                    ++_Ptr;
                    _Nonzero = true;
                }

                _Seendigit = true;
                if (_Groups[_Group] != 127) {
                    ++_Groups[_Group];
                }
            } else if (_Groups[_Group] == '\0' || _Kseparator == _Elem{} || *_First != _Kseparator) {
                break; 
            } else { 
                _Groups.push_back('\0');
                ++_Group;
            }
        }

        if (_Group != 0) {
            if ('\0' < _Groups[_Group]) {
                ++_Group; 
            } else {
                _Seendigit = false; 
            }
        }

        for (const char* _Pg = &_Grouping[0]; _Seendigit && 0 < _Group;) {
            if (*_Pg == 127) {
                break; 
            } else if ((0 < --_Group && *_Pg != _Groups[_Group]) || (0 == _Group && *_Pg < _Groups[_Group])) {
                _Seendigit = false; 
            } else if ('\0' < _Pg[1]) {
                ++_Pg; 
            }
        }

        if (_Seendigit && !_Nonzero) {
            *_Ptr++ = '0'; 
        } else if (!_Seendigit) {
            _Ptr = _Ac; 
        }

        *_Ptr = '\0';
        return _Base;
    }

    int __cdecl _Getffld(char* _Ac, _InIt& _First, _InIt& _Last, ios_base& _Iosbase,
        int* _Phexexp) const { 
        if ((_Iosbase.flags() & ios_base::floatfield) == ios_base::hexfloat) {
            return _Getffldx(_Ac, _First, _Last, _Iosbase, _Phexexp); 
        }

        const auto& _Punct_fac = ::std:: use_facet<numpunct<_Elem>>(_Iosbase.getloc());
        const string _Grouping = _Punct_fac.grouping();
        char* _Ptr             = _Ac;
        bool _Bad              = false;
        bool _Sticky           = false;

        constexpr int _Numget_signoff = 10;
        constexpr int _Numget_eoff    = 12;
        static constexpr char _Src[]  = "0123456789-+Ee";
        _Elem _Atoms[sizeof(_Src)];
        const ctype<_Elem>& _Ctype_fac = ::std:: use_facet<ctype<_Elem>>(_Iosbase.getloc());
        _Ctype_fac.widen(::std:: begin(_Src), ::std:: end(_Src), _Atoms);

        if (_First != _Last) {
            if (*_First == _Atoms[_Numget_signoff + 1]) { 
                *_Ptr++ = '+';
                ++_First;
            } else if (*_First == _Atoms[_Numget_signoff]) { 
                *_Ptr++ = '-';
                ++_First;
            }
        }

        char* _Leading = _Ptr; 
        *_Ptr++        = '0'; 

        bool _Seendigit  = false; 
        int _Significant = 0; 
        int _Pten        = 0; 
        size_t _Idx;

        const int _Max_sig_dig = (*_Phexexp == 1000000000 ? 768 : 36);

        const char* _Pg = &_Grouping[0];
        if (*_Pg == 127 || *_Pg <= '\0') {
            for (; _First != _Last && (_Idx = _Find_elem(_Atoms, *_First)) < 10; _Seendigit = true, (void) ++_First) {
                if (_Max_sig_dig <= _Significant) { 
                    ++_Pten;
                    if (0 < _Idx) {
                        _Sticky = true;
                    }
                } else if (_Idx != 0 || _Significant != 0) { 
                    *_Ptr++ = _Src[_Idx];
                    ++_Significant;
                }
            }
        } else { 
            const _Elem _Kseparator = _Grouping.empty() ? _Elem{} : _Punct_fac.thousands_sep();
            string _Groups(1, '\0');
            size_t _Group = 0;

            for (; _First != _Last; ++_First) {
                if ((_Idx = _Find_elem(_Atoms, *_First)) < 10) { 
                    _Seendigit = true;
                    if (_Max_sig_dig <= _Significant) { 
                        ++_Pten;
                        if (0 < _Idx) {
                            _Sticky = true;
                        }
                    } else if (_Idx != 0 || _Significant != 0) { 
                        *_Ptr++ = _Src[_Idx];
                        ++_Significant;
                    }

                    if (_Groups[_Group] != 127) {
                        ++_Groups[_Group];
                    }
                } else if (_Groups[_Group] == '\0' || _Kseparator == _Elem{} || *_First != _Kseparator) {
                    break; 
                } else { 
                    _Groups.push_back('\0');
                    ++_Group;
                }
            }

            if (_Group != 0) {
                if ('\0' < _Groups[_Group]) {
                    ++_Group; 
                } else {
                    _Bad = true; 
                }
            }

            while (!_Bad && 0 < _Group) {
                if (*_Pg == 127) {
                    break; 
                }

                if ((0 < --_Group && *_Pg != _Groups[_Group]) || (0 == _Group && *_Pg < _Groups[_Group])) {
                    _Bad = true; 
                } else if ('\0' < _Pg[1]) {
                    ++_Pg; 
                }
            }
        }

        if (_First != _Last && *_First == _Punct_fac.decimal_point()) { 
            *_Ptr++ = localeconv()->decimal_point[0];
            ++_First;
        }

        if (*_Phexexp != 1000000000 && _Significant == 0) { 
            for (; _First != _Last && *_First == _Atoms[0]; _Seendigit = true, (void) ++_First) {
                --_Pten; 
            }

            if (_Pten < 0) { 
                *_Ptr++ = '0';
                ++_Pten;
            }
        }

        for (; _First != _Last && (_Idx = _Find_elem(_Atoms, *_First)) < 10; _Seendigit = true, (void) ++_First) {
            if (_Significant < _Max_sig_dig) { 
                *_Ptr++ = _Src[_Idx];
                ++_Significant;
            } else if (0 < _Idx) {
                _Sticky = true; 
            }
        }

        if (_Sticky) { 
            char* _Px = _Ptr;
            while (--_Px != _Leading) { 
                if (*_Px != localeconv()->decimal_point[0]) { 
                    if (*_Px != '9') { 
                        ++*_Px;
                        break;
                    }

                    *_Px = '0'; 
                }
            }

            if (_Px == _Leading) { 
                *_Px = '1';
                ++_Pten;
            }
        }

        if (_Seendigit && _First != _Last
            && (*_First == _Atoms[_Numget_eoff + 1]
                || *_First == _Atoms[_Numget_eoff])) { 
            *_Ptr++ = 'e';
            ++_First;
            _Seendigit   = false;
            _Significant = 0;

            if (_First != _Last) {
                if (*_First == _Atoms[_Numget_signoff + 1]) { 
                    *_Ptr++ = '+';
                    ++_First;
                } else if (*_First == _Atoms[_Numget_signoff]) { 
                    *_Ptr++ = '-';
                    ++_First;
                }
            }

            for (; _First != _Last && *_First == _Atoms[0]; ++_First) { 
                _Seendigit = true;
            }

            if (_Seendigit) {
                *_Ptr++ = '0'; 
            }

            for (; _First != _Last && (_Idx = _Find_elem(_Atoms, *_First)) < 10; _Seendigit = true, (void) ++_First) {
                if (_Significant < 8) { 
                    *_Ptr++ = _Src[_Idx];
                    ++_Significant;
                }
            }
        }

        if (_Bad || !_Seendigit) {
            _Ptr = _Ac; 
        }

        *_Ptr = '\0';
        return _Pten;
    }

    int __cdecl _Getffldx(char* _Ac, _InIt& _First, _InIt& _Last, ios_base& _Iosbase,
        int* _Phexexp) const { 
        const auto& _Punct_fac = ::std:: use_facet<numpunct<_Elem>>(_Iosbase.getloc());
        const string _Grouping = _Punct_fac.grouping();

        constexpr int _Numget_signoff = 22;
        constexpr int _Numget_xoff    = 24;
        constexpr int _Numget_poff    = 26;
        static constexpr char _Src[]  = "0123456789ABCDEFabcdef-+XxPp";
        _Elem _Atoms[sizeof(_Src)];
        const ctype<_Elem>& _Ctype_fac = ::std:: use_facet<ctype<_Elem>>(_Iosbase.getloc());
        _Ctype_fac.widen(::std:: begin(_Src), ::std:: end(_Src), _Atoms);

        char* _Ptr = _Ac;
        bool _Bad  = false;
        size_t _Idx;

        if (_First != _Last) {
            if (*_First == _Atoms[_Numget_signoff + 1]) { 
                *_Ptr++ = '+';
                ++_First;
            } else if (*_First == _Atoms[_Numget_signoff]) { 
                *_Ptr++ = '-';
                ++_First;
            }
        }

        *_Ptr++ = '0';
        *_Ptr++ = 'x';

        bool _Seendigit  = false; 
        int _Significant = 0; 
        int _Phex        = 0; 

        if (_First != _Last && *_First == _Atoms[0]) {
            if (++_First != _Last && (*_First == _Atoms[_Numget_xoff + 1] || *_First == _Atoms[_Numget_xoff])) {
                ++_First; 
            } else {
                _Seendigit = true; 
            }
        }

        const int _Max_sig_dig = (*_Phexexp == 1000000000 ? 768 : 36);

        const char* _Pg = &_Grouping[0];
        if (*_Pg == 127 || *_Pg <= '\0') {
            for (; _First != _Last && (_Idx = _Find_elem(_Atoms, *_First)) < _Numget_signoff;
                 _Seendigit = true, (void) ++_First) {
                if (_Max_sig_dig <= _Significant) {
                    ++_Phex; 
                } else if (_Idx != 0 || _Significant != 0) { 
                    *_Ptr++ = _Src[_Idx];
                    ++_Significant;
                }
            }
        } else { 
            const _Elem _Kseparator = _Grouping.empty() ? _Elem{} : _Punct_fac.thousands_sep();
            string _Groups(1, '\0');
            size_t _Group = 0;

            for (; _First != _Last; ++_First) {
                if ((_Idx = _Find_elem(_Atoms, *_First)) < _Numget_signoff) { 
                    _Seendigit = true;
                    if (_Max_sig_dig <= _Significant) {
                        ++_Phex; 
                    } else if (_Idx != 0 || _Significant != 0) { 
                        *_Ptr++ = _Src[_Idx];
                        ++_Significant;
                    }

                    if (_Groups[_Group] != 127) {
                        ++_Groups[_Group];
                    }
                } else if (_Groups[_Group] == '\0' || _Kseparator == _Elem{} || *_First != _Kseparator) {
                    break; 
                } else { 
                    _Groups.push_back('\0');
                    ++_Group;
                }
            }

            if (_Group != 0) {
                if ('\0' < _Groups[_Group]) {
                    ++_Group; 
                } else {
                    _Bad = true; 
                }
            }

            while (!_Bad && 0 < _Group) {
                if (*_Pg == 127) {
                    break; 
                }

                if ((0 < --_Group && *_Pg != _Groups[_Group]) || (0 == _Group && *_Pg < _Groups[_Group])) {
                    _Bad = true; 
                } else if ('\0' < _Pg[1]) {
                    ++_Pg; 
                }
            }
        }

        if (_Seendigit && _Significant == 0) {
            *_Ptr++ = '0'; 
        }

        if (_First != _Last && *_First == _Punct_fac.decimal_point()) { 
            *_Ptr++ = localeconv()->decimal_point[0];
            ++_First;
        }

        if (_Significant == 0) { 
            for (; _First != _Last && *_First == _Atoms[0]; _Seendigit = true, (void) ++_First) {
                --_Phex; 
            }

            if (_Phex < 0) { 
                *_Ptr++ = '0';
                ++_Phex;
            }
        }

        for (; _First != _Last && (_Idx = _Find_elem(_Atoms, *_First)) < _Numget_signoff;
             _Seendigit = true, (void) ++_First) {
            if (_Significant < _Max_sig_dig) { 
                *_Ptr++ = _Src[_Idx];
                ++_Significant;
            }
        }

        if (_Seendigit && _First != _Last
            && (*_First == _Atoms[_Numget_poff + 1]
                || *_First == _Atoms[_Numget_poff])) { 
            *_Ptr++ = 'p';
            ++_First;
            _Seendigit   = false;
            _Significant = 0;

            if (_First != _Last) {
                if (*_First == _Atoms[_Numget_signoff + 1]) { 
                    *_Ptr++ = '+';
                    ++_First;
                } else if (*_First == _Atoms[_Numget_signoff]) { 
                    *_Ptr++ = '-';
                    ++_First;
                }
            }

            for (; _First != _Last && *_First == _Atoms[0]; ++_First) { 
                _Seendigit = true;
            }

            if (_Seendigit) {
                *_Ptr++ = '0'; 
            }

            for (; _First != _Last && (_Idx = _Find_elem(_Atoms, *_First)) < _Numget_signoff;
                 _Seendigit = true, (void) ++_First) {
                if (_Significant < 8) { 
                    *_Ptr++ = _Src[_Idx];
                    ++_Significant;
                }
            }
        }

        if (_Bad || !_Seendigit) {
            _Ptr = _Ac; 
        }

        *_Ptr     = '\0';
        *_Phexexp = _Phex; 
        return 0; 
    }


};


template <class _Elem, class _InIt>
 locale::id num_get<_Elem, _InIt>::id;


template <class _Ty>
struct _Hex_float_precision;

template <>
struct _Hex_float_precision<double> {
    
    static constexpr int value = ((53 - 1) + 3) / 4;
};

template <>
struct _Hex_float_precision<long double> {
    
    static constexpr int value = ((53 - 1) + 3) / 4;
};

template <class _Ty>
int _Float_put_desired_precision(const streamsize _Precision, const ios_base::fmtflags _Float_flags) {
    const bool _Is_hex = _Float_flags == (ios_base::fixed | ios_base::scientific);
    if (_Is_hex) {
        return _Hex_float_precision<_Ty>::value;
    }

    if (_Precision > 0) {
        return static_cast<int>(_Precision);
    } else if (_Precision == 0) {
        const bool _Is_default_float = _Float_flags == 0;
        if (_Is_default_float) {
            return 1;
        } else {
            return 0;
        }
    } else {
        constexpr int _Default_precision = 6;
        return _Default_precision;
    }
}

template <class _Elem, class _OutIt = ostreambuf_iterator<_Elem, char_traits<_Elem>>>
class num_put : public locale::facet { 
public:
    static_assert(!0 || _Is_any_of_v<_Elem, char, wchar_t, unsigned short>,
        "Unsupported facet specialization; see N4800 27.3.1.1.1 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this diagnostic.");

    static size_t __cdecl _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
        
        if (_Ppf && !*_Ppf) {
            *_Ppf = new num_put<_Elem, _OutIt>(_Locinfo(_Ploc->c_str()));
        }

        return 4;
    }

     static locale::id id; 

protected:
     ~num_put() noexcept override {}

    void  _Init(const _Locinfo&) {} 

public:
    explicit  num_put(size_t _Refs = 0) : locale::facet(_Refs) { 
        { _Locinfo _Lobj;
        _Init(_Lobj);
        }
    }

     num_put(const _Locinfo& _Lobj, size_t _Refs = 0) : locale::facet(_Refs) {
        _Init(_Lobj);
    }

    using char_type = _Elem;
    using iter_type = _OutIt;

    _OutIt  put(
        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, bool _Val) const { 
        return do_put(_Dest, _Iosbase, _Fill, _Val);
    }

    _OutIt  put(
        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, long _Val) const { 
        return do_put(_Dest, _Iosbase, _Fill, _Val);
    }

    _OutIt  put(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill,
        unsigned long _Val) const { 
        return do_put(_Dest, _Iosbase, _Fill, _Val);
    }

    _OutIt  put(
        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, long long _Val) const { 
        return do_put(_Dest, _Iosbase, _Fill, _Val);
    }

    _OutIt  put(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill,
        unsigned long long _Val) const { 
        return do_put(_Dest, _Iosbase, _Fill, _Val);
    }

    _OutIt  put(
        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, double _Val) const { 
        return do_put(_Dest, _Iosbase, _Fill, _Val);
    }

    _OutIt  put(
        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, long double _Val) const { 
        return do_put(_Dest, _Iosbase, _Fill, _Val);
    }

    _OutIt  put(
        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, const void* _Val) const { 
        return do_put(_Dest, _Iosbase, _Fill, _Val);
    }

protected:
    virtual _OutIt  do_put(
        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, bool _Val) const { 
        if (!(_Iosbase.flags() & ios_base::boolalpha)) {
            return do_put(_Dest, _Iosbase, _Fill, static_cast<long>(_Val));
        } else { 
            const auto& _Punct_fac = ::std:: use_facet<numpunct<_Elem>>(_Iosbase.getloc());
            basic_string<_Elem> _Str;
            if (_Val) {
                _Str.assign(_Punct_fac.truename());
            } else {
                _Str.assign(_Punct_fac.falsename());
            }

            size_t _Fillcount;
            if (_Iosbase.width() <= 0 || static_cast<size_t>(_Iosbase.width()) <= _Str.size()) {
                _Fillcount = 0;
            } else {
                _Fillcount = static_cast<size_t>(_Iosbase.width()) - _Str.size();
            }

            if ((_Iosbase.flags() & ios_base::adjustfield) != ios_base::left) { 
                _Dest      = _Rep(_Dest, _Fill, _Fillcount);
                _Fillcount = 0;
            }
            _Dest = _Put(_Dest, _Str.c_str(), _Str.size()); 
            _Iosbase.width(0);
            return _Rep(_Dest, _Fill, _Fillcount); 
        }
    }

#pragma warning(push)
#pragma warning(disable : 4774) 
    virtual _OutIt  do_put(
        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, long _Val) const { 
        char _Buf[2 * 32];
        char _Fmt[6];

        return _Iput(_Dest, _Iosbase, _Fill, _Buf,
            static_cast<size_t>(:: sprintf_s(_Buf, sizeof(_Buf), _Ifmt(_Fmt, "ld", _Iosbase.flags()), _Val)));
    }

    virtual _OutIt  do_put(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill,
        unsigned long _Val) const { 
        char _Buf[2 * 32];
        char _Fmt[6];

        return _Iput(_Dest, _Iosbase, _Fill, _Buf,
            static_cast<size_t>(:: sprintf_s(_Buf, sizeof(_Buf), _Ifmt(_Fmt, "lu", _Iosbase.flags()), _Val)));
    }

    virtual _OutIt  do_put(
        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, long long _Val) const { 
        char _Buf[2 * 32];
        char _Fmt[8];

        return _Iput(_Dest, _Iosbase, _Fill, _Buf,
            static_cast<size_t>(:: sprintf_s(_Buf, sizeof(_Buf), _Ifmt(_Fmt, "Ld", _Iosbase.flags()), _Val)));
    }

    virtual _OutIt  do_put(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill,
        unsigned long long _Val) const { 
        char _Buf[2 * 32];
        char _Fmt[8];

        return _Iput(_Dest, _Iosbase, _Fill, _Buf,
            static_cast<size_t>(:: sprintf_s(_Buf, sizeof(_Buf), _Ifmt(_Fmt, "Lu", _Iosbase.flags()), _Val)));
    }

    virtual _OutIt  do_put(
        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, double _Val) const { 
        string _Buf;
        char _Fmt[8];
        const auto _Float_flags     = _Iosbase.flags() & ios_base::floatfield;
        const bool _Is_fixed        = _Float_flags == ios_base::fixed;
        const bool _Is_hex          = _Float_flags == (ios_base::fixed | ios_base::scientific);
        const streamsize _Precision = _Is_hex ? -1 : _Iosbase.precision(); 
        const int _Desired_precision =
            _Float_put_desired_precision<double>(_Precision, _Float_flags); 
        size_t _Bufsize = static_cast<size_t>(_Desired_precision);
        if (_Is_fixed && 1e10 < :: fabs(_Val)) { 
            int _Ptwo;
            (void) :: frexp(_Val, &_Ptwo);
            _Bufsize += :: abs(_Ptwo) * 30103L / 100000L;
        }

        _Buf.resize(_Bufsize + 50); 
        const auto _Ngen = static_cast<size_t>(:: sprintf_s(
            &_Buf[0], _Buf.size(), _Ffmt(_Fmt, 0, _Iosbase.flags()), static_cast<int>(_Precision), _Val));

        return _Fput(_Dest, _Iosbase, _Fill, _Buf.c_str(), _Ngen);
    }

    virtual _OutIt  do_put(
        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, long double _Val) const { 
        string _Buf;
        char _Fmt[8];
        const auto _Float_flags     = _Iosbase.flags() & ios_base::floatfield;
        const bool _Is_fixed        = _Float_flags == ios_base::fixed;
        const bool _Is_hex          = _Float_flags == (ios_base::fixed | ios_base::scientific);
        const streamsize _Precision = _Is_hex ? -1 : _Iosbase.precision(); 
        const int _Desired_precision =
            _Float_put_desired_precision<long double>(_Precision, _Float_flags); 
        size_t _Bufsize = static_cast<size_t>(_Desired_precision);
        if (_Is_fixed && 1e10 < :: fabsl(_Val)) { 
            int _Ptwo;
            (void) :: frexpl(_Val, &_Ptwo);
            _Bufsize += :: abs(_Ptwo) * 30103L / 100000L;
        }

        _Buf.resize(_Bufsize + 50); 
        const auto _Ngen = static_cast<size_t>(:: sprintf_s(
            &_Buf[0], _Buf.size(), _Ffmt(_Fmt, 'L', _Iosbase.flags()), static_cast<int>(_Precision), _Val));

        return _Fput(_Dest, _Iosbase, _Fill, _Buf.c_str(), _Ngen);
    }
#pragma warning(pop)

    virtual _OutIt  do_put(
        _OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, const void* _Val) const { 
        char _Buf[2 * 32];

        return _Iput(
            _Dest, _Iosbase, _Fill, _Buf, static_cast<size_t>(:: sprintf_s(_Buf, sizeof(_Buf), "%p", _Val)));
    }

private:
    char* __cdecl _Ffmt(
        char* _Fmt, char _Spec, ios_base::fmtflags _Flags) const { 
        char* _Ptr = _Fmt;
        *_Ptr++    = '%';

        if (_Flags & ios_base::showpos) {
            *_Ptr++ = '+';
        }

        if (_Flags & ios_base::showpoint) {
            *_Ptr++ = '#';
        }

        *_Ptr++ = '.';
        *_Ptr++ = '*'; 
        if (_Spec != '\0') {
            *_Ptr++ = _Spec; 
        }

        char _Ch; 
        ios_base::fmtflags _Ffl = _Flags & ios_base::floatfield;
        if (_Flags & ios_base::uppercase) {
            if (_Ffl == ios_base::fixed) {
                _Ch = 'f';
            } else if (_Ffl == ios_base::hexfloat) {
                _Ch = 'A'; 
            } else if (_Ffl == ios_base::scientific) {
                _Ch = 'E';
            } else {
                _Ch = 'G';
            }
        } else {
            if (_Ffl == ios_base::fixed) {
                _Ch = 'f';
            } else if (_Ffl == ios_base::hexfloat) {
                _Ch = 'a'; 
            } else if (_Ffl == ios_base::scientific) {
                _Ch = 'e';
            } else {
                _Ch = 'g';
            }
        }
        *_Ptr++ = _Ch;

        *_Ptr = '\0';
        return _Fmt;
    }

    _OutIt __cdecl _Fput(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, const char* _Buf,
        size_t _Count) const { 
        auto _Prefix = static_cast<size_t>(0 < _Count && (*_Buf == '+' || *_Buf == '-'));
        const char* _Exps;
        if ((_Iosbase.flags() & ios_base::floatfield) != ios_base::hexfloat) {
            _Exps = "eE";
        } else { 
            _Exps = "pP";
            if (_Prefix + 2 <= _Count && _Buf[_Prefix] == '0'
                && (_Buf[_Prefix + 1] == 'x' || _Buf[_Prefix + 1] == 'X')) {
                _Prefix += 2;
            }
        }
        const size_t _Eoff = :: strcspn(&_Buf[0], _Exps); 
        char _Dp[2]        = {"."};
        _Dp[0]             = :: localeconv()->decimal_point[0];
        const size_t _Poff = :: strcspn(&_Buf[0], &_Dp[0]); 

        const ctype<_Elem>& _Ctype_fac = ::std:: use_facet<ctype<_Elem>>(_Iosbase.getloc());
        basic_string<_Elem> _Groupstring(_Count, _Elem(0)); 
        _Ctype_fac.widen(_Buf, _Buf + _Count, &_Groupstring[0]);

        const auto& _Punct_fac  = ::std:: use_facet<numpunct<_Elem>>(_Iosbase.getloc());
        const string _Grouping  = _Punct_fac.grouping();
        const _Elem _Kseparator = _Punct_fac.thousands_sep();

        if (_Poff != _Count) {
            _Groupstring[_Poff] = _Punct_fac.decimal_point();
        }

        size_t _Off     = _Poff == _Count ? _Eoff : _Poff;
        const char* _Pg = &_Grouping[0];
        while (*_Pg != 127 && '\0' < *_Pg && static_cast<size_t>(*_Pg) < _Off - _Prefix) {
            
            _Groupstring.insert(_Off -= *_Pg, 1, _Kseparator);
            if ('\0' < _Pg[1]) {
                ++_Pg; 
            }
        }

        _Count = _Groupstring.size();

        size_t _Fillcount;
        if (_Iosbase.width() <= 0 || static_cast<size_t>(_Iosbase.width()) <= _Count) {
            _Fillcount = 0;
        } else {
            _Fillcount = static_cast<size_t>(_Iosbase.width()) - _Count;
        }

        ios_base::fmtflags _Adjustfield = _Iosbase.flags() & ios_base::adjustfield;
        if (_Adjustfield != ios_base::left && _Adjustfield != ios_base::internal) { 
            _Dest      = _Rep(_Dest, _Fill, _Fillcount);
            _Fillcount = 0;
            _Dest      = _Put(_Dest, &_Groupstring[0], _Prefix);
        } else if (_Adjustfield == ios_base::internal) { 
            _Dest      = _Put(_Dest, &_Groupstring[0], _Prefix);
            _Dest      = _Rep(_Dest, _Fill, _Fillcount);
            _Fillcount = 0;
        } else {
            _Dest = _Put(_Dest, &_Groupstring[0], _Prefix);
        }

        _Dest = _Put(_Dest, &_Groupstring[_Prefix], _Count - _Prefix);
        _Iosbase.width(0);
        return _Rep(_Dest, _Fill, _Fillcount); 
    }

    char* __cdecl _Ifmt(
        char* _Fmt, const char* _Spec, ios_base::fmtflags _Flags) const { 
        char* _Ptr = _Fmt;
        *_Ptr++    = '%';

        if (_Flags & ios_base::showpos) {
            *_Ptr++ = '+';
        }

        if (_Flags & ios_base::showbase) {
            *_Ptr++ = '#';
        }

        if (_Spec[0] != 'L') {
            *_Ptr++ = _Spec[0]; 
        } else { 
            *_Ptr++ = 'I';
            *_Ptr++ = '6';
            *_Ptr++ = '4';
        }

        ios_base::fmtflags _Basefield = _Flags & ios_base::basefield;
        *_Ptr++                       = _Basefield == ios_base::oct  ? 'o'
                                      : _Basefield != ios_base::hex  ? _Spec[1] 
                                      : _Flags & ios_base::uppercase ? 'X'
                                                                     : 'x';
        *_Ptr                         = '\0';
        return _Fmt;
    }

    _OutIt __cdecl _Iput(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, char* _Buf,
        size_t _Count) const { 
        auto _Prefix = static_cast<size_t>(0 < _Count && (*_Buf == '+' || *_Buf == '-'));
        if ((_Iosbase.flags() & ios_base::basefield) == ios_base::hex && _Prefix + 2 <= _Count && _Buf[_Prefix] == '0'
            && (_Buf[_Prefix + 1] == 'x' || _Buf[_Prefix + 1] == 'X')) {
            _Prefix += 2;
        }

        const ctype<_Elem>& _Ctype_fac = ::std:: use_facet<ctype<_Elem>>(_Iosbase.getloc());
        basic_string<_Elem> _Groupstring(_Count, _Elem(0)); 
        _Ctype_fac.widen(_Buf, _Buf + _Count, &_Groupstring[0]);

        const auto& _Punct_fac = ::std:: use_facet<numpunct<_Elem>>(_Iosbase.getloc());
        const string _Grouping = _Punct_fac.grouping();
        const char* _Pg        = &_Grouping[0];
        if (*_Pg != 127 && '\0' < *_Pg) { 
            const _Elem _Kseparator = _Punct_fac.thousands_sep();
            while (*_Pg != 127 && '\0' < *_Pg && static_cast<size_t>(*_Pg) < _Count - _Prefix) {
                
                _Count -= *_Pg;
                _Groupstring.insert(_Count, 1, _Kseparator);
                if ('\0' < _Pg[1]) {
                    ++_Pg; 
                }
            }
        }

        _Count = _Groupstring.size();

        size_t _Fillcount;
        if (_Iosbase.width() <= 0 || static_cast<size_t>(_Iosbase.width()) <= _Count) {
            _Fillcount = 0;
        } else {
            _Fillcount = static_cast<size_t>(_Iosbase.width()) - _Count;
        }

        ios_base::fmtflags _Adjustfield = _Iosbase.flags() & ios_base::adjustfield;
        if (_Adjustfield != ios_base::left && _Adjustfield != ios_base::internal) { 
            _Dest      = _Rep(_Dest, _Fill, _Fillcount);
            _Fillcount = 0;
            _Dest      = _Put(_Dest, &_Groupstring[0], _Prefix);
        } else if (_Adjustfield == ios_base::internal) { 
            _Dest      = _Put(_Dest, &_Groupstring[0], _Prefix);
            _Dest      = _Rep(_Dest, _Fill, _Fillcount);
            _Fillcount = 0;
        } else {
            _Dest = _Put(_Dest, &_Groupstring[0], _Prefix);
        }

        _Dest = _Put(_Dest, &_Groupstring[_Prefix], _Count - _Prefix);
        _Iosbase.width(0);
        return _Rep(_Dest, _Fill, _Fillcount); 
    }

    _OutIt __cdecl _Put(
        _OutIt _Dest, const _Elem* _Ptr, size_t _Count) const { 
        for (; 0 < _Count; --_Count, (void) ++_Dest, ++_Ptr) {
            *_Dest = *_Ptr;
        }

        return _Dest;
    }

    _OutIt __cdecl _Rep(_OutIt _Dest, _Elem _Ch, size_t _Count) const { 
        for (; 0 < _Count; --_Count, (void) ++_Dest) {
            *_Dest = _Ch;
        }

        return _Dest;
    }
};


template <class _Elem, class _OutIt>
 locale::id num_put<_Elem, _OutIt>::id;


#line 1624 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocnum"


}


#pragma warning(pop)
#pragma pack(pop)
#line 1634 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocnum"
#line 1635 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocnum"
#line 12 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ios"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
template <class _Elem, class _Traits>
class basic_ios : public ios_base { 
public:
    using _Myos       = basic_ostream<_Elem, _Traits>;
    using _Mysb       = basic_streambuf<_Elem, _Traits>;
    using _Ctype      = ctype<_Elem>;
    using char_type   = _Elem;
    using traits_type = _Traits;
    using int_type    = typename _Traits::int_type;
    using pos_type    = typename _Traits::pos_type;
    using off_type    = typename _Traits::off_type;

    explicit  basic_ios(_Mysb* _Strbuf) {
        init(_Strbuf);
    }

     ~basic_ios() noexcept override {}

    void  clear(iostate _State = goodbit, bool _Reraise = false) {
        
        ios_base::clear(_State | (_Mystrbuf ? ios_base::_Iostate{} : ios_base::badbit), _Reraise);
    }


#line 49 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ios"

    void  setstate(
        iostate _State, bool _Reraise = false) { 
        clear(rdstate() | _State, _Reraise);
    }


#line 60 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ios"

    basic_ios&  copyfmt(const basic_ios& _Right) { 
        _Tiestr = _Right.tie();
        _Fillch = _Right.fill();
        ios_base::copyfmt(_Right);
        return *this;
    }

    _Myos*  tie() const {
        return _Tiestr;
    }

    _Myos*  tie(_Myos* _Newtie) { 
        _Myos* _Oldtie = _Tiestr;
        _Tiestr        = _Newtie;
        return _Oldtie;
    }

    [[nodiscard]] _Mysb*  rdbuf() const {
        return _Mystrbuf;
    }

    _Mysb*  rdbuf(_Mysb* _Strbuf) { 
        _Mysb* _Oldstrbuf = _Mystrbuf;
        _Mystrbuf         = _Strbuf;
        clear();
        return _Oldstrbuf;
    }

    locale  imbue(const locale& _Loc) { 
        locale _Oldlocale = ios_base::imbue(_Loc);
        const auto _Rdbuf = rdbuf();
        if (_Rdbuf) {
            _Rdbuf->pubimbue(_Loc);
        }

        return _Oldlocale;
    }

    _Elem  fill() const {
        return _Fillch;
    }

    _Elem  fill(_Elem _Newfill) { 
        _Elem _Oldfill = _Fillch;
        _Fillch        = _Newfill;
        return _Oldfill;
    }

    char  narrow(_Elem _Ch, char _Dflt = '\0') const { 
        return ::std:: use_facet<_Ctype>(getloc()).narrow(_Ch, _Dflt);
    }

    _Elem  widen(char _Byte) const { 
        return ::std:: use_facet<_Ctype>(getloc()).widen(_Byte);
    }

    void  move(basic_ios& _Right) {
        if (this != ::std:: addressof(_Right)) {
            _Mystrbuf = nullptr;
            _Tiestr   = nullptr;
            this->swap(_Right);
        }
    }

    void  move(basic_ios&& _Right) {
        if (this != ::std:: addressof(_Right)) {
            _Mystrbuf = nullptr;
            _Tiestr   = nullptr;
            this->swap(_Right);
        }
    }

    void  swap(basic_ios& _Right) noexcept { 
        ios_base::swap(_Right);
        ::std:: swap(_Fillch, _Right._Fillch);
        ::std:: swap(_Tiestr, _Right._Tiestr);
    }

    void  set_rdbuf(_Mysb* _Strbuf) { 
        _Mystrbuf = _Strbuf;
    }

protected:
    void  init(_Mysb* _Strbuf = nullptr,
        bool _Isstd                             = false) { 
        _Init(); 
        _Mystrbuf = _Strbuf;
        _Tiestr   = nullptr;
        _Fillch   = widen(' ');

        if (!_Mystrbuf) {
            setstate(badbit);
        }

        if (_Isstd) {
            _Addstd(this); 
        }
    }

     basic_ios() {}

private:
    _Mysb* _Mystrbuf; 
    _Myos* _Tiestr; 
    _Elem _Fillch; 

public:
     basic_ios(const basic_ios&) = delete;
    basic_ios&  operator=(const basic_ios&) = delete;
};


#line 183 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ios"

inline ios_base& __cdecl boolalpha(ios_base& _Iosbase) { 
    _Iosbase.setf(ios_base::boolalpha);
    return _Iosbase;
}

inline ios_base& __cdecl dec(ios_base& _Iosbase) { 
    _Iosbase.setf(ios_base::dec, ios_base::basefield);
    return _Iosbase;
}

inline ios_base& __cdecl defaultfloat(ios_base& _Iosbase) { 
    _Iosbase.unsetf(ios_base::floatfield);
    return _Iosbase;
}

inline ios_base& __cdecl fixed(ios_base& _Iosbase) { 
    _Iosbase.setf(ios_base::fixed, ios_base::floatfield);
    return _Iosbase;
}

inline ios_base& __cdecl hex(ios_base& _Iosbase) { 
    _Iosbase.setf(ios_base::hex, ios_base::basefield);
    return _Iosbase;
}

inline ios_base& __cdecl hexfloat(ios_base& _Iosbase) { 
    _Iosbase.setf(ios_base::hexfloat, ios_base::floatfield);
    return _Iosbase;
}

inline ios_base& __cdecl internal(ios_base& _Iosbase) { 
    _Iosbase.setf(ios_base::internal, ios_base::adjustfield);
    return _Iosbase;
}

inline ios_base& __cdecl left(ios_base& _Iosbase) { 
    _Iosbase.setf(ios_base::left, ios_base::adjustfield);
    return _Iosbase;
}

inline ios_base& __cdecl noboolalpha(ios_base& _Iosbase) { 
    _Iosbase.unsetf(ios_base::boolalpha);
    return _Iosbase;
}

inline ios_base& __cdecl noshowbase(ios_base& _Iosbase) { 
    _Iosbase.unsetf(ios_base::showbase);
    return _Iosbase;
}

inline ios_base& __cdecl noshowpoint(ios_base& _Iosbase) { 
    _Iosbase.unsetf(ios_base::showpoint);
    return _Iosbase;
}

inline ios_base& __cdecl noshowpos(ios_base& _Iosbase) { 
    _Iosbase.unsetf(ios_base::showpos);
    return _Iosbase;
}

inline ios_base& __cdecl noskipws(ios_base& _Iosbase) { 
    _Iosbase.unsetf(ios_base::skipws);
    return _Iosbase;
}

inline ios_base& __cdecl nounitbuf(ios_base& _Iosbase) { 
    _Iosbase.unsetf(ios_base::unitbuf);
    return _Iosbase;
}

inline ios_base& __cdecl nouppercase(ios_base& _Iosbase) { 
    _Iosbase.unsetf(ios_base::uppercase);
    return _Iosbase;
}

inline ios_base& __cdecl oct(ios_base& _Iosbase) { 
    _Iosbase.setf(ios_base::oct, ios_base::basefield);
    return _Iosbase;
}

inline ios_base& __cdecl right(ios_base& _Iosbase) { 
    _Iosbase.setf(ios_base::right, ios_base::adjustfield);
    return _Iosbase;
}

inline ios_base& __cdecl scientific(ios_base& _Iosbase) { 
    _Iosbase.setf(ios_base::scientific, ios_base::floatfield);
    return _Iosbase;
}

inline ios_base& __cdecl showbase(ios_base& _Iosbase) { 
    _Iosbase.setf(ios_base::showbase);
    return _Iosbase;
}

inline ios_base& __cdecl showpoint(ios_base& _Iosbase) { 
    _Iosbase.setf(ios_base::showpoint);
    return _Iosbase;
}

inline ios_base& __cdecl showpos(ios_base& _Iosbase) { 
    _Iosbase.setf(ios_base::showpos);
    return _Iosbase;
}

inline ios_base& __cdecl skipws(ios_base& _Iosbase) { 
    _Iosbase.setf(ios_base::skipws);
    return _Iosbase;
}

inline ios_base& __cdecl unitbuf(ios_base& _Iosbase) { 
    _Iosbase.setf(ios_base::unitbuf);
    return _Iosbase;
}

inline ios_base& __cdecl uppercase(ios_base& _Iosbase) { 
    _Iosbase.setf(ios_base::uppercase);
    return _Iosbase;
}


#line 309 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ios"

}


#pragma warning(pop)
#pragma pack(pop)
#line 317 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ios"
#line 318 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ios"
#line 12 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ostream"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
#pragma vtordisp(push, 2) 

template <class _Elem, class _Traits>
class basic_ostream : virtual public basic_ios<_Elem, _Traits> { 
public:
    using _Myios = basic_ios<_Elem, _Traits>;
    using _Mysb  = basic_streambuf<_Elem, _Traits>;
    using _Iter  = ostreambuf_iterator<_Elem, _Traits>;
    using _Nput  = num_put<_Elem, _Iter>;

    explicit  basic_ostream(basic_streambuf<_Elem, _Traits>* _Strbuf, bool _Isstd = false) {
        _Myios::init(_Strbuf, _Isstd);
    }

     basic_ostream(_Uninitialized, bool _Addit = true) {
        if (_Addit) {
            this->_Addstd(this); 
        }
    }

protected:
     basic_ostream(basic_ostream&& _Right) {
        _Myios::init();
        _Myios::move(::std:: move(_Right));
    }

    basic_ostream&  operator=(basic_ostream&& _Right) {
        this->swap(_Right);
        return *this;
    }

    void  swap(basic_ostream& _Right) {
        if (this != ::std:: addressof(_Right)) {
            _Myios::swap(_Right);
        }
    }

public:
     basic_ostream(const basic_ostream&) = delete;
    basic_ostream&  operator=(const basic_ostream&) = delete;

     ~basic_ostream() noexcept override {}

    using int_type = typename _Traits::int_type;
    using pos_type = typename _Traits::pos_type;
    using off_type = typename _Traits::off_type;

    class _Sentry_base { 
    public:
         _Sentry_base(basic_ostream& _Ostr) : _Myostr(_Ostr) { 
            const auto _Rdbuf = _Myostr.rdbuf();
            if (_Rdbuf) {
                _Rdbuf->_Lock();
            }
        }

         ~_Sentry_base() noexcept { 
            const auto _Rdbuf = _Myostr.rdbuf();
            if (_Rdbuf) {
                _Rdbuf->_Unlock();
            }
        }

        basic_ostream& _Myostr; 

        _Sentry_base& operator=(const _Sentry_base&) = delete;
    };

    class sentry : public _Sentry_base {
    public:
        explicit  sentry(basic_ostream& _Ostr) : _Sentry_base(_Ostr) {
            if (!_Ostr.good()) {
                _Ok = false;
                return;
            }

            const auto _Tied = _Ostr.tie();
            if (!_Tied || _Tied == &_Ostr) {
                _Ok = true;
                return;
            }

            _Tied->flush();
            _Ok = _Ostr.good(); 
        }

        __pragma(warning(push)) __pragma(warning(disable : 4996))
         ~sentry() noexcept {


#line 112 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ostream"

#line 114 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ostream"
            const bool _Zero_uncaught_exceptions = ::std:: uncaught_exceptions() == 0;
#line 116 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ostream"

            if (_Zero_uncaught_exceptions) {
                this->_Myostr._Osfx();
            }
        }
        __pragma(warning(pop))

        explicit  operator bool() const {
            return _Ok;
        }

         sentry(const sentry&) = delete;
        sentry&  operator=(const sentry&) = delete;

    private:
        bool _Ok; 
    };

    
    bool  opfx() { 
        if (!this->good()) {
            return false;
        }

        const auto _Tied = _Myios::tie();
        if (!_Tied || _Myios::tie() == this) {
            return true;
        }

        _Tied->flush();
        return this->good();
    }

    
    void  osfx() { 
        _Osfx();
    }

    void  _Osfx() { 
        try {
        if (this->good() && this->flags() & ios_base::unitbuf) {
            if (_Myios::rdbuf()->pubsync() == -1) { 
                _Myios::setstate(ios_base::badbit);
            }
        }
        } catch (...) {
        }
    }


    basic_ostream&  operator<<(basic_ostream&(__cdecl* _Pfn)(basic_ostream&) ) {
        
        return _Pfn(*this);
    }

    basic_ostream&  operator<<(_Myios&(__cdecl* _Pfn)(_Myios&) ) { 
        _Pfn(*this);
        return *this;
    }

    basic_ostream&  operator<<(ios_base&(__cdecl* _Pfn)(ios_base&) ) { 
        _Pfn(*this);
        return *this;
    }

    basic_ostream&  operator<<(bool _Val) { 
        ios_base::iostate _State = ios_base::goodbit;
        const sentry _Ok(*this);

        if (_Ok) { 
            const _Nput& _Nput_fac = ::std:: use_facet<_Nput>(this->getloc());

            try {
            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this, _Myios::fill(), _Val).failed()) {
                _State |= ios_base::badbit;
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        _Myios::setstate(_State);
        return *this;
    }

    basic_ostream&  operator<<(short _Val) { 
        ios_base::iostate _State = ios_base::goodbit;
        const sentry _Ok(*this);

        if (_Ok) { 
            const _Nput& _Nput_fac  = ::std:: use_facet<_Nput>(this->getloc());
            ios_base::fmtflags _Bfl = this->flags() & ios_base::basefield;

            long _Tmp;
            if (_Bfl == ios_base::oct || _Bfl == ios_base::hex) {
                _Tmp = static_cast<long>(static_cast<unsigned short>(_Val));
            } else {
                _Tmp = static_cast<long>(_Val);
            }

            try {
            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this, _Myios::fill(), _Tmp).failed()) {
                _State |= ios_base::badbit;
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        _Myios::setstate(_State);
        return *this;
    }

    
    basic_ostream&  operator<<(unsigned short _Val) { 
        ios_base::iostate _State = ios_base::goodbit;
        const sentry _Ok(*this);

        if (_Ok) { 
            const _Nput& _Nput_fac = ::std:: use_facet<_Nput>(this->getloc());

            try {
            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this, _Myios::fill(), static_cast<unsigned long>(_Val))
                    .failed()) {
                _State |= ios_base::badbit;
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        _Myios::setstate(_State);
        return *this;
    }

    basic_ostream&  operator<<(int _Val) { 
        ios_base::iostate _State = ios_base::goodbit;
        const sentry _Ok(*this);

        if (_Ok) { 
            const _Nput& _Nput_fac  = ::std:: use_facet<_Nput>(this->getloc());
            ios_base::fmtflags _Bfl = this->flags() & ios_base::basefield;

            long _Tmp;
            if (_Bfl == ios_base::oct || _Bfl == ios_base::hex) {
                _Tmp = static_cast<long>(static_cast<unsigned int>(_Val));
            } else {
                _Tmp = static_cast<long>(_Val);
            }

            try {
            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this, _Myios::fill(), _Tmp).failed()) {
                _State |= ios_base::badbit;
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        _Myios::setstate(_State);
        return *this;
    }

    basic_ostream&  operator<<(unsigned int _Val) { 
        ios_base::iostate _State = ios_base::goodbit;
        const sentry _Ok(*this);

        if (_Ok) { 
            const _Nput& _Nput_fac = ::std:: use_facet<_Nput>(this->getloc());

            try {
            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this, _Myios::fill(), static_cast<unsigned long>(_Val))
                    .failed()) {
                _State |= ios_base::badbit;
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        _Myios::setstate(_State);
        return *this;
    }

    basic_ostream&  operator<<(long _Val) { 
        ios_base::iostate _State = ios_base::goodbit;
        const sentry _Ok(*this);

        if (_Ok) { 
            const _Nput& _Nput_fac = ::std:: use_facet<_Nput>(this->getloc());

            try {
            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this, _Myios::fill(), _Val).failed()) {
                _State |= ios_base::badbit;
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        _Myios::setstate(_State);
        return *this;
    }

    basic_ostream&  operator<<(unsigned long _Val) { 
        ios_base::iostate _State = ios_base::goodbit;
        const sentry _Ok(*this);

        if (_Ok) { 
            const _Nput& _Nput_fac = ::std:: use_facet<_Nput>(this->getloc());

            try {
            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this, _Myios::fill(), _Val).failed()) {
                _State |= ios_base::badbit;
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        _Myios::setstate(_State);
        return *this;
    }

    basic_ostream&  operator<<(long long _Val) { 
        ios_base::iostate _State = ios_base::goodbit;
        const sentry _Ok(*this);

        if (_Ok) { 
            const _Nput& _Nput_fac = ::std:: use_facet<_Nput>(this->getloc());

            try {
            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this, _Myios::fill(), _Val).failed()) {
                _State |= ios_base::badbit;
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        _Myios::setstate(_State);
        return *this;
    }

    basic_ostream&  operator<<(unsigned long long _Val) { 
        ios_base::iostate _State = ios_base::goodbit;
        const sentry _Ok(*this);

        if (_Ok) { 
            const _Nput& _Nput_fac = ::std:: use_facet<_Nput>(this->getloc());

            try {
            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this, _Myios::fill(), _Val).failed()) {
                _State |= ios_base::badbit;
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        _Myios::setstate(_State);
        return *this;
    }

    basic_ostream&  operator<<(float _Val) { 
        ios_base::iostate _State = ios_base::goodbit;
        const sentry _Ok(*this);

        if (_Ok) { 
            const _Nput& _Nput_fac = ::std:: use_facet<_Nput>(this->getloc());

            try {
            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this, _Myios::fill(), static_cast<double>(_Val)).failed()) {
                _State |= ios_base::badbit;
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        _Myios::setstate(_State);
        return *this;
    }

    basic_ostream&  operator<<(double _Val) { 
        ios_base::iostate _State = ios_base::goodbit;
        const sentry _Ok(*this);

        if (_Ok) { 
            const _Nput& _Nput_fac = ::std:: use_facet<_Nput>(this->getloc());

            try {
            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this, _Myios::fill(), _Val).failed()) {
                _State |= ios_base::badbit;
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        _Myios::setstate(_State);
        return *this;
    }

    basic_ostream&  operator<<(long double _Val) { 
        ios_base::iostate _State = ios_base::goodbit;
        const sentry _Ok(*this);

        if (_Ok) { 
            const _Nput& _Nput_fac = ::std:: use_facet<_Nput>(this->getloc());

            try {
            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this, _Myios::fill(), _Val).failed()) {
                _State |= ios_base::badbit;
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        _Myios::setstate(_State);
        return *this;
    }

    basic_ostream&  operator<<(const void* _Val) { 
        ios_base::iostate _State = ios_base::goodbit;
        const sentry _Ok(*this);

        if (_Ok) { 
            const _Nput& _Nput_fac = ::std:: use_facet<_Nput>(this->getloc());

            try {
            if (_Nput_fac.put(_Iter(_Myios::rdbuf()), *this, _Myios::fill(), _Val).failed()) {
                _State |= ios_base::badbit;
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        _Myios::setstate(_State);
        return *this;
    }


    template <class = void> 
    basic_ostream& operator<<(const volatile void* _Val) {
        return *this << const_cast<const void*>(_Val);
    }
#line 463 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ostream"


    template <class = void> 
    basic_ostream& operator<<(nullptr_t) { 
        return *this << "nullptr";
    }
#line 470 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ostream"

    basic_ostream&  operator<<(_Mysb* _Strbuf) { 
        ios_base::iostate _State = ios_base::goodbit;
        bool _Copied             = false;
        const sentry _Ok(*this);

        if (_Ok && _Strbuf) {
            for (int_type _Meta = _Traits::eof();; _Copied = true) { 
                try {
                _Meta = _Traits::eq_int_type(_Traits::eof(), _Meta) ? _Strbuf->sgetc() : _Strbuf->snextc();
                } catch (...) {
                _Myios::setstate(ios_base::failbit);
                throw;
                }

                if (_Traits::eq_int_type(_Traits::eof(), _Meta)) {
                    break; 
                }

                try {
                if (_Traits::eq_int_type(_Traits::eof(), _Myios::rdbuf()->sputc(_Traits::to_char_type(_Meta)))) {
                    _State |= ios_base::badbit; 
                    break;
                }
                } catch (...) { _Myios::setstate(ios_base::badbit, true); }
            }
        }

        this->width(0);
        int _Setstate_with;
        if (_Strbuf) {
            if (_Copied) {
                _Setstate_with = _State;
            } else {
                _Setstate_with = _State | ios_base::failbit;
            }
        } else {
            _Setstate_with = ios_base::badbit;
        }

        _Myios::setstate(_Setstate_with);
        return *this;
    }

    basic_ostream&  put(_Elem _Ch) { 
        ios_base::iostate _State = ios_base::goodbit;
        const sentry _Ok(*this);

        if (!_Ok) {
            _State |= ios_base::badbit;
        } else { 
            try {
            if (_Traits::eq_int_type(_Traits::eof(), _Myios::rdbuf()->sputc(_Ch))) {
                _State |= ios_base::badbit;
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        _Myios::setstate(_State);
        return *this;
    }

    basic_ostream&  write(const _Elem* _Str, streamsize _Count) {
        
        ios_base::iostate _State = ios_base::goodbit;
        const sentry _Ok(*this);

        if (!_Ok) {
            _State |= ios_base::badbit;
        } else if (0 < _Count) { 
            try {
            if (_Myios::rdbuf()->sputn(_Str, _Count) != _Count) {
                _State |= ios_base::badbit;
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        _Myios::setstate(_State);
        return *this;
    }

    basic_ostream&  flush() { 
        const auto _Rdbuf = _Myios::rdbuf();
        if (_Rdbuf) { 
            const sentry _Ok(*this);

            if (_Ok) {
                ios_base::iostate _State = ios_base::goodbit;
                try {
                if (_Rdbuf->pubsync() == -1) {
                    _State |= ios_base::badbit; 
                }
                } catch (...) { _Myios::setstate(ios_base::badbit, true); }
                _Myios::setstate(_State);
            }
        }
        return *this;
    }

    basic_ostream&  seekp(pos_type _Pos) { 
        const sentry _Ok(*this);

        if (!this->fail()) {
            ios_base::iostate _State = ios_base::goodbit;
            try {
            if (static_cast<off_type>(_Myios::rdbuf()->pubseekpos(_Pos, ios_base::out)) == -1) {
                _State |= ios_base::failbit; 
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
            _Myios::setstate(_State);
        }

        return *this;
    }

    basic_ostream&  seekp(off_type _Off, ios_base::seekdir _Way) {
        
        const sentry _Ok(*this);

        if (!this->fail()) {
            ios_base::iostate _State = ios_base::goodbit;
            try {
            if (static_cast<off_type>(_Myios::rdbuf()->pubseekoff(_Off, _Way, ios_base::out)) == -1) {
                _State |= ios_base::failbit; 
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
            _Myios::setstate(_State);
        }

        return *this;
    }

    pos_type  tellp() {
        const sentry _Ok(*this);

        if (!this->fail()) {
            try {
            return _Myios::rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        return pos_type(-1);
    }
};

#pragma vtordisp(pop) 


#line 675 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ostream"

template <class _Elem, class _Traits>
basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, const char* _Val) { 
    ios_base::iostate _State = ios_base::goodbit;
    streamsize _Count        = static_cast<streamsize>(:: strlen(_Val));
    streamsize _Pad          = _Ostr.width() <= 0 || _Ostr.width() <= _Count ? 0 : _Ostr.width() - _Count;
    const typename basic_ostream<_Elem, _Traits>::sentry _Ok(_Ostr);

    if (!_Ok) {
        _State |= ios_base::badbit;
    } else { 
        try {
        const ctype<_Elem>& _Ctype_fac = ::std:: use_facet<ctype<_Elem>>(_Ostr.getloc());
        if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left) {
            for (; 0 < _Pad; --_Pad) { 
                if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
                    _State |= ios_base::badbit; 
                    break;
                }
            }
        }

        for (; _State == ios_base::goodbit && 0 < _Count; --_Count, ++_Val) {
            if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ctype_fac.widen(*_Val)))) {
                _State |= ios_base::badbit;
            }
        }

        if (_State == ios_base::goodbit) {
            for (; 0 < _Pad; --_Pad) { 
                if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
                    _State |= ios_base::badbit; 
                    break;
                }
            }
        }

        _Ostr.width(0);
        } catch (...) { (_Ostr) .setstate(ios_base::badbit, true); }
    }

    _Ostr.setstate(_State);
    return _Ostr;
}

template <class _Elem, class _Traits>
basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, char _Ch) { 
    ios_base::iostate _State = ios_base::goodbit;
    const typename basic_ostream<_Elem, _Traits>::sentry _Ok(_Ostr);

    if (_Ok) { 
        const ctype<_Elem>& _Ctype_fac = ::std:: use_facet<ctype<_Elem>>(_Ostr.getloc());
        streamsize _Pad                = _Ostr.width() <= 1 ? 0 : _Ostr.width() - 1;

        try {
        if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left) {
            for (; _State == ios_base::goodbit && 0 < _Pad; --_Pad) { 
                if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
                    _State |= ios_base::badbit;
                }
            }
        }

        if (_State == ios_base::goodbit
            && _Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ctype_fac.widen(_Ch)))) {
            _State |= ios_base::badbit;
        }

        for (; _State == ios_base::goodbit && 0 < _Pad; --_Pad) { 
            if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
                _State |= ios_base::badbit;
            }
        }
        } catch (...) { (_Ostr) .setstate(ios_base::badbit, true); }
    }

    _Ostr.width(0);
    _Ostr.setstate(_State);
    return _Ostr;
}

template <class _Traits>
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& _Ostr, const char* _Val) {
    
    using _Elem = char;
    using _Myos = basic_ostream<_Elem, _Traits>;

    ios_base::iostate _State = ios_base::goodbit;
    streamsize _Count        = static_cast<streamsize>(_Traits::length(_Val));
    streamsize _Pad          = _Ostr.width() <= 0 || _Ostr.width() <= _Count ? 0 : _Ostr.width() - _Count;
    const typename _Myos::sentry _Ok(_Ostr);

    if (!_Ok) {
        _State |= ios_base::badbit;
    } else { 
        try {
        if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left) {
            for (; 0 < _Pad; --_Pad) { 
                if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
                    _State |= ios_base::badbit; 
                    break;
                }
            }
        }

        if (_State == ios_base::goodbit && _Ostr.rdbuf()->sputn(_Val, _Count) != _Count) {
            _State |= ios_base::badbit;
        }

        if (_State == ios_base::goodbit) {
            for (; 0 < _Pad; --_Pad) { 
                if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
                    _State |= ios_base::badbit; 
                    break;
                }
            }
        }

        _Ostr.width(0);
        } catch (...) { (_Ostr) .setstate(ios_base::badbit, true); }
    }

    _Ostr.setstate(_State);
    return _Ostr;
}

template <class _Traits>
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& _Ostr, char _Ch) {
    
    using _Elem = char;
    using _Myos = basic_ostream<_Elem, _Traits>;

    ios_base::iostate _State = ios_base::goodbit;
    const typename _Myos::sentry _Ok(_Ostr);

    if (_Ok) { 
        streamsize _Pad = _Ostr.width() <= 1 ? 0 : _Ostr.width() - 1;

        try {
        if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left) {
            for (; _State == ios_base::goodbit && 0 < _Pad; --_Pad) { 
                if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
                    _State |= ios_base::badbit;
                }
            }
        }

        if (_State == ios_base::goodbit && _Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ch))) {
            _State |= ios_base::badbit;
        }

        for (; _State == ios_base::goodbit && 0 < _Pad; --_Pad) { 
            if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
                _State |= ios_base::badbit;
            }
        }
        } catch (...) { (_Ostr) .setstate(ios_base::badbit, true); }
    }

    _Ostr.width(0);
    _Ostr.setstate(_State);
    return _Ostr;
}

template <class _Elem, class _Traits>
basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, const _Elem* _Val) { 
    using _Myos = basic_ostream<_Elem, _Traits>;

    ios_base::iostate _State = ios_base::goodbit;
    streamsize _Count        = static_cast<streamsize>(_Traits::length(_Val));
    streamsize _Pad          = _Ostr.width() <= 0 || _Ostr.width() <= _Count ? 0 : _Ostr.width() - _Count;
    const typename _Myos::sentry _Ok(_Ostr);

    if (!_Ok) {
        _State |= ios_base::badbit;
    } else { 
        try {
        if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left) {
            for (; 0 < _Pad; --_Pad) { 
                if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
                    _State |= ios_base::badbit; 
                    break;
                }
            }
        }

        if (_State == ios_base::goodbit && _Ostr.rdbuf()->sputn(_Val, _Count) != _Count) {
            _State |= ios_base::badbit;
        }

        if (_State == ios_base::goodbit) {
            for (; 0 < _Pad; --_Pad) { 
                if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
                    _State |= ios_base::badbit; 
                    break;
                }
            }
        }

        _Ostr.width(0);
        } catch (...) { (_Ostr) .setstate(ios_base::badbit, true); }
    }

    _Ostr.setstate(_State);
    return _Ostr;
}

template <class _Elem, class _Traits>
basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, _Elem _Ch) { 
    using _Myos = basic_ostream<_Elem, _Traits>;

    ios_base::iostate _State = ios_base::goodbit;
    const typename _Myos::sentry _Ok(_Ostr);

    if (_Ok) { 
        streamsize _Pad = _Ostr.width() <= 1 ? 0 : _Ostr.width() - 1;

        try {
        if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left) {
            for (; _State == ios_base::goodbit && 0 < _Pad; --_Pad) { 
                if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
                    _State |= ios_base::badbit;
                }
            }
        }

        if (_State == ios_base::goodbit && _Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ch))) {
            _State |= ios_base::badbit;
        }

        for (; _State == ios_base::goodbit && 0 < _Pad; --_Pad) { 
            if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
                _State |= ios_base::badbit;
            }
        }
        } catch (...) { (_Ostr) .setstate(ios_base::badbit, true); }
    }

    _Ostr.width(0);
    _Ostr.setstate(_State);
    return _Ostr;
}

template <class _Traits>
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& _Ostr, const signed char* _Val) {
    
    return _Ostr << reinterpret_cast<const char*>(_Val);
}

template <class _Traits>
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& _Ostr, signed char _Ch) { 
    return _Ostr << static_cast<char>(_Ch);
}

template <class _Traits>
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& _Ostr, const unsigned char* _Val) {
    
    return _Ostr << reinterpret_cast<const char*>(_Val);
}

template <class _Traits>
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& _Ostr, unsigned char _Ch) {
    
    return _Ostr << static_cast<char>(_Ch);
}


template <class _Traits>
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char8_t*) = delete;
template <class _Traits>
basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char8_t*) = delete;


template <class _Traits>
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char8_t) = delete;
template <class _Traits>
basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char8_t) = delete;
#line 954 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ostream"


template <class _Traits>
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, wchar_t) = delete;

template <class _Traits>
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const wchar_t*) = delete;
#line 963 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ostream"

template <class _Traits>
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char16_t) = delete;
template <class _Traits>
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char32_t) = delete;

template <class _Traits>
basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char16_t) = delete;
template <class _Traits>
basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char32_t) = delete;

template <class _Traits>
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char16_t*) = delete;
template <class _Traits>
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char32_t*) = delete;

template <class _Traits>
basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char16_t*) = delete;
template <class _Traits>
basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char32_t*) = delete;
#line 984 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ostream"

template <class _Ostr, class _Ty, class = void>
struct _Can_stream_out : false_type {};

template <class _Ostr, class _Ty>
struct _Can_stream_out<_Ostr, _Ty, void_t<decltype(::std:: declval<_Ostr&>() << ::std:: declval<const _Ty&>())>> : true_type {
};

template <class _Ostr, class _Ty,
    enable_if_t<conjunction_v<is_convertible<_Ostr*, ios_base*>, _Can_stream_out<_Ostr, _Ty>>, int> = 0>
_Ostr&& operator<<(_Ostr&& _Os, const _Ty& _Val) { 
    _Os << _Val;
    return ::std:: move(_Os);
}

template <class _Elem, class _Traits>
basic_ostream<_Elem, _Traits>& __cdecl endl(
    basic_ostream<_Elem, _Traits>& _Ostr) { 
    _Ostr.put(_Ostr.widen('\n'));
    _Ostr.flush();
    return _Ostr;
}

template <class _Elem, class _Traits>
basic_ostream<_Elem, _Traits>& __cdecl ends(basic_ostream<_Elem, _Traits>& _Ostr) { 
    _Ostr.put(_Elem());
    return _Ostr;
}

template <class _Elem, class _Traits>
basic_ostream<_Elem, _Traits>& __cdecl flush(basic_ostream<_Elem, _Traits>& _Ostr) { 
    _Ostr.flush();
    return _Ostr;
}


template <class _Elem, class _Traits>
basic_ostream<_Elem, _Traits>& emit_on_flush(basic_ostream<_Elem, _Traits>& _Ostr) {
    const auto _Sync_buf_ptr = dynamic_cast<_Basic_syncbuf_impl<_Elem, _Traits>*>(_Ostr.rdbuf());
    if (_Sync_buf_ptr) {
        _Sync_buf_ptr->set_emit_on_sync(true);
    }
    return _Ostr;
}

template <class _Elem, class _Traits>
basic_ostream<_Elem, _Traits>& noemit_on_flush(basic_ostream<_Elem, _Traits>& _Ostr) {
    const auto _Sync_buf_ptr = dynamic_cast<_Basic_syncbuf_impl<_Elem, _Traits>*>(_Ostr.rdbuf());
    if (_Sync_buf_ptr) {
        _Sync_buf_ptr->set_emit_on_sync(false);
    }
    return _Ostr;
}

template <class _Elem, class _Traits>
basic_ostream<_Elem, _Traits>& flush_emit(basic_ostream<_Elem, _Traits>& _Ostr) {
    _Ostr.flush();
    const auto _Sync_buf_ptr = dynamic_cast<_Basic_syncbuf_impl<_Elem, _Traits>*>(_Ostr.rdbuf());
    if (_Sync_buf_ptr) {
        _Sync_buf_ptr->_Do_emit();
    }
    return _Ostr;
}


#line 1056 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ostream"
#line 1057 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ostream"

template <class _Elem, class _Traits>
basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, const error_code& _Errcode) {
    
    return _Ostr << _Errcode.category().name() << ':' << _Errcode.value();
}
}


#pragma warning(pop)
#pragma pack(pop)
#line 1070 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ostream"
#line 1071 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ostream"
#line 12 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\istream"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
#pragma vtordisp(push, 2) 

template <class _Elem, class _Traits>
class basic_istream : virtual public basic_ios<_Elem, _Traits> { 
public:
    using _Myios = basic_ios<_Elem, _Traits>;
    using _Mysb  = basic_streambuf<_Elem, _Traits>;
    using _Iter  = istreambuf_iterator<_Elem, _Traits>;
    using _Ctype = ctype<_Elem>;
    using _Nget  = num_get<_Elem, _Iter>;


#line 39 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\istream"

    explicit  basic_istream(_Mysb* _Strbuf, bool _Isstd = false)

        : _Chcount(0) {
        _Myios::init(_Strbuf, _Isstd);
    }

     basic_istream(_Uninitialized) {
        this->_Addstd(this);
    }

protected:
     basic_istream(basic_istream&& _Right) : _Chcount(_Right._Chcount) {
        _Myios::init();
        _Myios::move(::std:: move(_Right));
        _Right._Chcount = 0;
    }

    basic_istream&  operator=(basic_istream&& _Right) {
        this->swap(_Right);
        return *this;
    }

    void  swap(basic_istream& _Right) {
        _Myios::swap(_Right);
        ::std:: swap(_Chcount, _Right._Chcount);
    }

public:
     basic_istream(const basic_istream&) = delete;
    basic_istream&  operator=(const basic_istream&) = delete;

     ~basic_istream() noexcept override {}

    using int_type = typename _Traits::int_type;
    using pos_type = typename _Traits::pos_type;
    using off_type = typename _Traits::off_type;

    class _Sentry_base {
    public:
         _Sentry_base(basic_istream& _Istr) : _Myistr(_Istr) {
            const auto _Rdbuf = _Myistr.rdbuf();
            if (_Rdbuf) {
                _Rdbuf->_Lock();
            }
        }

         ~_Sentry_base() noexcept {
            const auto _Rdbuf = _Myistr.rdbuf();
            if (_Rdbuf) {
                _Rdbuf->_Unlock();
            }
        }

        basic_istream& _Myistr;

        _Sentry_base& operator=(const _Sentry_base&) = delete;
    };

    class sentry : public _Sentry_base {
    public:
        explicit  sentry(basic_istream& _Istr, bool _Noskip = false)
            : _Sentry_base(_Istr), _Ok(_Sentry_base::_Myistr._Ipfx(_Noskip)) {}

        explicit  operator bool() const {
            return _Ok;
        }

         sentry(const sentry&) = delete;
        sentry&  operator=(const sentry&) = delete;

    private:
        bool _Ok; 
    };

    bool  _Ipfx(bool _Noskip = false) { 
        if (!this->good()) {
            _Myios::setstate(ios_base::failbit);
            return false;
        }

        
        const auto _Tied = _Myios::tie();
        if (_Tied) {
            _Tied->flush();
        }

        bool _Eof = false;
        if (!_Noskip && this->flags() & ios_base::skipws) { 
            const _Ctype& _Ctype_fac = ::std:: use_facet<_Ctype>(this->getloc());

            try {
            int_type _Meta = _Myios::rdbuf()->sgetc();

            for (;; _Meta = _Myios::rdbuf()->snextc()) {
                if (_Traits::eq_int_type(_Traits::eof(), _Meta)) { 
                    _Eof = true;
                    break;
                } else if (!_Ctype_fac.is(_Ctype::space, _Traits::to_char_type(_Meta))) {
                    break; 
                }
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        if (_Eof) {
            _Myios::setstate(ios_base::eofbit | ios_base::failbit);
        }

        return this->good();
    }

    
    bool  ipfx(bool _Noskip = false) { 
        return _Ipfx(_Noskip);
    }

    
    void  isfx() {} 


    basic_istream&  operator>>(basic_istream&(__cdecl* _Pfn)(basic_istream&) ) {
        
        return _Pfn(*this);
    }

    basic_istream&  operator>>(_Myios&(__cdecl* _Pfn)(_Myios&) ) { 
        _Pfn(*this);
        return *this;
    }

    basic_istream&  operator>>(ios_base&(__cdecl* _Pfn)(ios_base&) ) { 
        _Pfn(*this);
        return *this;
    }

private:
    template <class _Ty>
    basic_istream& _Common_extract_with_num_get(_Ty& _Val) { 
        ios_base::iostate _Err = ios_base::goodbit;
        const sentry _Ok(*this);

        if (_Ok) { 
            try {
            ::std:: use_facet<_Nget>(this->getloc()).get(*this, {}, *this, _Err, _Val);
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        _Myios::setstate(_Err);
        return *this;
    }

    template <class = void>
    void _Increment_gcount() {
        if (_Chcount != (numeric_limits<streamsize>::max)()) {
            ++_Chcount;
        }
    }

public:
    basic_istream&  operator>>(bool& _Val) { 
        return _Common_extract_with_num_get(_Val);
    }

    basic_istream&  operator>>(short& _Val) { 
        ios_base::iostate _Err = ios_base::goodbit;
        const sentry _Ok(*this);

        if (_Ok) { 
            try {
            long _Lval;
            ::std:: use_facet<_Nget>(this->getloc()).get(*this, {}, *this, _Err, _Lval);
            if (_Lval < (-32768)) {
                _Err |= ios_base::failbit;
                _Val = (-32768);
            } else if (_Lval > 32767) {
                _Err |= ios_base::failbit;
                _Val = 32767;
            } else {
                _Val = static_cast<short>(_Lval);
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        _Myios::setstate(_Err);
        return *this;
    }

    
    basic_istream&  operator>>(unsigned short& _Val) { 
        return _Common_extract_with_num_get(_Val);
    }

    basic_istream&  operator>>(int& _Val) { 
        static_assert(sizeof(int) == sizeof(long), "Bad overflow assumptions due to sizeof(int) != sizeof(long)");
        long _Result = _Val;
        _Common_extract_with_num_get(_Result);
        _Val = _Result;
        return *this;
    }

    basic_istream&  operator>>(unsigned int& _Val) { 
        return _Common_extract_with_num_get(_Val);
    }

    basic_istream&  operator>>(long& _Val) { 
        return _Common_extract_with_num_get(_Val);
    }

    basic_istream&  operator>>(unsigned long& _Val) { 
        return _Common_extract_with_num_get(_Val);
    }

    basic_istream&  operator>>(long long& _Val) { 
        return _Common_extract_with_num_get(_Val);
    }

    basic_istream&  operator>>(unsigned long long& _Val) { 
        return _Common_extract_with_num_get(_Val);
    }

    basic_istream&  operator>>(float& _Val) { 
        return _Common_extract_with_num_get(_Val);
    }

    basic_istream&  operator>>(double& _Val) { 
        return _Common_extract_with_num_get(_Val);
    }

    basic_istream&  operator>>(long double& _Val) { 
        return _Common_extract_with_num_get(_Val);
    }

    basic_istream&  operator>>(void*& _Val) { 
        return _Common_extract_with_num_get(_Val);
    }

    basic_istream&  operator>>(_Mysb* _Strbuf) { 
        _Chcount = 0; 
        const sentry _Ok(*this, true);
        ios_base::iostate _State = ios_base::goodbit;
        if (_Ok && _Strbuf) { 
            try {
            for (int_type _Meta = _Myios::rdbuf()->sgetc();; _Meta = _Myios::rdbuf()->snextc()) {
                if (_Traits::eq_int_type(_Traits::eof(), _Meta)) { 
                    _State |= ios_base::eofbit;
                    break;
                }
                
                try {
                if (_Traits::eq_int_type(_Traits::eof(), _Strbuf->sputc(_Traits::to_char_type(_Meta)))) {
                    break;
                }

                } catch (...) {
                break;
                }

                _Increment_gcount();
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        if (_Chcount == 0) { 
            _State |= ios_base::failbit;
        }

        _Myios::setstate(_State);
        return *this;
    }

    int_type  get() { 
        int_type _Meta           = 0;
        ios_base::iostate _State = ios_base::goodbit;
        _Chcount                 = 0;
        const sentry _Ok(*this, true);

        if (!_Ok) {
            _Meta = _Traits::eof(); 
        } else { 
            try {
            _Meta = _Myios::rdbuf()->sgetc();

            if (_Traits::eq_int_type(_Traits::eof(), _Meta)) {
                _State |= ios_base::eofbit | ios_base::failbit; 
            } else { 
                _Myios::rdbuf()->sbumpc();
                _Chcount = 1;
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        _Myios::setstate(_State);
        return _Meta;
    }

    basic_istream&  get(_Elem* _Str, streamsize _Count) { 
        return get(_Str, _Count, _Myios::widen('\n'));
    }

    basic_istream&  get(_Elem* _Str, streamsize _Count, _Elem _Delim) {
        
        ios_base::iostate _State = ios_base::goodbit;
        _Chcount                 = 0;
        const sentry _Ok(*this, true);

        if (_Ok && 0 < _Count) { 
            try {
            int_type _Meta = _Myios::rdbuf()->sgetc();

            for (; 0 < --_Count; _Meta = _Myios::rdbuf()->snextc()) {
                if (_Traits::eq_int_type(_Traits::eof(), _Meta)) { 
                    _State |= ios_base::eofbit;
                    break;
                } else if (_Traits::to_char_type(_Meta) == _Delim) {
                    break; 
                } else { 
                    *_Str++ = _Traits::to_char_type(_Meta);
                    _Increment_gcount();
                }
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        _Myios::setstate(_Chcount == 0 ? _State | ios_base::failbit : _State);
        *_Str = _Elem(); 
        return *this;
    }

    basic_istream&  get(_Elem& _Ch) { 
        int_type _Meta = get();
        if (!_Traits::eq_int_type(_Traits::eof(), _Meta)) {
            _Ch = _Traits::to_char_type(_Meta);
        }

        return *this;
    }

    basic_istream&  get(_Mysb& _Strbuf) { 
        return get(_Strbuf, _Myios::widen('\n'));
    }

    basic_istream&  get(_Mysb& _Strbuf, _Elem _Delim) {
        
        ios_base::iostate _State = ios_base::goodbit;
        _Chcount                 = 0;
        const sentry _Ok(*this, true);

        if (_Ok) { 
            try {
            int_type _Meta = _Myios::rdbuf()->sgetc();

            for (;; _Meta = _Myios::rdbuf()->snextc()) {
                if (_Traits::eq_int_type(_Traits::eof(), _Meta)) { 
                    _State |= ios_base::eofbit;
                    break;
                } else { 
                    try {
                    _Elem _Ch = _Traits::to_char_type(_Meta);
                    if (_Ch == _Delim || _Traits::eq_int_type(_Traits::eof(), _Strbuf.sputc(_Ch))) {
                        break;
                    }
                    } catch (...) {
                    break;
                    }
                    _Increment_gcount();
                }
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        if (_Chcount == 0) {
            _State |= ios_base::failbit;
        }
        _Myios::setstate(_State);
        return *this;
    }

    basic_istream&  getline(_Elem* _Str, streamsize _Count) {
        
        return getline(_Str, _Count, _Myios::widen('\n'));
    }

    basic_istream&  getline(_Elem* _Str, streamsize _Count, _Elem _Delim) {
        
        ios_base::iostate _State = ios_base::goodbit;
        _Chcount                 = 0;
        const sentry _Ok(*this, true);

        if (_Ok && 0 < _Count) { 
            int_type _Metadelim = _Traits::to_int_type(_Delim);

            try {
            int_type _Meta = _Myios::rdbuf()->sgetc();

            for (;; _Meta = _Myios::rdbuf()->snextc()) {
                if (_Traits::eq_int_type(_Traits::eof(), _Meta)) { 
                    _State |= ios_base::eofbit;
                    break;
                } else if (_Meta == _Metadelim) { 
                    _Increment_gcount();
                    _Myios::rdbuf()->sbumpc();
                    break;
                } else if (--_Count <= 0) { 
                    _State |= ios_base::failbit;
                    break;
                } else { 
                    *_Str++ = _Traits::to_char_type(_Meta);
                    _Increment_gcount();
                }
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        *_Str = _Elem(); 
        _Myios::setstate(_Chcount == 0 ? _State | ios_base::failbit : _State);
        return *this;
    }

    basic_istream&  ignore(streamsize _Count = 1, int_type _Metadelim = _Traits::eof()) {
        
        ios_base::iostate _State = ios_base::goodbit;
        _Chcount                 = 0;
        const sentry _Ok(*this, true);

        if (_Ok && 0 < _Count) { 
            try {
            for (;;) { 
                int_type _Meta;
                if (_Count != (numeric_limits<streamsize>::max)() && --_Count < 0) {
                    break; 
                } else if (_Traits::eq_int_type(_Traits::eof(),
                               _Meta = _Myios::rdbuf()->sbumpc())) { 
                    _State |= ios_base::eofbit;
                    break;
                } else { 
                    _Increment_gcount();
                    if (_Meta == _Metadelim) {
                        break; 
                    }
                }
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        _Myios::setstate(_State);
        return *this;
    }

    basic_istream&  read(_Elem* _Str, streamsize _Count) { 
        ios_base::iostate _State = ios_base::goodbit;
        _Chcount                 = 0;
        const sentry _Ok(*this, true);

        if (_Ok && 0 < _Count) { 
            try {
            const streamsize _Num = _Myios::rdbuf()->sgetn(_Str, _Count);
            _Chcount              = _Num;

            if (_Num != _Count) {
                _State |= ios_base::eofbit | ios_base::failbit; 
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        _Myios::setstate(_State);
        return *this;
    }

    streamsize  readsome(_Elem* _Str, streamsize _Count) {
        
        ios_base::iostate _State = ios_base::goodbit;
        _Chcount                 = 0;
        const sentry _Ok(*this, true);
        streamsize _Num;

        if (!_Ok) {
            _State |= ios_base::failbit; 
        } else if ((_Num = _Myios::rdbuf()->in_avail()) < 0) {
            _State |= ios_base::eofbit; 
        } else if (0 < _Count && 0 < _Num) { 
            read(_Str, _Num < _Count ? _Num : _Count);
        }

        _Myios::setstate(_State);
        return gcount();
    }

    int_type  peek() {
        ios_base::iostate _State = ios_base::goodbit;
        _Chcount                 = 0;
        int_type _Meta           = 0;
        const sentry _Ok(*this, true);

        if (!_Ok) {
            _Meta = _Traits::eof(); 
        } else { 
            try {
            if (_Traits::eq_int_type(_Traits::eof(), _Meta = _Myios::rdbuf()->sgetc())) {
                _State |= ios_base::eofbit;
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        _Myios::setstate(_State);
        return _Meta;
    }

    basic_istream&  putback(_Elem _Ch) { 
        _Chcount                    = 0;
        ios_base::iostate _State    = ios_base::goodbit;
        ios_base::iostate _Oldstate = _Myios::rdstate();
        _Myios::clear(_Oldstate & ~ios_base::eofbit);
        const sentry _Ok(*this, true);

        if (_Ok) { 
            try {
            if (_Traits::eq_int_type(_Traits::eof(), _Myios::rdbuf()->sputbackc(_Ch))) {
                _State |= ios_base::badbit | _Oldstate;
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        _Myios::setstate(_State);
        return *this;
    }

    basic_istream&  unget() { 
        _Chcount                    = 0;
        ios_base::iostate _State    = ios_base::goodbit;
        ios_base::iostate _Oldstate = _Myios::rdstate();
        _Myios::clear(_Oldstate & ~ios_base::eofbit);
        const sentry _Ok(*this, true);

        if (_Ok) { 
            try {
            if (_Traits::eq_int_type(_Traits::eof(), _Myios::rdbuf()->sungetc())) {
                _State |= ios_base::badbit | _Oldstate;
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        _Myios::setstate(_State);
        return *this;
    }

    [[nodiscard]] streamsize  gcount() const { 
        return _Chcount;
    }

    int  sync() { 
        const sentry _Ok(*this, true);

        const auto _Rdbuf = _Myios::rdbuf();
        if (!_Rdbuf) {
            return -1;
        }

        ios_base::iostate _State = ios_base::goodbit;
        try {
        if (_Rdbuf->pubsync() == -1) {
            _State |= ios_base::badbit;
        }
        } catch (...) {
        _Myios::setstate(ios_base::badbit, true);
        return -1;
        }

        if (_State & ios_base::badbit) {
            _Myios::setstate(ios_base::badbit);
            return -1;
        }

        return 0;
    }

    basic_istream&  seekg(pos_type _Pos) { 
        ios_base::iostate _State    = ios_base::goodbit;
        ios_base::iostate _Oldstate = _Myios::rdstate();
        _Myios::clear(_Oldstate & ~ios_base::eofbit);
        const sentry _Ok(*this, true);

        if (!this->fail()) {
            try {
            if (static_cast<off_type>(_Myios::rdbuf()->pubseekpos(_Pos, ios_base::in)) == -1) {
                _State |= ios_base::failbit;
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        _Myios::setstate(_State);
        return *this;
    }

    basic_istream&  seekg(off_type _Off, ios_base::seekdir _Way) {
        
        ios_base::iostate _State    = ios_base::goodbit;
        ios_base::iostate _Oldstate = _Myios::rdstate();
        _Myios::clear(_Oldstate & ~ios_base::eofbit);
        const sentry _Ok(*this, true);

        if (!this->fail()) {
            try {
            if (static_cast<off_type>(_Myios::rdbuf()->pubseekoff(_Off, _Way, ios_base::in)) == -1) {
                _State |= ios_base::failbit;
            }
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        _Myios::setstate(_State);
        return *this;
    }

    pos_type  tellg() {
        const sentry _Ok(*this, true);

        if (!this->fail()) {
            try {
            return _Myios::rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in);
            } catch (...) { _Myios::setstate(ios_base::badbit, true); }
        }

        return pos_type(-1);
    }

private:
    streamsize _Chcount; 
};

#pragma vtordisp(pop) 


#line 723 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\istream"

template <class _Elem, class _Traits>
class basic_iostream : public basic_istream<_Elem, _Traits>,
                       public basic_ostream<_Elem, _Traits> { 
public:
    using _Myis       = basic_istream<_Elem, _Traits>;
    using _Myos       = basic_ostream<_Elem, _Traits>;
    using _Myios      = basic_ios<_Elem, _Traits>;
    using char_type   = _Elem;
    using traits_type = _Traits;
    using int_type    = typename _Traits::int_type;
    using pos_type    = typename _Traits::pos_type;
    using off_type    = typename _Traits::off_type;

    explicit  basic_iostream(basic_streambuf<_Elem, _Traits>* _Strbuf)
        : _Myis(_Strbuf, false), _Myos(_Noinit, false) {}

protected:
     basic_iostream(basic_iostream&& _Right) : _Myis(_Right.rdbuf(), false), _Myos(_Noinit, false) {
        _Myios::init();
        _Myios::move(::std:: move(_Right));
    }

    basic_iostream&  operator=(basic_iostream&& _Right) {
        this->swap(_Right);
        return *this;
    }

    void  swap(basic_iostream& _Right) {
        if (this != ::std:: addressof(_Right)) {
            _Myios::swap(_Right);
        }
    }

public:
     basic_iostream(const basic_iostream&) = delete;
    basic_iostream&  operator=(const basic_iostream&) = delete;

     ~basic_iostream() noexcept override {}
};


#line 775 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\istream"

template <class _Elem, class _Traits>
basic_istream<_Elem, _Traits>& _Istream_extract_into_buffer(
    basic_istream<_Elem, _Traits>& _Istr, size_t _Size, _Elem* _Str) {
    using _Myis              = basic_istream<_Elem, _Traits>;
    using _Ctype             = ctype<_Elem>;
    ios_base::iostate _State = ios_base::goodbit;
    size_t _Current          = 0;
    const typename _Myis::sentry _Ok(_Istr);

    if (_Ok) { 
        const _Ctype& _Ctype_fac = ::std:: use_facet<_Ctype>(_Istr.getloc());

        try {
        size_t _Count       = _Size;
        const size_t _Width = static_cast<size_t>(_Istr.width());
        if (_Width > 0 && _Width < _Size) {
            _Count = _Width;
        }

        typename _Myis::int_type _Meta = _Istr.rdbuf()->sgetc();
        _Elem _Ch;

        for (; _Current < _Count - 1; _Meta = _Istr.rdbuf()->snextc(), (void) ++_Current) {
            if (_Traits::eq_int_type(_Traits::eof(), _Meta)) { 
                _State |= ios_base::eofbit;
                break;
            } else if (_Ctype_fac.is(_Ctype::space, _Ch = _Traits::to_char_type(_Meta)) || _Ch == _Elem()) {
                break; 
            } else {
                _Str[_Current] = _Traits::to_char_type(_Meta); 
            }
        }
        } catch (...) { (_Istr) .setstate(ios_base::badbit, true); }
    }
    ; 
    _Str[_Current] = _Elem(); 
    _Istr.width(0);
    if (_Current == 0) {
        _State |= ios_base::failbit;
    }
    _Istr.setstate(_State);
    return _Istr;
}


#pragma warning(push)
#pragma warning(disable : 6001) 
template <class _Elem, class _Traits, size_t _Size>
basic_istream<_Elem, _Traits>& operator>>(
    basic_istream<_Elem, _Traits>& _Istr,   _Elem (&_Str)[_Size]) {
    return _Istream_extract_into_buffer(_Istr, _Size, _Str);
}

template <class _Traits, size_t _Size>
basic_istream<char, _Traits>& operator>>(
    basic_istream<char, _Traits>& _Istr,   signed char (&_Str)[_Size]) {
    return _Istream_extract_into_buffer(_Istr, _Size, reinterpret_cast<char*>(_Str));
}

template <class _Traits, size_t _Size>
basic_istream<char, _Traits>& operator>>(
    basic_istream<char, _Traits>& _Istr,   unsigned char (&_Str)[_Size]) {
    return _Istream_extract_into_buffer(_Istr, _Size, reinterpret_cast<char*>(_Str));
}
#pragma warning(pop)


#line 857 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\istream"

template <class _Elem, class _Traits>
basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, _Elem& _Ch) { 
    using _Myis = basic_istream<_Elem, _Traits>;

    typename _Myis::int_type _Meta;
    ios_base::iostate _State = ios_base::goodbit;
    const typename _Myis::sentry _Ok(_Istr);

    if (_Ok) { 
        try {
        _Meta = _Istr.rdbuf()->sbumpc();
        if (_Traits::eq_int_type(_Traits::eof(), _Meta)) {
            _State |= ios_base::eofbit | ios_base::failbit; 
        } else {
            _Ch = _Traits::to_char_type(_Meta); 
        }
        } catch (...) { (_Istr) .setstate(ios_base::badbit, true); }
    }

    _Istr.setstate(_State);
    return _Istr;
}

template <class _Traits>
basic_istream<char, _Traits>& operator>>(basic_istream<char, _Traits>& _Istr, signed char& _Ch) {
    
    return _Istr >> reinterpret_cast<char&>(_Ch);
}

template <class _Traits>
basic_istream<char, _Traits>& operator>>(basic_istream<char, _Traits>& _Istr, unsigned char& _Ch) {
    
    return _Istr >> reinterpret_cast<char&>(_Ch);
}

template <class _Istr, class _Ty, class = void>
struct _Can_stream_in : false_type {};

template <class _Istr, class _Ty>
struct _Can_stream_in<_Istr, _Ty, void_t<decltype(::std:: declval<_Istr&>() >> ::std:: declval<_Ty>())>> : true_type {};

template <class _Istr, class _Ty,
    enable_if_t<conjunction_v<is_convertible<_Istr*, ios_base*>, _Can_stream_in<_Istr, _Ty>>, int> = 0>
_Istr&& operator>>(_Istr&& _Is, _Ty&& _Val) { 
    _Is >> ::std:: forward<_Ty>(_Val);
    return ::std:: move(_Is);
}

template <class _Elem, class _Traits>
basic_istream<_Elem, _Traits>& __cdecl ws(basic_istream<_Elem, _Traits>& _Istr) { 
    const typename basic_istream<_Elem, _Traits>::sentry _Ok(_Istr, true);

    if (_Ok) { 
        ios_base::iostate _State = ios_base::goodbit;
        const auto& _Ctype_fac   = ::std:: use_facet<ctype<_Elem>>(_Istr.getloc());

        try {
        for (typename _Traits::int_type _Meta = _Istr.rdbuf()->sgetc();; _Meta = _Istr.rdbuf()->snextc()) {
            if (_Traits::eq_int_type(_Traits::eof(), _Meta)) { 
                _State |= ios_base::eofbit;
                break;
            } else if (!_Ctype_fac.is(ctype<_Elem>::space, _Traits::to_char_type(_Meta))) {
                break; 
            }
        }
        } catch (...) { (_Istr) .setstate(ios_base::badbit, true); }
        _Istr.setstate(_State);
    }

    return _Istr;
}
}


#pragma warning(pop)
#pragma pack(pop)
#line 936 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\istream"
#line 937 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\istream"
#line 26 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\optional"


#pragma once


#line 14 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\optional"


#line 17 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\optional"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xsmf_control.h"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {

template <class _Base>
struct _Non_trivial_copy : _Base { 
    using _Base::_Base;

    _Non_trivial_copy() = default;
    constexpr _Non_trivial_copy(const _Non_trivial_copy& _That) noexcept(
        noexcept(_Base::_Construct_from(static_cast<const _Base&>(_That)))) {
        _Base::_Construct_from(static_cast<const _Base&>(_That));
    }
    _Non_trivial_copy(_Non_trivial_copy&&) = default;
    _Non_trivial_copy& operator=(const _Non_trivial_copy&) = default;
    _Non_trivial_copy& operator=(_Non_trivial_copy&&) = default;
};

template <class _Base, class... _Types>
using _SMF_control_copy = conditional_t<
    conjunction_v<is_copy_constructible<_Types>..., negation<conjunction<is_trivially_copy_constructible<_Types>...>>>,
    _Non_trivial_copy<_Base>, _Base>;


template <class _Base, class... _Types>
struct _Non_trivial_move : _SMF_control_copy<_Base, _Types...> { 
    using _Mybase = _SMF_control_copy<_Base, _Types...>;
    using _Mybase::_Mybase;

    _Non_trivial_move()                         = default;
    _Non_trivial_move(const _Non_trivial_move&) = default;
    constexpr _Non_trivial_move(_Non_trivial_move&& _That) noexcept(
        noexcept(_Mybase::_Construct_from(static_cast<_Base&&>(_That)))) {
        _Mybase::_Construct_from(static_cast<_Base&&>(_That));
    }
    _Non_trivial_move& operator=(const _Non_trivial_move&) = default;
    _Non_trivial_move& operator=(_Non_trivial_move&&) = default;
};

template <class _Base, class... _Types>
using _SMF_control_move = conditional_t<
    conjunction_v<is_move_constructible<_Types>..., negation<conjunction<is_trivially_move_constructible<_Types>...>>>,
    _Non_trivial_move<_Base, _Types...>, _SMF_control_copy<_Base, _Types...>>;


template <class _Base, class... _Types>
struct _Non_trivial_copy_assign : _SMF_control_move<_Base, _Types...> { 
    using _Mybase = _SMF_control_move<_Base, _Types...>;
    using _Mybase::_Mybase;

    _Non_trivial_copy_assign()                                = default;
    _Non_trivial_copy_assign(const _Non_trivial_copy_assign&) = default;
    _Non_trivial_copy_assign(_Non_trivial_copy_assign&&)      = default;

    constexpr _Non_trivial_copy_assign& operator=(const _Non_trivial_copy_assign& _That) noexcept(
        noexcept(_Mybase::_Assign_from(static_cast<const _Base&>(_That)))) {
        _Mybase::_Assign_from(static_cast<const _Base&>(_That));
        return *this;
    }
    _Non_trivial_copy_assign& operator=(_Non_trivial_copy_assign&&) = default;
};

template <class _Base, class... _Types>
struct _Deleted_copy_assign : _SMF_control_move<_Base, _Types...> { 
    using _Mybase = _SMF_control_move<_Base, _Types...>;
    using _Mybase::_Mybase;

    _Deleted_copy_assign()                            = default;
    _Deleted_copy_assign(const _Deleted_copy_assign&) = default;
    _Deleted_copy_assign(_Deleted_copy_assign&&)      = default;
    _Deleted_copy_assign& operator=(const _Deleted_copy_assign&) = delete;
    _Deleted_copy_assign& operator=(_Deleted_copy_assign&&) = default;
};

template <class _Base, class... _Types>
using _SMF_control_copy_assign =
    conditional_t<conjunction_v<is_trivially_destructible<_Types>..., is_trivially_copy_constructible<_Types>...,
                      is_trivially_copy_assignable<_Types>...>,
        _SMF_control_move<_Base, _Types...>,
        conditional_t<conjunction_v<is_copy_constructible<_Types>..., is_copy_assignable<_Types>...>,
            _Non_trivial_copy_assign<_Base, _Types...>, _Deleted_copy_assign<_Base, _Types...>>>;


template <class _Base, class... _Types>
struct _Non_trivial_move_assign : _SMF_control_copy_assign<_Base, _Types...> { 
    using _Mybase = _SMF_control_copy_assign<_Base, _Types...>;
    using _Mybase::_Mybase;

    _Non_trivial_move_assign()                                = default;
    _Non_trivial_move_assign(const _Non_trivial_move_assign&) = default;
    _Non_trivial_move_assign(_Non_trivial_move_assign&&)      = default;
    _Non_trivial_move_assign& operator=(const _Non_trivial_move_assign&) = default;

    constexpr _Non_trivial_move_assign& operator=(_Non_trivial_move_assign&& _That) noexcept(
        noexcept(_Mybase::_Assign_from(static_cast<_Base&&>(_That)))) {
        _Mybase::_Assign_from(static_cast<_Base&&>(_That));
        return *this;
    }
};

template <class _Base, class... _Types>
struct _Deleted_move_assign : _SMF_control_copy_assign<_Base, _Types...> { 
    using _Mybase = _SMF_control_copy_assign<_Base, _Types...>;
    using _Mybase::_Mybase;

    _Deleted_move_assign()                            = default;
    _Deleted_move_assign(const _Deleted_move_assign&) = default;
    _Deleted_move_assign(_Deleted_move_assign&&)      = default;
    _Deleted_move_assign& operator=(const _Deleted_move_assign&) = default;
    _Deleted_move_assign& operator=(_Deleted_move_assign&&) = delete;
};

template <class _Base, class... _Types>
using _SMF_control_move_assign =
    conditional_t<conjunction_v<is_trivially_destructible<_Types>..., is_trivially_move_constructible<_Types>...,
                      is_trivially_move_assignable<_Types>...>,
        _SMF_control_copy_assign<_Base, _Types...>,
        conditional_t<conjunction_v<is_move_constructible<_Types>..., is_move_assignable<_Types>...>,
            _Non_trivial_move_assign<_Base, _Types...>, _Deleted_move_assign<_Base, _Types...>>>;


template <class _Base, class... _Types>
using _SMF_control = _SMF_control_move_assign<_Base, _Types...>;

}


#pragma warning(pop)
#pragma pack(pop)

#line 151 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xsmf_control.h"
#line 152 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xsmf_control.h"
#line 23 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\optional"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {

struct nullopt_t { 
    struct _Tag {};
    constexpr explicit nullopt_t(_Tag) {}
};
inline constexpr nullopt_t nullopt{nullopt_t::_Tag{}};

class bad_optional_access : public exception {
public:
    [[nodiscard]] const char*  what() const noexcept override {
        return "Bad optional access";
    }


#line 51 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\optional"
};

[[noreturn]] inline void _Throw_bad_optional_access() {
    throw bad_optional_access{};
}

struct _Nontrivial_dummy_type {
    constexpr _Nontrivial_dummy_type() noexcept {
        
    }
};
;


struct _Construct_from_invoke_result_tag {
    explicit _Construct_from_invoke_result_tag() = default;
};
#line 69 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\optional"

template <class _Ty, bool = is_trivially_destructible_v<_Ty>>
struct _Optional_destruct_base { 
    union {
        _Nontrivial_dummy_type _Dummy;
        remove_const_t<_Ty> _Value;
    };
    bool _Has_value;

    constexpr _Optional_destruct_base() noexcept : _Dummy{}, _Has_value{false} {} 

    template <class... _Types>
    constexpr explicit _Optional_destruct_base(in_place_t, _Types&&... _Args)
        : _Value(::std:: forward<_Types>(_Args)...), _Has_value{true} {} 


    template <class _Fn, class _Ux>
    constexpr _Optional_destruct_base(_Construct_from_invoke_result_tag, _Fn&& _Func, _Ux&& _Arg)
        : _Value(::std:: invoke(::std:: forward<_Fn>(_Func), ::std:: forward<_Ux>(_Arg))), _Has_value{true} {}
#line 89 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\optional"

    constexpr void reset() noexcept {
        _Has_value = false;
    }
};

template <class _Ty>
struct _Optional_destruct_base<_Ty, false> { 
    union {
        _Nontrivial_dummy_type _Dummy;
        remove_const_t<_Ty> _Value;
    };
    bool _Has_value;

    constexpr ~_Optional_destruct_base() noexcept {
        if (_Has_value) {
            _Destroy_in_place(_Value);
        }
    }

    constexpr _Optional_destruct_base() noexcept : _Dummy{}, _Has_value{false} {} 

    template <class... _Types>
    constexpr explicit _Optional_destruct_base(in_place_t, _Types&&... _Args)
        : _Value(::std:: forward<_Types>(_Args)...), _Has_value{true} {} 


    template <class _Fn, class _Ux>
    constexpr _Optional_destruct_base(_Construct_from_invoke_result_tag, _Fn&& _Func, _Ux&& _Arg)
        : _Value(::std:: invoke(::std:: forward<_Fn>(_Func), ::std:: forward<_Ux>(_Arg))), _Has_value{true} {}
#line 120 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\optional"

    _Optional_destruct_base(const _Optional_destruct_base&) = default;
    _Optional_destruct_base(_Optional_destruct_base&&)      = default;
    _Optional_destruct_base& operator=(const _Optional_destruct_base&) = default;
    _Optional_destruct_base& operator=(_Optional_destruct_base&&) = default;

    constexpr void reset() noexcept {
        if (_Has_value) {
            _Destroy_in_place(_Value);
            _Has_value = false;
        }
    }
};

template <class _Ty>
struct _Optional_construct_base : _Optional_destruct_base<_Ty> {
    
    using _Optional_destruct_base<_Ty>::_Optional_destruct_base;

    template <class... _Types>
    constexpr _Ty& _Construct(_Types&&... _Args) {
        
        ;
        _Construct_in_place(this->_Value, ::std:: forward<_Types>(_Args)...);
        this->_Has_value = true;
        return this->_Value;
    }

    template <class _Ty2>
    constexpr void _Assign(_Ty2&& _Right) { 
        if (this->_Has_value) {
            this->_Value = ::std:: forward<_Ty2>(_Right);
        } else {
            _Construct(::std:: forward<_Ty2>(_Right));
        }
    }

    template <class _Self>
    constexpr void _Construct_from(_Self&& _Right) noexcept(
        is_nothrow_constructible_v<_Ty, decltype(*::std:: forward<_Self>(_Right))>) {
        
        if (_Right._Has_value) {
            _Construct(*::std:: forward<_Self>(_Right));
        }
    }

    template <class _Self>
    constexpr void _Assign_from(_Self&& _Right) noexcept(
        is_nothrow_constructible_v<_Ty, decltype(*::std:: forward<_Self>(_Right))>&&
            is_nothrow_assignable_v<_Ty&, decltype(*::std:: forward<_Self>(_Right))>) {
        
        if (_Right._Has_value) {
            _Assign(*::std:: forward<_Self>(_Right));
        } else {
            this->reset();
        }
    }

    [[nodiscard]] constexpr _Ty& operator*() & noexcept {


#line 182 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\optional"
        return this->_Value;
    }

    [[nodiscard]] constexpr const _Ty& operator*() const& noexcept {


#line 189 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\optional"
        return this->_Value;
    }

    [[nodiscard]] constexpr _Ty&& operator*() && noexcept {


#line 196 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\optional"
        return ::std:: move(this->_Value);
    }

    [[nodiscard]] constexpr const _Ty&& operator*() const&& noexcept {


#line 203 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\optional"
        return ::std:: move(this->_Value);
    }
};

template <class _Ty>
class optional : private _SMF_control<_Optional_construct_base<_Ty>, _Ty> {
private:
    using _Mybase = _SMF_control<_Optional_construct_base<_Ty>, _Ty>;

public:
    static_assert(!_Is_any_of_v<remove_cv_t<_Ty>, nullopt_t, in_place_t>,
        "T in optional<T> must be a type other than nullopt_t or in_place_t (N4828 [optional.optional]/3).");
    static_assert(is_object_v<_Ty> && is_destructible_v<_Ty> && !is_array_v<_Ty>,
        "T in optional<T> must meet the Cpp17Destructible requirements (N4828 [optional.optional]/3).");

    using value_type = _Ty;

    constexpr optional() noexcept {}
    constexpr optional(nullopt_t) noexcept {}

    template <class... _Types, enable_if_t<is_constructible_v<_Ty, _Types...>, int> = 0>
    constexpr explicit optional(in_place_t, _Types&&... _Args) : _Mybase(in_place, ::std:: forward<_Types>(_Args)...) {}

    template <class _Elem, class... _Types,
        enable_if_t<is_constructible_v<_Ty, initializer_list<_Elem>&, _Types...>, int> = 0>
    constexpr explicit optional(in_place_t, initializer_list<_Elem> _Ilist, _Types&&... _Args)
        : _Mybase(in_place, _Ilist, ::std:: forward<_Types>(_Args)...) {}

    template <class _Ty2>
    using _AllowDirectConversion = bool_constant<conjunction_v<negation<is_same<_Remove_cvref_t<_Ty2>, optional>>,
        negation<is_same<_Remove_cvref_t<_Ty2>, in_place_t>>, is_constructible<_Ty, _Ty2>>>;


    template <class _Ty2 = _Ty, enable_if_t<_AllowDirectConversion<_Ty2>::value, int> = 0>
    constexpr explicit(!is_convertible_v<_Ty2, _Ty>) optional(_Ty2&& _Right)
        : _Mybase(in_place, ::std:: forward<_Ty2>(_Right)) {}


#line 247 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\optional"

    template <class _Ty2>
    struct _AllowUnwrapping : bool_constant<!disjunction_v<is_same<_Ty, _Ty2>, is_constructible<_Ty, optional<_Ty2>&>,
                                  is_constructible<_Ty, const optional<_Ty2>&>,
                                  is_constructible<_Ty, const optional<_Ty2>>, is_constructible<_Ty, optional<_Ty2>>,
                                  is_convertible<optional<_Ty2>&, _Ty>, is_convertible<const optional<_Ty2>&, _Ty>,
                                  is_convertible<const optional<_Ty2>, _Ty>, is_convertible<optional<_Ty2>, _Ty>>> {};


    template <class _Ty2,
        enable_if_t<conjunction_v<_AllowUnwrapping<_Ty2>, is_constructible<_Ty, const _Ty2&>>, int> = 0>
    constexpr explicit(!is_convertible_v<const _Ty2&, _Ty>) optional(const optional<_Ty2>& _Right) {
        if (_Right) {
            this->_Construct(*_Right);
        }
    }


#line 281 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\optional"


    template <class _Ty2, enable_if_t<conjunction_v<_AllowUnwrapping<_Ty2>, is_constructible<_Ty, _Ty2>>, int> = 0>
    constexpr explicit(!is_convertible_v<_Ty2, _Ty>) optional(optional<_Ty2>&& _Right) {
        if (_Right) {
            this->_Construct(::std:: move(*_Right));
        }
    }


#line 307 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\optional"


    template <class _Fn, class _Ux>
    constexpr optional(_Construct_from_invoke_result_tag _Tag, _Fn&& _Func, _Ux&& _Arg)
        : _Mybase(_Tag, ::std:: forward<_Fn>(_Func), ::std:: forward<_Ux>(_Arg)) {}
#line 313 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\optional"

    constexpr optional& operator=(nullopt_t) noexcept {
        reset();
        return *this;
    }

    template <class _Ty2 = _Ty, enable_if_t<conjunction_v<negation<is_same<optional, _Remove_cvref_t<_Ty2>>>,
                                                negation<conjunction<is_scalar<_Ty>, is_same<_Ty, decay_t<_Ty2>>>>,
                                                is_constructible<_Ty, _Ty2>, is_assignable<_Ty&, _Ty2>>,
                                    int> = 0>
    constexpr optional& operator=(_Ty2&& _Right) {
        this->_Assign(::std:: forward<_Ty2>(_Right));
        return *this;
    }

    template <class _Ty2>
    struct _AllowUnwrappingAssignment
        : bool_constant<!disjunction_v<is_same<_Ty, _Ty2>, is_assignable<_Ty&, optional<_Ty2>&>,
              is_assignable<_Ty&, const optional<_Ty2>&>, is_assignable<_Ty&, const optional<_Ty2>>,
              is_assignable<_Ty&, optional<_Ty2>>>> {};

    template <class _Ty2, enable_if_t<conjunction_v<_AllowUnwrappingAssignment<_Ty2>,
                                          is_constructible<_Ty, const _Ty2&>, is_assignable<_Ty&, const _Ty2&>>,
                              int> = 0>
    constexpr optional& operator=(const optional<_Ty2>& _Right) {
        if (_Right) {
            this->_Assign(*_Right);
        } else {
            reset();
        }

        return *this;
    }

    template <class _Ty2, enable_if_t<conjunction_v<_AllowUnwrappingAssignment<_Ty2>, is_constructible<_Ty, _Ty2>,
                                          is_assignable<_Ty&, _Ty2>>,
                              int> = 0>
    constexpr optional& operator=(optional<_Ty2>&& _Right) {
        if (_Right) {
            this->_Assign(::std:: move(*_Right));
        } else {
            reset();
        }

        return *this;
    }

    template <class... _Types>
    constexpr _Ty& emplace(_Types&&... _Args) {
        reset();
        return this->_Construct(::std:: forward<_Types>(_Args)...);
    }

    template <class _Elem, class... _Types,
        enable_if_t<is_constructible_v<_Ty, initializer_list<_Elem>&, _Types...>, int> = 0>
    constexpr _Ty& emplace(initializer_list<_Elem> _Ilist, _Types&&... _Args) {
        reset();
        return this->_Construct(_Ilist, ::std:: forward<_Types>(_Args)...);
    }

    constexpr void swap(optional& _Right) noexcept(
        is_nothrow_move_constructible_v<_Ty>&& is_nothrow_swappable_v<_Ty>) {
        static_assert(is_move_constructible_v<_Ty>,
            "optional<T>::swap requires T to be move constructible (N4828 [optional.swap]/1).");
        static_assert(!is_move_constructible_v<_Ty> || is_swappable_v<_Ty>,
            "optional<T>::swap requires T to be swappable (N4828 [optional.swap]/1).");
        if constexpr (_Is_trivially_swappable_v<_Ty>) {
            using _TrivialBaseTy = _Optional_destruct_base<_Ty>;
            ::std:: swap(static_cast<_TrivialBaseTy&>(*this), static_cast<_TrivialBaseTy&>(_Right));
        } else {
            const bool _Engaged = this->_Has_value;
            if (_Engaged == _Right._Has_value) {
                if (_Engaged) {
                    _Swap_adl(**this, *_Right);
                }
            } else {
                optional& _Source = _Engaged ? *this : _Right;
                optional& _Target = _Engaged ? _Right : *this;
                _Target._Construct(::std:: move(*_Source));
                _Source.reset();
            }
        }
    }

    [[nodiscard]] constexpr const _Ty* operator->() const noexcept {


#line 401 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\optional"
        return ::std:: addressof(this->_Value);
    }
    [[nodiscard]] constexpr _Ty* operator->() noexcept {


#line 407 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\optional"
        return ::std:: addressof(this->_Value);
    }

    using _Mybase::operator*;

    constexpr explicit operator bool() const noexcept {
        return this->_Has_value;
    }
    [[nodiscard]] constexpr bool has_value() const noexcept {
        return this->_Has_value;
    }

    [[nodiscard]] constexpr const _Ty& value() const& {
        if (!this->_Has_value) {
            _Throw_bad_optional_access();
        }

        return this->_Value;
    }
    [[nodiscard]] constexpr _Ty& value() & {
        if (!this->_Has_value) {
            _Throw_bad_optional_access();
        }

        return this->_Value;
    }
    [[nodiscard]] constexpr _Ty&& value() && {
        if (!this->_Has_value) {
            _Throw_bad_optional_access();
        }

        return ::std:: move(this->_Value);
    }
    [[nodiscard]] constexpr const _Ty&& value() const&& {
        if (!this->_Has_value) {
            _Throw_bad_optional_access();
        }

        return ::std:: move(this->_Value);
    }

    template <class _Ty2>
    [[nodiscard]] constexpr remove_cv_t<_Ty> value_or(_Ty2&& _Right) const& {
        static_assert(is_convertible_v<const _Ty&, remove_cv_t<_Ty>>,
            "The const overload of optional<T>::value_or requires const T& to be convertible to remove_cv_t<T> "
            "(N4885 [optional.observe]/17 as modified by LWG-3424).");
        static_assert(is_convertible_v<_Ty2, _Ty>,
            "optional<T>::value_or(U) requires U to be convertible to T (N4828 [optional.observe]/18).");

        if (this->_Has_value) {
            return this->_Value;
        }

        return static_cast<remove_cv_t<_Ty>>(::std:: forward<_Ty2>(_Right));
    }
    template <class _Ty2>
    [[nodiscard]] constexpr remove_cv_t<_Ty> value_or(_Ty2&& _Right) && {
        static_assert(is_convertible_v<_Ty, remove_cv_t<_Ty>>,
            "The rvalue overload of optional<T>::value_or requires T to be convertible to remove_cv_t<T> "
            "(N4885 [optional.observe]/19 as modified by LWG-3424).");
        static_assert(is_convertible_v<_Ty2, _Ty>,
            "optional<T>::value_or(U) requires U to be convertible to T (N4828 [optional.observe]/20).");

        if (this->_Has_value) {
            return ::std:: move(this->_Value);
        }

        return static_cast<remove_cv_t<_Ty>>(::std:: forward<_Ty2>(_Right));
    }


    template <class _Fn>
    constexpr auto and_then(_Fn&& _Func) & {
        using _Uty = invoke_result_t<_Fn, _Ty&>;

        static_assert(_Is_specialization_v<remove_cvref_t<_Uty>, optional>,
            "optional<T>::and_then(F) requires the return type of F to be a specialization of optional "
            "(N4901 [optional.monadic]/2).");

        if (this->_Has_value) {
            return ::std:: invoke(::std:: forward<_Fn>(_Func), this->_Value);
        } else {
            return remove_cvref_t<_Uty>{};
        }
    }

    template <class _Fn>
    constexpr auto and_then(_Fn&& _Func) const& {
        using _Uty = invoke_result_t<_Fn, const _Ty&>;

        static_assert(_Is_specialization_v<remove_cvref_t<_Uty>, optional>,
            "optional<T>::and_then(F) requires the return type of F to be a specialization of optional "
            "(N4901 [optional.monadic]/2).");

        if (this->_Has_value) {
            return ::std:: invoke(::std:: forward<_Fn>(_Func), this->_Value);
        } else {
            return remove_cvref_t<_Uty>{};
        }
    }

    template <class _Fn>
    constexpr auto and_then(_Fn&& _Func) && {
        using _Uty = invoke_result_t<_Fn, _Ty>;

        static_assert(_Is_specialization_v<remove_cvref_t<_Uty>, optional>,
            "optional<T>::and_then(F) requires the return type of F to be a specialization of optional "
            "(N4901 [optional.monadic]/5).");

        if (this->_Has_value) {
            return ::std:: invoke(::std:: forward<_Fn>(_Func), ::std:: move(this->_Value));
        } else {
            return remove_cvref_t<_Uty>{};
        }
    }

    template <class _Fn>
    constexpr auto and_then(_Fn&& _Func) const&& {
        using _Uty = invoke_result_t<_Fn, const _Ty>;

        static_assert(_Is_specialization_v<remove_cvref_t<_Uty>, optional>,
            "optional<T>::and_then(F) requires the return type of F to be a specialization of optional "
            "(N4901 [optional.monadic]/5).");

        if (this->_Has_value) {
            return ::std:: invoke(::std:: forward<_Fn>(_Func), ::std:: move(this->_Value));
        } else {
            return remove_cvref_t<_Uty>{};
        }
    }

    template <class _Fn>
    constexpr auto transform(_Fn&& _Func) & {
        using _Uty = remove_cv_t<invoke_result_t<_Fn, _Ty&>>;

        static_assert(!_Is_any_of_v<_Uty, nullopt_t, in_place_t>,
            "optional<T>::transform(F) requires the return type of F to be a type other than nullopt_t or in_place_t "
            "(N4901 [optional.monadic]/8).");
        static_assert(is_object_v<_Uty> && !is_array_v<_Uty>,
            "optional<T>::transform(F) requires the return type of F to be a non-array object type "
            "(N4901 [optional.monadic]/8).");

        if (this->_Has_value) {
            return optional<_Uty>{_Construct_from_invoke_result_tag{}, ::std:: forward<_Fn>(_Func), this->_Value};
        } else {
            return optional<_Uty>{};
        }
    }

    template <class _Fn>
    constexpr auto transform(_Fn&& _Func) const& {
        using _Uty = remove_cv_t<invoke_result_t<_Fn, const _Ty&>>;

        static_assert(!_Is_any_of_v<_Uty, nullopt_t, in_place_t>,
            "optional<T>::transform(F) requires the return type of F to be a type other than nullopt_t or in_place_t "
            "(N4901 [optional.monadic]/8).");
        static_assert(is_object_v<_Uty> && !is_array_v<_Uty>,
            "optional<T>::transform(F) requires the return type of F to be a non-array object type "
            "(N4901 [optional.monadic]/8).");

        if (this->_Has_value) {
            return optional<_Uty>{_Construct_from_invoke_result_tag{}, ::std:: forward<_Fn>(_Func), this->_Value};
        } else {
            return optional<_Uty>{};
        }
    }

    template <class _Fn>
    constexpr auto transform(_Fn&& _Func) && {
        using _Uty = remove_cv_t<invoke_result_t<_Fn, _Ty>>;

        static_assert(!_Is_any_of_v<_Uty, nullopt_t, in_place_t>,
            "optional<T>::transform(F) requires the return type of F to be a type other than nullopt_t or in_place_t "
            "(N4901 [optional.monadic]/11).");
        static_assert(is_object_v<_Uty> && !is_array_v<_Uty>,
            "optional<T>::transform(F) requires the return type of F to be a non-array object type "
            "(N4901 [optional.monadic]/11).");

        if (this->_Has_value) {
            return optional<_Uty>{
                _Construct_from_invoke_result_tag{}, ::std:: forward<_Fn>(_Func), ::std:: move(this->_Value)};
        } else {
            return optional<_Uty>{};
        }
    }

    template <class _Fn>
    constexpr auto transform(_Fn&& _Func) const&& {
        using _Uty = remove_cv_t<invoke_result_t<_Fn, const _Ty>>;

        static_assert(!_Is_any_of_v<_Uty, nullopt_t, in_place_t>,
            "optional<T>::transform(F) requires the return type of F to be a type other than nullopt_t or in_place_t "
            "(N4901 [optional.monadic]/11).");
        static_assert(is_object_v<_Uty> && !is_array_v<_Uty>,
            "optional<T>::transform(F) requires the return type of F to be a non-array object type "
            "(N4901 [optional.monadic]/11).");

        if (this->_Has_value) {
            return optional<_Uty>{
                _Construct_from_invoke_result_tag{}, ::std:: forward<_Fn>(_Func), ::std:: move(this->_Value)};
        } else {
            return optional<_Uty>{};
        }
    }


    template <invocable<> _Fn>
        requires copy_constructible<_Ty>
    constexpr optional or_else(_Fn&& _Func) const& {
        static_assert(is_same_v<remove_cvref_t<invoke_result_t<_Fn>>, optional>,
            "optional<T>::or_else(F) requires F to return an optional<T> (N4901 [optional.monadic]/14).");

        if (this->_Has_value) {
            return *this;
        } else {
            return ::std:: forward<_Fn>(_Func)();
        }
    }

    template <invocable<> _Fn>
        requires move_constructible<_Ty>
    constexpr optional or_else(_Fn&& _Func) && {
        static_assert(is_same_v<remove_cvref_t<invoke_result_t<_Fn>>, optional>,
            "optional<T>::or_else(F) requires F to return an optional<T> (N4901 [optional.monadic]/17).");

        if (this->_Has_value) {
            return ::std:: move(*this);
        } else {
            return ::std:: forward<_Fn>(_Func)();
        }
    }
#line 639 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\optional"
#line 640 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\optional"

    using _Mybase::reset;
};

template <class _Ty>
optional(_Ty) -> optional<_Ty>;

template <class _Ty1, class _Ty2>
[[nodiscard]] constexpr bool operator==(const optional<_Ty1>& _Left, const optional<_Ty2>& _Right) {
    const bool _Left_has_value = _Left.has_value();
    return _Left_has_value == _Right.has_value() && (!_Left_has_value || *_Left == *_Right);
}

template <class _Ty1, class _Ty2>
[[nodiscard]] constexpr bool operator!=(const optional<_Ty1>& _Left, const optional<_Ty2>& _Right) {
    const bool _Left_has_value = _Left.has_value();
    return _Left_has_value != _Right.has_value() || (_Left_has_value && *_Left != *_Right);
}

template <class _Ty1, class _Ty2>
[[nodiscard]] constexpr bool operator<(const optional<_Ty1>& _Left, const optional<_Ty2>& _Right) {
    return _Right.has_value() && (!_Left.has_value() || *_Left < *_Right);
}

template <class _Ty1, class _Ty2>
[[nodiscard]] constexpr bool operator>(const optional<_Ty1>& _Left, const optional<_Ty2>& _Right) {
    return _Left.has_value() && (!_Right.has_value() || *_Left > *_Right);
}

template <class _Ty1, class _Ty2>
[[nodiscard]] constexpr bool operator<=(const optional<_Ty1>& _Left, const optional<_Ty2>& _Right) {
    return !_Left.has_value() || (_Right.has_value() && *_Left <= *_Right);
}

template <class _Ty1, class _Ty2>
[[nodiscard]] constexpr bool operator>=(const optional<_Ty1>& _Left, const optional<_Ty2>& _Right) {
    return !_Right.has_value() || (_Left.has_value() && *_Left >= *_Right);
}


template <class _Ty1, three_way_comparable_with<_Ty1> _Ty2>
[[nodiscard]] constexpr compare_three_way_result_t<_Ty1, _Ty2> operator<=>(
    const optional<_Ty1>& _Left, const optional<_Ty2>& _Right) {
    if (_Left && _Right) {
        return *_Left <=> *_Right;
    }

    return _Left.has_value() <=> _Right.has_value();
}
#line 690 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\optional"

template <class _Ty>
[[nodiscard]] constexpr bool operator==(const optional<_Ty>& _Left, nullopt_t) noexcept {
    return !_Left.has_value();
}


template <class _Ty>
[[nodiscard]] constexpr strong_ordering operator<=>(const optional<_Ty>& _Left, nullopt_t) noexcept {
    return _Left.has_value() <=> false;
}


#line 752 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\optional"

template <class _Ty>
using _Enable_if_bool_convertible = enable_if_t<is_convertible_v<_Ty, bool>, int>;

template <class _Lhs, class _Rhs>
using _Enable_if_comparable_with_equal =
    _Enable_if_bool_convertible<decltype(::std:: declval<const _Lhs&>() == ::std:: declval<const _Rhs&>())>;

template <class _Lhs, class _Rhs>
using _Enable_if_comparable_with_not_equal =
    _Enable_if_bool_convertible<decltype(::std:: declval<const _Lhs&>() != ::std:: declval<const _Rhs&>())>;

template <class _Lhs, class _Rhs>
using _Enable_if_comparable_with_less =
    _Enable_if_bool_convertible<decltype(::std:: declval<const _Lhs&>() < ::std:: declval<const _Rhs&>())>;

template <class _Lhs, class _Rhs>
using _Enable_if_comparable_with_greater =
    _Enable_if_bool_convertible<decltype(::std:: declval<const _Lhs&>() > ::std:: declval<const _Rhs&>())>;

template <class _Lhs, class _Rhs>
using _Enable_if_comparable_with_less_equal =
    _Enable_if_bool_convertible<decltype(::std:: declval<const _Lhs&>() <= ::std:: declval<const _Rhs&>())>;

template <class _Lhs, class _Rhs>
using _Enable_if_comparable_with_greater_equal =
    _Enable_if_bool_convertible<decltype(::std:: declval<const _Lhs&>() >= ::std:: declval<const _Rhs&>())>;

template <class _Ty1, class _Ty2, _Enable_if_comparable_with_equal<_Ty1, _Ty2> = 0>
[[nodiscard]] constexpr bool operator==(const optional<_Ty1>& _Left, const _Ty2& _Right) {
    return _Left ? *_Left == _Right : false;
}

template <class _Ty1, class _Ty2, _Enable_if_comparable_with_equal<_Ty1, _Ty2> = 0>
[[nodiscard]] constexpr bool operator==(const _Ty1& _Left, const optional<_Ty2>& _Right) {
    return _Right ? _Left == *_Right : false;
}

template <class _Ty1, class _Ty2, _Enable_if_comparable_with_not_equal<_Ty1, _Ty2> = 0>
[[nodiscard]] constexpr bool operator!=(const optional<_Ty1>& _Left, const _Ty2& _Right) {
    return _Left ? *_Left != _Right : true;
}
template <class _Ty1, class _Ty2, _Enable_if_comparable_with_not_equal<_Ty1, _Ty2> = 0>
[[nodiscard]] constexpr bool operator!=(const _Ty1& _Left, const optional<_Ty2>& _Right) {
    return _Right ? _Left != *_Right : true;
}

template <class _Ty1, class _Ty2, _Enable_if_comparable_with_less<_Ty1, _Ty2> = 0>
[[nodiscard]] constexpr bool operator<(const optional<_Ty1>& _Left, const _Ty2& _Right) {
    return _Left ? *_Left < _Right : true;
}
template <class _Ty1, class _Ty2, _Enable_if_comparable_with_less<_Ty1, _Ty2> = 0>
[[nodiscard]] constexpr bool operator<(const _Ty1& _Left, const optional<_Ty2>& _Right) {
    return _Right ? _Left < *_Right : false;
}

template <class _Ty1, class _Ty2, _Enable_if_comparable_with_greater<_Ty1, _Ty2> = 0>
[[nodiscard]] constexpr bool operator>(const optional<_Ty1>& _Left, const _Ty2& _Right) {
    return _Left ? *_Left > _Right : false;
}
template <class _Ty1, class _Ty2, _Enable_if_comparable_with_greater<_Ty1, _Ty2> = 0>
[[nodiscard]] constexpr bool operator>(const _Ty1& _Left, const optional<_Ty2>& _Right) {
    return _Right ? _Left > *_Right : true;
}

template <class _Ty1, class _Ty2, _Enable_if_comparable_with_less_equal<_Ty1, _Ty2> = 0>
[[nodiscard]] constexpr bool operator<=(const optional<_Ty1>& _Left, const _Ty2& _Right) {
    return _Left ? *_Left <= _Right : true;
}
template <class _Ty1, class _Ty2, _Enable_if_comparable_with_less_equal<_Ty1, _Ty2> = 0>
[[nodiscard]] constexpr bool operator<=(const _Ty1& _Left, const optional<_Ty2>& _Right) {
    return _Right ? _Left <= *_Right : false;
}

template <class _Ty1, class _Ty2, _Enable_if_comparable_with_greater_equal<_Ty1, _Ty2> = 0>
[[nodiscard]] constexpr bool operator>=(const optional<_Ty1>& _Left, const _Ty2& _Right) {
    return _Left ? *_Left >= _Right : false;
}
template <class _Ty1, class _Ty2, _Enable_if_comparable_with_greater_equal<_Ty1, _Ty2> = 0>
[[nodiscard]] constexpr bool operator>=(const _Ty1& _Left, const optional<_Ty2>& _Right) {
    return _Right ? _Left >= *_Right : true;
}


template <class _Ty1, class _Ty2>
    requires (!_Is_specialization_v<_Ty2, optional>)
        && three_way_comparable_with<_Ty1, _Ty2>
[[nodiscard]] constexpr compare_three_way_result_t<_Ty1, _Ty2>
    operator<=>(const optional<_Ty1>& _Left, const _Ty2& _Right) {
    
    if (_Left) {
        return *_Left <=> _Right;
    }

    return strong_ordering::less;
}
#line 850 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\optional"

template <class _Ty, enable_if_t<is_move_constructible_v<_Ty> && is_swappable_v<_Ty>, int> = 0>
constexpr void swap(optional<_Ty>& _Left, optional<_Ty>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
    _Left.swap(_Right);
}

template <class _Ty>
[[nodiscard]] constexpr optional<decay_t<_Ty>> make_optional(_Ty&& _Value) {
    return optional<decay_t<_Ty>>{::std:: forward<_Ty>(_Value)};
}
template <class _Ty, class... _Types>
[[nodiscard]] constexpr optional<_Ty> make_optional(_Types&&... _Args) {
    return optional<_Ty>{in_place, ::std:: forward<_Types>(_Args)...};
}
template <class _Ty, class _Elem, class... _Types>
[[nodiscard]] constexpr optional<_Ty> make_optional(initializer_list<_Elem> _Ilist, _Types&&... _Args) {
    return optional<_Ty>{in_place, _Ilist, ::std:: forward<_Types>(_Args)...};
}

template <class _Ty>
struct hash<optional<_Ty>>
    : _Conditionally_enabled_hash<optional<_Ty>, is_default_constructible_v<hash<remove_const_t<_Ty>>>> {
    static size_t _Do_hash(const optional<_Ty>& _Opt) noexcept(_Is_nothrow_hashable<remove_const_t<_Ty>>::value) {
        constexpr size_t _Unspecified_value = 0;
        if (_Opt) {
            return hash<remove_const_t<_Ty>>{}(*_Opt);
        }

        return _Unspecified_value;
    }
};

}


#pragma warning(pop)
#pragma pack(pop)
#line 889 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\optional"
#line 890 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\optional"
#line 891 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\optional"
#line 28 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sstream"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\string"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
template <class _Elem, class _Traits, class _Alloc>
basic_istream<_Elem, _Traits>& getline(basic_istream<_Elem, _Traits>&& _Istr,
    basic_string<_Elem, _Traits, _Alloc>& _Str,
    const _Elem _Delim) { 
    using _Myis = basic_istream<_Elem, _Traits>;

    typename _Myis::iostate _State = _Myis::goodbit;
    bool _Changed                  = false;
    const typename _Myis::sentry _Ok(_Istr, true);

    if (_Ok) { 
        try {
        _Str.erase();
        const typename _Traits::int_type _Metadelim = _Traits::to_int_type(_Delim);
        typename _Traits::int_type _Meta            = _Istr.rdbuf()->sgetc();

        for (;; _Meta = _Istr.rdbuf()->snextc()) {
            if (_Traits::eq_int_type(_Traits::eof(), _Meta)) { 
                _State |= _Myis::eofbit;
                break;
            } else if (_Traits::eq_int_type(_Meta, _Metadelim)) { 
                _Changed = true;
                _Istr.rdbuf()->sbumpc();
                break;
            } else if (_Str.max_size() <= _Str.size()) { 
                _State |= _Myis::failbit;
                break;
            } else { 
                _Str += _Traits::to_char_type(_Meta);
                _Changed = true;
            }
        }
        } catch (...) { (_Istr) .setstate(_Myis::badbit, true); }
    }

    if (!_Changed) {
        _State |= _Myis::failbit;
    }

    _Istr.setstate(_State);
    return static_cast<basic_istream<_Elem, _Traits>&>(_Istr);
}

template <class _Elem, class _Traits, class _Alloc>
basic_istream<_Elem, _Traits>& getline(basic_istream<_Elem, _Traits>&& _Istr,
    basic_string<_Elem, _Traits, _Alloc>& _Str) { 
    return getline(_Istr, _Str, _Istr.widen('\n'));
}

template <class _Elem, class _Traits, class _Alloc>
basic_istream<_Elem, _Traits>& getline(basic_istream<_Elem, _Traits>& _Istr, basic_string<_Elem, _Traits, _Alloc>& _Str,
    const _Elem _Delim) { 
    return getline(::std:: move(_Istr), _Str, _Delim);
}

template <class _Elem, class _Traits, class _Alloc>
basic_istream<_Elem, _Traits>& getline(basic_istream<_Elem, _Traits>& _Istr,
    basic_string<_Elem, _Traits, _Alloc>& _Str) { 
    return getline(::std:: move(_Istr), _Str, _Istr.widen('\n'));
}

[[nodiscard]] inline int stoi(const string& _Str, size_t* _Idx = nullptr, int _Base = 10) {
    
    int& _Errno_ref  = (*_errno()); 
    const char* _Ptr = _Str.c_str();
    char* _Eptr;
    _Errno_ref      = 0;
    const long _Ans = :: strtol(_Ptr, &_Eptr, _Base);

    if (_Ptr == _Eptr) {
        _Xinvalid_argument("invalid stoi argument");
    }

    if (_Errno_ref == 34) {
        _Xout_of_range("stoi argument out of range");
    }

    if (_Idx) {
        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
    }

    return static_cast<int>(_Ans);
}

[[nodiscard]] inline long stol(const string& _Str, size_t* _Idx = nullptr, int _Base = 10) {
    
    int& _Errno_ref  = (*_errno()); 
    const char* _Ptr = _Str.c_str();
    char* _Eptr;
    _Errno_ref      = 0;
    const long _Ans = :: strtol(_Ptr, &_Eptr, _Base);

    if (_Ptr == _Eptr) {
        _Xinvalid_argument("invalid stol argument");
    }

    if (_Errno_ref == 34) {
        _Xout_of_range("stol argument out of range");
    }

    if (_Idx) {
        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
    }

    return _Ans;
}

[[nodiscard]] inline unsigned long stoul(const string& _Str, size_t* _Idx = nullptr, int _Base = 10) {
    
    int& _Errno_ref  = (*_errno()); 
    const char* _Ptr = _Str.c_str();
    char* _Eptr;
    _Errno_ref               = 0;
    const unsigned long _Ans = :: strtoul(_Ptr, &_Eptr, _Base);

    if (_Ptr == _Eptr) {
        _Xinvalid_argument("invalid stoul argument");
    }

    if (_Errno_ref == 34) {
        _Xout_of_range("stoul argument out of range");
    }

    if (_Idx) {
        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
    }

    return _Ans;
}

[[nodiscard]] inline long long stoll(const string& _Str, size_t* _Idx = nullptr, int _Base = 10) {
    
    int& _Errno_ref  = (*_errno()); 
    const char* _Ptr = _Str.c_str();
    char* _Eptr;
    _Errno_ref           = 0;
    const long long _Ans = :: strtoll(_Ptr, &_Eptr, _Base);

    if (_Ptr == _Eptr) {
        _Xinvalid_argument("invalid stoll argument");
    }

    if (_Errno_ref == 34) {
        _Xout_of_range("stoll argument out of range");
    }

    if (_Idx) {
        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
    }

    return _Ans;
}

[[nodiscard]] inline unsigned long long stoull(const string& _Str, size_t* _Idx = nullptr, int _Base = 10) {
    
    int& _Errno_ref  = (*_errno()); 
    const char* _Ptr = _Str.c_str();
    char* _Eptr;
    _Errno_ref                    = 0;
    const unsigned long long _Ans = :: strtoull(_Ptr, &_Eptr, _Base);

    if (_Ptr == _Eptr) {
        _Xinvalid_argument("invalid stoull argument");
    }

    if (_Errno_ref == 34) {
        _Xout_of_range("stoull argument out of range");
    }

    if (_Idx) {
        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
    }

    return _Ans;
}

[[nodiscard]] inline float stof(const string& _Str, size_t* _Idx = nullptr) { 
    int& _Errno_ref  = (*_errno()); 
    const char* _Ptr = _Str.c_str();
    char* _Eptr;
    _Errno_ref       = 0;
    const float _Ans = :: strtof(_Ptr, &_Eptr);

    if (_Ptr == _Eptr) {
        _Xinvalid_argument("invalid stof argument");
    }

    if (_Errno_ref == 34) {
        _Xout_of_range("stof argument out of range");
    }

    if (_Idx) {
        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
    }

    return _Ans;
}

[[nodiscard]] inline double stod(const string& _Str, size_t* _Idx = nullptr) { 
    int& _Errno_ref  = (*_errno()); 
    const char* _Ptr = _Str.c_str();
    char* _Eptr;
    _Errno_ref        = 0;
    const double _Ans = :: strtod(_Ptr, &_Eptr);

    if (_Ptr == _Eptr) {
        _Xinvalid_argument("invalid stod argument");
    }

    if (_Errno_ref == 34) {
        _Xout_of_range("stod argument out of range");
    }

    if (_Idx) {
        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
    }

    return _Ans;
}

[[nodiscard]] inline long double stold(const string& _Str, size_t* _Idx = nullptr) { 
    int& _Errno_ref  = (*_errno()); 
    const char* _Ptr = _Str.c_str();
    char* _Eptr;
    _Errno_ref             = 0;
    const long double _Ans = :: strtold(_Ptr, &_Eptr);

    if (_Ptr == _Eptr) {
        _Xinvalid_argument("invalid stold argument");
    }

    if (_Errno_ref == 34) {
        _Xout_of_range("stold argument out of range");
    }

    if (_Idx) {
        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
    }

    return _Ans;
}

[[nodiscard]] inline int stoi(const wstring& _Str, size_t* _Idx = nullptr, int _Base = 10) {
    
    int& _Errno_ref     = (*_errno()); 
    const wchar_t* _Ptr = _Str.c_str();
    wchar_t* _Eptr;
    _Errno_ref      = 0;
    const long _Ans = :: wcstol(_Ptr, &_Eptr, _Base);

    if (_Ptr == _Eptr) {
        _Xinvalid_argument("invalid stoi argument");
    }

    if (_Errno_ref == 34) {
        _Xout_of_range("stoi argument out of range");
    }

    if (_Idx) {
        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
    }

    return static_cast<int>(_Ans);
}

[[nodiscard]] inline long stol(const wstring& _Str, size_t* _Idx = nullptr, int _Base = 10) {
    
    int& _Errno_ref     = (*_errno()); 
    const wchar_t* _Ptr = _Str.c_str();
    wchar_t* _Eptr;
    _Errno_ref      = 0;
    const long _Ans = :: wcstol(_Ptr, &_Eptr, _Base);

    if (_Ptr == _Eptr) {
        _Xinvalid_argument("invalid stol argument");
    }

    if (_Errno_ref == 34) {
        _Xout_of_range("stol argument out of range");
    }

    if (_Idx) {
        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
    }

    return _Ans;
}

[[nodiscard]] inline unsigned long stoul(const wstring& _Str, size_t* _Idx = nullptr, int _Base = 10) {
    
    int& _Errno_ref     = (*_errno()); 
    const wchar_t* _Ptr = _Str.c_str();
    wchar_t* _Eptr;
    _Errno_ref               = 0;
    const unsigned long _Ans = :: wcstoul(_Ptr, &_Eptr, _Base);

    if (_Ptr == _Eptr) {
        _Xinvalid_argument("invalid stoul argument");
    }

    if (_Errno_ref == 34) {
        _Xout_of_range("stoul argument out of range");
    }

    if (_Idx) {
        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
    }

    return _Ans;
}

[[nodiscard]] inline long long stoll(const wstring& _Str, size_t* _Idx = nullptr, int _Base = 10) {
    
    int& _Errno_ref     = (*_errno()); 
    const wchar_t* _Ptr = _Str.c_str();
    wchar_t* _Eptr;
    _Errno_ref           = 0;
    const long long _Ans = :: wcstoll(_Ptr, &_Eptr, _Base);

    if (_Ptr == _Eptr) {
        _Xinvalid_argument("invalid stoll argument");
    }

    if (_Errno_ref == 34) {
        _Xout_of_range("stoll argument out of range");
    }

    if (_Idx) {
        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
    }

    return _Ans;
}

[[nodiscard]] inline unsigned long long stoull(const wstring& _Str, size_t* _Idx = nullptr, int _Base = 10) {
    
    int& _Errno_ref     = (*_errno()); 
    const wchar_t* _Ptr = _Str.c_str();
    wchar_t* _Eptr;
    _Errno_ref                    = 0;
    const unsigned long long _Ans = :: wcstoull(_Ptr, &_Eptr, _Base);

    if (_Ptr == _Eptr) {
        _Xinvalid_argument("invalid stoull argument");
    }

    if (_Errno_ref == 34) {
        _Xout_of_range("stoull argument out of range");
    }

    if (_Idx) {
        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
    }

    return _Ans;
}

[[nodiscard]] inline float stof(const wstring& _Str, size_t* _Idx = nullptr) { 
    int& _Errno_ref     = (*_errno()); 
    const wchar_t* _Ptr = _Str.c_str();
    wchar_t* _Eptr;
    _Errno_ref       = 0;
    const float _Ans = :: wcstof(_Ptr, &_Eptr);

    if (_Ptr == _Eptr) {
        _Xinvalid_argument("invalid stof argument");
    }

    if (_Errno_ref == 34) {
        _Xout_of_range("stof argument out of range");
    }

    if (_Idx) {
        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
    }

    return _Ans;
}

[[nodiscard]] inline double stod(const wstring& _Str, size_t* _Idx = nullptr) { 
    int& _Errno_ref     = (*_errno()); 
    const wchar_t* _Ptr = _Str.c_str();
    wchar_t* _Eptr;
    _Errno_ref        = 0;
    const double _Ans = :: wcstod(_Ptr, &_Eptr);

    if (_Ptr == _Eptr) {
        _Xinvalid_argument("invalid stod argument");
    }

    if (_Errno_ref == 34) {
        _Xout_of_range("stod argument out of range");
    }

    if (_Idx) {
        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
    }

    return _Ans;
}

[[nodiscard]] inline long double stold(const wstring& _Str, size_t* _Idx = nullptr) { 
    int& _Errno_ref     = (*_errno()); 
    const wchar_t* _Ptr = _Str.c_str();
    wchar_t* _Eptr;
    _Errno_ref             = 0;
    const long double _Ans = :: wcstold(_Ptr, &_Eptr);

    if (_Ptr == _Eptr) {
        _Xinvalid_argument("invalid stold argument");
    }

    if (_Errno_ref == 34) {
        _Xout_of_range("stold argument out of range");
    }

    if (_Idx) {
        *_Idx = static_cast<size_t>(_Eptr - _Ptr);
    }

    return _Ans;
}

template <class _Elem, class _UTy>
[[nodiscard]] _Elem* _UIntegral_to_buff(_Elem* _RNext, _UTy _UVal) { 
    static_assert(is_unsigned_v<_UTy>, "_UTy must be unsigned");


    constexpr bool _Big_uty = sizeof(_UTy) > 4;
    if constexpr (_Big_uty) { 
        while (_UVal > 0xFFFFFFFFU) {
            auto _UVal_chunk = static_cast<unsigned long>(_UVal % 1000000000);
            _UVal /= 1000000000;

            for (int _Idx = 0; _Idx != 9; ++_Idx) {
                *--_RNext = static_cast<_Elem>('0' + _UVal_chunk % 10);
                _UVal_chunk /= 10;
            }
        }
    }

    auto _UVal_trunc = static_cast<unsigned long>(_UVal);
#line 471 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\string"

    do {
        *--_RNext = static_cast<_Elem>('0' + _UVal_trunc % 10);
        _UVal_trunc /= 10;
    } while (_UVal_trunc != 0);
    return _RNext;
}

template <class _Elem, class _Ty>
[[nodiscard]] basic_string<_Elem> _Integral_to_string(const _Ty _Val) { 
    static_assert(is_integral_v<_Ty>, "_Ty must be integral");
    using _UTy = make_unsigned_t<_Ty>;
    _Elem _Buff[21]; 
    _Elem* const _Buff_end = ::std:: end(_Buff);
    _Elem* _RNext          = _Buff_end;
    const auto _UVal       = static_cast<_UTy>(_Val);
    if (_Val < 0) {
        _RNext    = _UIntegral_to_buff(_RNext, 0 - _UVal);
        *--_RNext = '-';
    } else {
        _RNext = _UIntegral_to_buff(_RNext, _UVal);
    }

    return basic_string<_Elem>(_RNext, _Buff_end);
}


template <class _Elem, class _Ty>
[[nodiscard]] basic_string<_Elem> _UIntegral_to_string(const _Ty _Val) { 
    static_assert(is_integral_v<_Ty>, "_Ty must be integral");
    static_assert(is_unsigned_v<_Ty>, "_Ty must be unsigned");
    _Elem _Buff[21]; 
    _Elem* const _Buff_end = ::std:: end(_Buff);
    _Elem* const _RNext    = _UIntegral_to_buff(_Buff_end, _Val);
    return basic_string<_Elem>(_RNext, _Buff_end);
}

[[nodiscard]] inline string to_string(int _Val) { 
    return _Integral_to_string<char>(_Val);
}

[[nodiscard]] inline string to_string(unsigned int _Val) { 
    return _UIntegral_to_string<char>(_Val);
}

[[nodiscard]] inline string to_string(long _Val) { 
    return _Integral_to_string<char>(_Val);
}

[[nodiscard]] inline string to_string(unsigned long _Val) { 
    return _UIntegral_to_string<char>(_Val);
}

[[nodiscard]] inline string to_string(long long _Val) { 
    return _Integral_to_string<char>(_Val);
}

[[nodiscard]] inline string to_string(unsigned long long _Val) { 
    return _UIntegral_to_string<char>(_Val);
}

[[nodiscard]] inline string to_string(double _Val) { 
    const auto _Len = static_cast<size_t>(:: _scprintf("%f", _Val));
    string _Str(_Len, '\0');
    :: sprintf_s(&_Str[0], _Len + 1, "%f", _Val);
    return _Str;
}

[[nodiscard]] inline string to_string(float _Val) { 
    return ::std:: to_string(static_cast<double>(_Val));
}

[[nodiscard]] inline string to_string(long double _Val) { 
    return ::std:: to_string(static_cast<double>(_Val));
}

[[nodiscard]] inline wstring to_wstring(int _Val) { 
    return _Integral_to_string<wchar_t>(_Val);
}

[[nodiscard]] inline wstring to_wstring(unsigned int _Val) { 
    return _UIntegral_to_string<wchar_t>(_Val);
}

[[nodiscard]] inline wstring to_wstring(long _Val) { 
    return _Integral_to_string<wchar_t>(_Val);
}

[[nodiscard]] inline wstring to_wstring(unsigned long _Val) { 
    return _UIntegral_to_string<wchar_t>(_Val);
}

[[nodiscard]] inline wstring to_wstring(long long _Val) { 
    return _Integral_to_string<wchar_t>(_Val);
}

[[nodiscard]] inline wstring to_wstring(unsigned long long _Val) { 
    return _UIntegral_to_string<wchar_t>(_Val);
}

[[nodiscard]] inline wstring to_wstring(double _Val) { 
    const auto _Len = static_cast<size_t>(:: _scwprintf(L"%f", _Val));
    wstring _Str(_Len, L'\0');
    :: swprintf_s(&_Str[0], _Len + 1, L"%f", _Val);
    return _Str;
}

[[nodiscard]] inline wstring to_wstring(float _Val) { 
    return ::std:: to_wstring(static_cast<double>(_Val));
}

[[nodiscard]] inline wstring to_wstring(long double _Val) { 
    return ::std:: to_wstring(static_cast<double>(_Val));
}
}


#pragma warning(pop)
#pragma pack(pop)
#line 592 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\string"
#line 593 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\string"
#line 13 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sstream"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {

template <class _Elem, class _Traits, class _Alloc>
class basic_stringbuf
    : public basic_streambuf<_Elem, _Traits> { 
public:
    using allocator_type = _Alloc;
    using _Mysb          = basic_streambuf<_Elem, _Traits>;
    using _Mystr         = basic_string<_Elem, _Traits, _Alloc>;
    using _Mysize_type   = typename _Mystr::size_type;


    using _Mystr_view = basic_string_view<_Elem, _Traits>;
#line 34 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sstream"

    basic_stringbuf() : _Seekhigh(nullptr), _Mystate(_Getstate(ios_base::in | ios_base::out)), _Al() {}

    explicit basic_stringbuf(ios_base::openmode _Mode) : _Seekhigh(nullptr), _Mystate(_Getstate(_Mode)), _Al() {}

    explicit basic_stringbuf(const _Mystr& _Str, ios_base::openmode _Mode = ios_base::in | ios_base::out)
        : _Al(_Str.get_allocator()) {
        _Init(_Str.c_str(), _Str.size(), _Getstate(_Mode));
    }


    explicit basic_stringbuf(const _Alloc& _Al_) : basic_stringbuf(ios_base::in | ios_base::out, _Al_) {}

    basic_stringbuf(ios_base::openmode _Mode, const _Alloc& _Al_)
        : _Seekhigh(nullptr), _Mystate(_Getstate(_Mode)), _Al(_Al_) {}

    explicit basic_stringbuf(_Mystr&& _Str, ios_base::openmode _Mode = ios_base::in | ios_base::out)
        : _Al(::std:: move(_Str._Getal())) {
        _Init_string_inplace(::std:: move(_Str), _Getstate(_Mode));
    }

    template <class _Alloc2>
    basic_stringbuf(const basic_string<_Elem, _Traits, _Alloc2>& _Str, ios_base::openmode _Mode, const _Alloc& _Al_)
        : _Al(_Al_) {
        _Init(_Str.c_str(), _Str.size(), _Getstate(_Mode));
    }

    template <class _Alloc2>
    basic_stringbuf(const basic_string<_Elem, _Traits, _Alloc2>& _Str, const _Alloc& _Al_)
        : basic_stringbuf(_Str, ios_base::in | ios_base::out, _Al_) {}

    template <class _Alloc2, enable_if_t<!is_same_v<_Alloc2, _Alloc>, int> = 0>
    explicit basic_stringbuf(
        const basic_string<_Elem, _Traits, _Alloc2>& _Str, ios_base::openmode _Mode = ios_base::in | ios_base::out)
        : basic_stringbuf(_Str, _Mode, _Alloc{}) {}

    basic_stringbuf(basic_stringbuf&& _Right, const _Alloc& _Al_) : _Al(_Al_) {
        _Assign_rv(::std:: move(_Right));
    }
#line 74 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sstream"

    basic_stringbuf(basic_stringbuf&& _Right) {
        _Assign_rv(::std:: move(_Right));
    }

    basic_stringbuf& operator=(basic_stringbuf&& _Right) {
        _Assign_rv(::std:: move(_Right));
        return *this;
    }

    void _Assign_rv(basic_stringbuf&& _Right) {
        if (this != ::std:: addressof(_Right)) {
            _Tidy();
            this->swap(_Right);
        }
    }

    void swap(basic_stringbuf& _Right) noexcept  {
        if (this != ::std:: addressof(_Right)) {
            if constexpr (!allocator_traits<_Alloc>::propagate_on_container_swap::value) {
                ;
#line 96 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sstream"
            }

            _Mysb::swap(_Right);
            ::std:: swap(_Seekhigh, _Right._Seekhigh);
            ::std:: swap(_Mystate, _Right._Mystate);
            
            _Pocs(_Al, _Right._Al);
        }
    }

    basic_stringbuf(const basic_stringbuf&) = delete;
    basic_stringbuf& operator=(const basic_stringbuf&) = delete;

    ~basic_stringbuf() noexcept override {
        _Tidy();
    }

    enum { 
        _Allocated   = 1, 
        _Constant    = 2, 
        _Noread      = 4, 
        _Append      = 8, 
        _Atend       = 16, 
        _From_rvalue = 32 
    };

    using int_type = typename _Traits::int_type;
    using pos_type = typename _Traits::pos_type;
    using off_type = typename _Traits::off_type;

    struct _Buffer_view {
        _Elem* _Ptr;
        _Mysize_type _Size;
        _Mysize_type _Res;
    };

    [[nodiscard]] _Buffer_view _Get_buffer_view() const noexcept {
        _Buffer_view _Result{};
        if ((!(_Mystate & _Constant) || (_Mystate & _From_rvalue)) && _Mysb::pptr()) {
            
            const auto _Base = _Mysb::pbase();
            _Result._Ptr     = _Base;
            _Result._Size    = static_cast<_Mysize_type>((::std:: max)(_Mysb::pptr(), _Seekhigh) - _Base);
            _Result._Res     = static_cast<_Mysize_type>(_Mysb::epptr() - _Base);
        } else if (!(_Mystate & _Noread) && _Mysb::gptr()) {
            
            const auto _Base = _Mysb::eback();
            _Result._Ptr     = _Base;
            _Result._Size    = static_cast<_Mysize_type>(_Mysb::egptr() - _Base);
            _Result._Res     = _Result._Size;
        }
        return _Result;
    }


    [[nodiscard]] _Mystr str() const&


#line 155 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sstream"
    {
        _Mystr _Result(_Al);
        const auto _View = _Get_buffer_view();
        if (_View._Ptr) {
            _Result.assign(_View._Ptr, _View._Size);
        }
        return _Result;
    }

    void str(const _Mystr& _Newstr) { 
        _Tidy();
        _Init(_Newstr.c_str(), _Newstr.size(), _Mystate);
    }


    template <class _Alloc2, enable_if_t<_Is_allocator<_Alloc2>::value, int> = 0>
    [[nodiscard]] basic_string<_Elem, _Traits, _Alloc2> str(const _Alloc2& _Al) const {
        return basic_string<_Elem, _Traits, _Alloc2>{view(), _Al};
    }

    
    [[nodiscard]] _Mystr str() && {
        _Mystr _Result{_String_constructor_rvalue_allocator_tag{}, ::std:: move(_Al)};
        const auto _View = _Get_buffer_view();
        
        
        if (_View._Size == _View._Res) {
            
            _Result.assign(_View._Ptr, _View._Size);
        } else {
            _Traits::assign(_View._Ptr[_View._Size], _Elem());
            if (_Result._Move_assign_from_buffer(_View._Ptr, _View._Size, _View._Res)) {
                _Mystate &= ~_Allocated;
            }
        }

        _Tidy();
        return _Result;
    }

    [[nodiscard]] _Mystr_view view() const noexcept {
        const auto _View = _Get_buffer_view();
        return _Mystr_view{_View._Ptr, _View._Size};
    }

    template <class _Alloc2, enable_if_t<!is_same_v<_Alloc2, _Alloc>, int> = 0>
    void str(const basic_string<_Elem, _Traits, _Alloc2>& _Newstr) {
        _Tidy();
        _Init(_Newstr.c_str(), _Newstr.size(), _Mystate);
    }

    void str(_Mystr&& _Newstr) {
        auto& _Newstr_al          = _Newstr._Getal();
        constexpr auto _Pocma_val = _Choose_pocma_v<_Alloc>;
        if constexpr (_Pocma_val == _Pocma_values::_No_propagate_allocators) {
            if (_Al != _Newstr_al) {
                _Tidy();
                _Init(_Newstr.c_str(), _Newstr.size(), _Mystate);
                return;
            }
        }

        _Tidy();
        _Pocma(_Al, _Newstr_al);
        _Init_string_inplace(::std:: move(_Newstr), _Mystate);
    }

    [[nodiscard]] allocator_type get_allocator() const noexcept {
        return _Al;
    }
#line 228 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sstream"

protected:
    int_type overflow(int_type _Meta = _Traits::eof()) override { 
        if (_Mystate & _Constant) {
            return _Traits::eof(); 
        }

        if (_Traits::eq_int_type(_Traits::eof(), _Meta)) {
            return _Traits::not_eof(_Meta); 
        }

        const auto _Pptr  = _Mysb::pptr();
        const auto _Epptr = _Mysb::epptr();
        if (_Pptr && _Pptr < _Epptr) { 
            *_Mysb::_Pninc() = _Traits::to_char_type(_Meta);
            _Seekhigh        = _Pptr + 1;
            return _Meta;
        }

        
        size_t _Oldsize    = 0;
        const auto _Oldptr = _Mysb::eback();
        if (_Pptr) {
            _Oldsize = static_cast<size_t>(_Epptr - _Oldptr);
        }

        size_t _Newsize;
        if (_Oldsize < _MINSIZE) {
            _Newsize = _MINSIZE;
        } else if (_Oldsize < 2147483647 / 2) { 
            _Newsize = _Oldsize << 1;
        } else if (_Oldsize < 2147483647) {
            _Newsize = 2147483647;
        } else { 
            return _Traits::eof();
        }

        const auto _Newptr = _Unfancy(_Al.allocate(_Newsize));
        _Traits::copy(_Newptr, _Oldptr, _Oldsize);

        const auto _New_pnext = _Newptr + _Oldsize;
        _Seekhigh             = _New_pnext + 1; 

        _Mysb::setp(_Newptr, _New_pnext, _Newptr + _Newsize);
        if (_Mystate & _Noread) { 
            _Mysb::setg(_Newptr, nullptr, _Newptr);
        } else { 
            _Mysb::setg(_Newptr, _Newptr + (_Mysb::gptr() - _Oldptr), _Seekhigh);
        }

        if (_Mystate & _Allocated) {
            _Al.deallocate(_Ptr_traits::pointer_to(*_Oldptr), _Oldsize);
        }

        _Mystate |= _Allocated;
        *_Mysb::_Pninc() = _Traits::to_char_type(_Meta);
        return _Meta;
    }

    int_type pbackfail(int_type _Meta = _Traits::eof()) override { 
        const auto _Gptr = _Mysb::gptr();
        if (!_Gptr || _Gptr <= _Mysb::eback()
            || (!_Traits::eq_int_type(_Traits::eof(), _Meta) && !_Traits::eq(_Traits::to_char_type(_Meta), _Gptr[-1])
                && (_Mystate & _Constant))) { 
            return _Traits::eof();
        }

        
        _Mysb::gbump(-1);
        if (!_Traits::eq_int_type(_Traits::eof(), _Meta)) {
            *_Mysb::gptr() = _Traits::to_char_type(_Meta);
        }

        return _Traits::not_eof(_Meta);
    }

    int_type underflow() override { 
        const auto _Gptr = _Mysb::gptr();
        if (!_Gptr) { 
            return _Traits::eof();
        }

        if (_Gptr < _Mysb::egptr()) {
            return _Traits::to_int_type(*_Gptr);
        }

        
        const auto _Pptr = _Mysb::pptr();
        if (!_Pptr || (_Mystate & _Noread)) { 
            return _Traits::eof();
        }

        const auto _Local_highwater = (::std:: max)(_Seekhigh, _Pptr);
        if (_Local_highwater <= _Gptr) { 
            return _Traits::eof();
        }

        _Seekhigh = _Local_highwater;
        _Mysb::setg(_Mysb::eback(), _Mysb::gptr(), _Local_highwater);
        return _Traits::to_int_type(*_Mysb::gptr());
    }

    pos_type seekoff(
        off_type _Off, ios_base::seekdir _Way, ios_base::openmode _Mode = ios_base::in | ios_base::out) override {
        
        const auto _Gptr_old = _Mysb::gptr();
        const auto _Pptr_old = (_Mystate & _Constant) ? nullptr : _Mysb::pptr();
        if (_Pptr_old && _Seekhigh < _Pptr_old) { 
            _Seekhigh = _Pptr_old;
        }

        const auto _Seeklow  = _Mysb::eback();
        const auto _Seekdist = _Seekhigh - _Seeklow;
        off_type _Newoff;
        switch (_Way) {
        case ios_base::beg:
            _Newoff = 0;
            break;
        case ios_base::end:
            _Newoff = _Seekdist;
            break;
        case ios_base::cur:
            {
                constexpr auto _Both = ios_base::in | ios_base::out;
                if ((_Mode & _Both)
                    != _Both) { 
                    if (_Mode & ios_base::in) {
                        if (_Gptr_old || !_Seeklow) {
                            _Newoff = _Gptr_old - _Seeklow;
                            break;
                        }
                    } else if ((_Mode & ios_base::out) && (_Pptr_old || !_Seeklow)) {
                        _Newoff = _Pptr_old - _Seeklow;
                        break;
                    }
                }
            }

            
        default:
            return pos_type(off_type(-1));
        }

        if (static_cast<unsigned long long>(_Off) + _Newoff > static_cast<unsigned long long>(_Seekdist)) {
            return pos_type(off_type(-1));
        }

        _Off += _Newoff;
        if (_Off != 0 && (((_Mode & ios_base::in) && !_Gptr_old) || ((_Mode & ios_base::out) && !_Pptr_old))) {
            return pos_type(off_type(-1));
        }

        const auto _Newptr = _Seeklow + _Off; 
        if ((_Mode & ios_base::in) && _Gptr_old) {
            _Mysb::setg(_Seeklow, _Newptr, _Seekhigh);
        }

        if ((_Mode & ios_base::out) && _Pptr_old) {
            _Mysb::setp(_Seeklow, _Newptr, _Mysb::epptr());
        }

        return pos_type(_Off);
    }

    pos_type seekpos(pos_type _Pos, ios_base::openmode _Mode = ios_base::in | ios_base::out) override {
        
        const auto _Off      = static_cast<streamoff>(_Pos);
        const auto _Gptr_old = _Mysb::gptr();
        const auto _Pptr_old = (_Mystate & _Constant) ? nullptr : _Mysb::pptr();
        if (_Pptr_old && _Seekhigh < _Pptr_old) { 
            _Seekhigh = _Pptr_old;
        }

        const auto _Seeklow  = _Mysb::eback();
        const auto _Seekdist = _Seekhigh - _Seeklow;
        if (static_cast<unsigned long long>(_Off) > static_cast<unsigned long long>(_Seekdist)) {
            return pos_type(off_type(-1));
        }

        if (_Off != 0 && (((_Mode & ios_base::in) && !_Gptr_old) || ((_Mode & ios_base::out) && !_Pptr_old))) {
            return pos_type(off_type(-1));
        }

        const auto _Newptr = _Seeklow + _Off; 
        if ((_Mode & ios_base::in) && _Gptr_old) {
            _Mysb::setg(_Seeklow, _Newptr, _Seekhigh);
        }

        if ((_Mode & ios_base::out) && _Pptr_old) {
            _Mysb::setp(_Seeklow, _Newptr, _Mysb::epptr());
        }

        return pos_type(_Off);
    }

protected:
    void _Init(const _Elem* _Ptr, _Mysize_type _Count, int _State) {
        
        _State &= ~_From_rvalue;

        if (_Count > 2147483647) { 
            _Xbad_alloc();
        }

        if (_Count != 0
            && (_State & (_Noread | _Constant))
                   != (_Noread | _Constant)) { 
            const auto _Pnew = _Unfancy(_Al.allocate(_Count));
            _Traits::copy(_Pnew, _Ptr, _Count);
            _Seekhigh = _Pnew + _Count;

            if (!(_State & _Noread)) {
                _Mysb::setg(_Pnew, _Pnew, _Seekhigh); 
            }

            if (!(_State & _Constant)) { 
                _Mysb::setp(_Pnew, (_State & (_Atend | _Append)) ? _Seekhigh : _Pnew, _Seekhigh);

                if (_State & _Noread) { 
                    _Mysb::setg(_Pnew, nullptr, _Pnew);
                }
            }

            _State |= _Allocated;
        } else {
            _Seekhigh = nullptr;
        }

        _Mystate = _State;
    }


    void _Init_string_inplace(_Mystr&& _Str, int _State) {
        if ((_State & _Noread) && (_State & _Constant)) { 
            _Seekhigh = nullptr;
            _Mystate  = _State | _From_rvalue;
            return;
        }

        
        auto [_Ptr, _Size, _Res] = _Str._Release_to_buffer(_Al);
        _Elem* const _Pnew       = _Unfancy(_Ptr);
        _Seekhigh                = _Pnew + _Size;
        auto _Next               = (_State & (_Atend | _Append)) ? _Seekhigh : _Pnew;
        auto _End_buffer         = _Pnew + _Res;

        _Mysb::setp(_Pnew, _Next, _End_buffer);
        if (_State & _Noread) { 
            _Mysb::setg(_Pnew, nullptr, _Pnew);
        } else {
            _Mysb::setg(_Pnew, _Pnew, _Seekhigh);
        }

        _Mystate = _State | _Allocated | _From_rvalue;
    }
#line 484 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sstream"

    void _Tidy() noexcept { 
        if (_Mystate & _Allocated) {
            _Al.deallocate(_Ptr_traits::pointer_to(*_Mysb::eback()),
                static_cast<typename allocator_traits<allocator_type>::size_type>(
                    (_Mysb::pptr() ? _Mysb::epptr() : _Mysb::egptr()) - _Mysb::eback()));
        }

        _Mysb::setg(nullptr, nullptr, nullptr);
        _Mysb::setp(nullptr, nullptr);
        _Seekhigh = nullptr;
        _Mystate &= ~_Allocated;
    }

private:
    using _Ptr_traits = pointer_traits<typename allocator_traits<allocator_type>::pointer>;

    enum { 
        _MINSIZE = 32
    };

    static int _Getstate(ios_base::openmode _Mode) { 
        int _State = 0;
        if (!(_Mode & ios_base::in)) {
            _State |= _Noread;
        }

        if (!(_Mode & ios_base::out)) {
            _State |= _Constant;
        }

        if (_Mode & ios_base::app) {
            _State |= _Append;
        }

        if (_Mode & ios_base::ate) {
            _State |= _Atend;
        }

        return _State;
    }

    
    _Elem* _Seekhigh; 
    int _Mystate; 
    allocator_type _Al; 
};

template <class _Elem, class _Traits, class _Alloc>
void swap(basic_stringbuf<_Elem, _Traits, _Alloc>& _Left, basic_stringbuf<_Elem, _Traits, _Alloc>& _Right) noexcept
 {
    _Left.swap(_Right);
}

template <class _Elem, class _Traits, class _Alloc>
class basic_istringstream : public basic_istream<_Elem, _Traits> { 
public:
    using _Mybase        = basic_istream<_Elem, _Traits>;
    using allocator_type = _Alloc;
    using _Mysb          = basic_stringbuf<_Elem, _Traits, _Alloc>;
    using _Mystr         = basic_string<_Elem, _Traits, _Alloc>;


    using _Mystr_view = basic_string_view<_Elem, _Traits>;
#line 549 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sstream"

    basic_istringstream() : _Mybase(::std:: addressof(_Stringbuffer)), _Stringbuffer(ios_base::in) {}

    explicit basic_istringstream(ios_base::openmode _Mode)
        : _Mybase(::std:: addressof(_Stringbuffer)), _Stringbuffer(_Mode | ios_base::in) {}

    explicit basic_istringstream(const _Mystr& _Str, ios_base::openmode _Mode = ios_base::in)
        : _Mybase(::std:: addressof(_Stringbuffer)), _Stringbuffer(_Str, _Mode | ios_base::in) {}


    basic_istringstream(ios_base::openmode _Mode, const _Alloc& _Al)
        : _Mybase(::std:: addressof(_Stringbuffer)), _Stringbuffer(_Mode | ios_base::in, _Al) {}

    explicit basic_istringstream(_Mystr&& _Str, ios_base::openmode _Mode = ios_base::in)
        : _Mybase(::std:: addressof(_Stringbuffer)), _Stringbuffer(::std:: move(_Str), _Mode | ios_base::in) {}

    template <class _Alloc2>
    basic_istringstream(const basic_string<_Elem, _Traits, _Alloc2>& _Str, const _Alloc& _Al)
        : _Mybase(::std:: addressof(_Stringbuffer)), _Stringbuffer(_Str, ios_base::in, _Al) {}

    template <class _Alloc2>
    basic_istringstream(const basic_string<_Elem, _Traits, _Alloc2>& _Str, ios_base::openmode _Mode, const _Alloc& _Al)
        : _Mybase(::std:: addressof(_Stringbuffer)), _Stringbuffer(_Str, _Mode | ios_base::in, _Al) {}

    template <class _Alloc2, enable_if_t<!is_same_v<_Alloc2, _Alloc>, int> = 0>
    explicit basic_istringstream(
        const basic_string<_Elem, _Traits, _Alloc2>& _Str, ios_base::openmode _Mode = ios_base::in)
        : _Mybase(::std:: addressof(_Stringbuffer)), _Stringbuffer(_Str, _Mode | ios_base::in) {}
#line 578 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sstream"

    basic_istringstream(basic_istringstream&& _Right) : _Mybase(::std:: addressof(_Stringbuffer)) {
        _Assign_rv(::std:: move(_Right));
    }

    basic_istringstream& operator=(basic_istringstream&& _Right) {
        _Assign_rv(::std:: move(_Right));
        return *this;
    }

    void _Assign_rv(basic_istringstream&& _Right) {
        if (this != ::std:: addressof(_Right)) {
            _Stringbuffer.str(_Mystr());
            this->swap(_Right);
        }
    }

    void swap(basic_istringstream& _Right) {
        if (this != ::std:: addressof(_Right)) {
            _Mybase::swap(_Right);
            _Stringbuffer.swap(_Right._Stringbuffer);
        }
    }

    basic_istringstream(const basic_istringstream&) = delete;
    basic_istringstream& operator=(const basic_istringstream&) = delete;

    ~basic_istringstream() noexcept override {}

    [[nodiscard]] _Mysb* rdbuf() const {
        return const_cast<_Mysb*>(::std:: addressof(_Stringbuffer));
    }


    [[nodiscard]] _Mystr str() const&


#line 616 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sstream"
    {
        return _Stringbuffer.str();
    }

    void str(const _Mystr& _Newstr) { 
        _Stringbuffer.str(_Newstr);
    }


    template <class _Alloc2, enable_if_t<_Is_allocator<_Alloc2>::value, int> = 0>
    [[nodiscard]] basic_string<_Elem, _Traits, _Alloc2> str(const _Alloc2& _Al) const {
        return _Stringbuffer.str(_Al);
    }

    [[nodiscard]] _Mystr str() && {
        return ::std:: move(_Stringbuffer).str();
    }

    [[nodiscard]] _Mystr_view view() const noexcept {
        return _Stringbuffer.view();
    }

    template <class _Alloc2, enable_if_t<!is_same_v<_Alloc2, _Alloc>, int> = 0>
    void str(const basic_string<_Elem, _Traits, _Alloc2>& _Newstr) {
        _Stringbuffer.str(_Newstr);
    }

    void str(_Mystr&& _Newstr) {
        _Stringbuffer.str(::std:: move(_Newstr));
    }
#line 647 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sstream"

private:
    _Mysb _Stringbuffer;
};

template <class _Elem, class _Traits, class _Alloc>
void swap(basic_istringstream<_Elem, _Traits, _Alloc>& _Left, basic_istringstream<_Elem, _Traits, _Alloc>& _Right) {
    _Left.swap(_Right);
}

template <class _Elem, class _Traits, class _Alloc>
class basic_ostringstream : public basic_ostream<_Elem, _Traits> { 
public:
    using _Mybase        = basic_ostream<_Elem, _Traits>;
    using allocator_type = _Alloc;
    using _Mysb          = basic_stringbuf<_Elem, _Traits, _Alloc>;
    using _Mystr         = basic_string<_Elem, _Traits, _Alloc>;


    using _Mystr_view = basic_string_view<_Elem, _Traits>;
#line 668 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sstream"

    basic_ostringstream() : _Mybase(::std:: addressof(_Stringbuffer)), _Stringbuffer(ios_base::out) {}

    explicit basic_ostringstream(ios_base::openmode _Mode)
        : _Mybase(::std:: addressof(_Stringbuffer)), _Stringbuffer(_Mode | ios_base::out) {}

    explicit basic_ostringstream(const _Mystr& _Str, ios_base::openmode _Mode = ios_base::out)
        : _Mybase(::std:: addressof(_Stringbuffer)), _Stringbuffer(_Str, _Mode | ios_base::out) {}


    basic_ostringstream(ios_base::openmode _Mode, const _Alloc& _Al)
        : _Mybase(::std:: addressof(_Stringbuffer)), _Stringbuffer(_Mode | ios_base::out, _Al) {}

    explicit basic_ostringstream(_Mystr&& _Str, ios_base::openmode _Mode = ios_base::out)
        : _Mybase(::std:: addressof(_Stringbuffer)), _Stringbuffer(::std:: move(_Str), _Mode | ios_base::out) {}

    template <class _Alloc2>
    basic_ostringstream(const basic_string<_Elem, _Traits, _Alloc2>& _Str, const _Alloc& _Al)
        : _Mybase(::std:: addressof(_Stringbuffer)), _Stringbuffer(_Str, ios_base::out, _Al) {}

    template <class _Alloc2>
    basic_ostringstream(const basic_string<_Elem, _Traits, _Alloc2>& _Str, ios_base::openmode _Mode, const _Alloc& _Al)
        : _Mybase(::std:: addressof(_Stringbuffer)), _Stringbuffer(_Str, _Mode | ios_base::out, _Al) {}

    template <class _Alloc2, enable_if_t<!is_same_v<_Alloc2, _Alloc>, int> = 0>
    explicit basic_ostringstream(
        const basic_string<_Elem, _Traits, _Alloc2>& _Str, ios_base::openmode _Mode = ios_base::out)
        : _Mybase(::std:: addressof(_Stringbuffer)), _Stringbuffer(_Str, _Mode | ios_base::out) {}
#line 697 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sstream"

    basic_ostringstream(basic_ostringstream&& _Right) : _Mybase(::std:: addressof(_Stringbuffer)) {
        _Assign_rv(::std:: move(_Right));
    }

    basic_ostringstream& operator=(basic_ostringstream&& _Right) {
        _Assign_rv(::std:: move(_Right));
        return *this;
    }

    void _Assign_rv(basic_ostringstream&& _Right) {
        if (this != ::std:: addressof(_Right)) {
            _Stringbuffer.str(_Mystr());
            this->swap(_Right);
        }
    }

    void swap(basic_ostringstream& _Right) {
        if (this != ::std:: addressof(_Right)) {
            _Mybase::swap(_Right);
            _Stringbuffer.swap(_Right._Stringbuffer);
        }
    }

    basic_ostringstream(const basic_ostringstream&) = delete;
    basic_ostringstream& operator=(const basic_ostringstream&) = delete;

    ~basic_ostringstream() noexcept override {}

    [[nodiscard]] _Mysb* rdbuf() const {
        return const_cast<_Mysb*>(::std:: addressof(_Stringbuffer));
    }


    [[nodiscard]] _Mystr str() const&


#line 735 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sstream"
    {
        return _Stringbuffer.str();
    }

    void str(const _Mystr& _Newstr) { 
        _Stringbuffer.str(_Newstr);
    }


    template <class _Alloc2, enable_if_t<_Is_allocator<_Alloc2>::value, int> = 0>
    [[nodiscard]] basic_string<_Elem, _Traits, _Alloc2> str(const _Alloc2& _Al) const {
        return _Stringbuffer.str(_Al);
    }

    [[nodiscard]] _Mystr str() && {
        return ::std:: move(_Stringbuffer).str();
    }

    [[nodiscard]] _Mystr_view view() const noexcept {
        return _Stringbuffer.view();
    }

    template <class _Alloc2, enable_if_t<!is_same_v<_Alloc2, _Alloc>, int> = 0>
    void str(const basic_string<_Elem, _Traits, _Alloc2>& _Newstr) {
        _Stringbuffer.str(_Newstr);
    }

    void str(_Mystr&& _Newstr) {
        _Stringbuffer.str(::std:: move(_Newstr));
    }
#line 766 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sstream"

private:
    _Mysb _Stringbuffer;
};

template <class _Elem, class _Traits, class _Alloc>
void swap(basic_ostringstream<_Elem, _Traits, _Alloc>& _Left, basic_ostringstream<_Elem, _Traits, _Alloc>& _Right) {
    _Left.swap(_Right);
}

template <class _Elem, class _Traits, class _Alloc>
class basic_stringstream
    : public basic_iostream<_Elem, _Traits> { 
public:
    using _Mybase        = basic_iostream<_Elem, _Traits>;
    using char_type      = _Elem;
    using traits_type    = _Traits;
    using allocator_type = _Alloc;
    using int_type       = typename _Traits::int_type;
    using pos_type       = typename _Traits::pos_type;
    using off_type       = typename _Traits::off_type;
    using _Mysb          = basic_stringbuf<_Elem, _Traits, _Alloc>;
    using _Mystr         = basic_string<_Elem, _Traits, _Alloc>;


    using _Mystr_view = basic_string_view<_Elem, _Traits>;
#line 793 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sstream"

    basic_stringstream() : _Mybase(::std:: addressof(_Stringbuffer)), _Stringbuffer(ios_base::in | ios_base::out) {}

    explicit basic_stringstream(ios_base::openmode _Mode)
        : _Mybase(::std:: addressof(_Stringbuffer)), _Stringbuffer(_Mode) {}

    explicit basic_stringstream(const _Mystr& _Str, ios_base::openmode _Mode = ios_base::in | ios_base::out)
        : _Mybase(::std:: addressof(_Stringbuffer)), _Stringbuffer(_Str, _Mode) {}


    basic_stringstream(ios_base::openmode _Mode, const _Alloc& _Al)
        : _Mybase(::std:: addressof(_Stringbuffer)), _Stringbuffer(_Mode, _Al) {}

    explicit basic_stringstream(_Mystr&& _Str, ios_base::openmode _Mode = ios_base::in | ios_base::out)
        : _Mybase(::std:: addressof(_Stringbuffer)), _Stringbuffer(::std:: move(_Str), _Mode) {}

    template <class _Alloc2>
    basic_stringstream(const basic_string<_Elem, _Traits, _Alloc2>& _Str, const _Alloc& _Al)
        : _Mybase(::std:: addressof(_Stringbuffer)), _Stringbuffer(_Str, ios_base::in | ios_base::out, _Al) {}

    template <class _Alloc2>
    basic_stringstream(const basic_string<_Elem, _Traits, _Alloc2>& _Str, ios_base::openmode _Mode, const _Alloc& _Al)
        : _Mybase(::std:: addressof(_Stringbuffer)), _Stringbuffer(_Str, _Mode, _Al) {}

    template <class _Alloc2, enable_if_t<!is_same_v<_Alloc2, _Alloc>, int> = 0>
    explicit basic_stringstream(
        const basic_string<_Elem, _Traits, _Alloc2>& _Str, ios_base::openmode _Mode = ios_base::in | ios_base::out)
        : _Mybase(::std:: addressof(_Stringbuffer)), _Stringbuffer(_Str, _Mode) {}
#line 822 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sstream"

    basic_stringstream(basic_stringstream&& _Right) : _Mybase(::std:: addressof(_Stringbuffer)) {
        _Assign_rv(::std:: move(_Right));
    }

    basic_stringstream& operator=(basic_stringstream&& _Right) {
        _Assign_rv(::std:: move(_Right));
        return *this;
    }

    void _Assign_rv(basic_stringstream&& _Right) {
        if (this != ::std:: addressof(_Right)) {
            _Stringbuffer.str(_Mystr());
            this->swap(_Right);
        }
    }

    void swap(basic_stringstream& _Right) {
        if (this != ::std:: addressof(_Right)) {
            _Mybase::swap(_Right);
            _Stringbuffer.swap(_Right._Stringbuffer);
        }
    }

    basic_stringstream(const basic_stringstream&) = delete;
    basic_stringstream& operator=(const basic_stringstream&) = delete;

    ~basic_stringstream() noexcept override {}

    [[nodiscard]] _Mysb* rdbuf() const {
        return const_cast<_Mysb*>(::std:: addressof(_Stringbuffer));
    }


    [[nodiscard]] _Mystr str() const&


#line 860 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sstream"
    {
        return _Stringbuffer.str();
    }

    void str(const _Mystr& _Newstr) { 
        _Stringbuffer.str(_Newstr);
    }


    template <class _Alloc2, enable_if_t<_Is_allocator<_Alloc2>::value, int> = 0>
    [[nodiscard]] basic_string<_Elem, _Traits, _Alloc2> str(const _Alloc2& _Al) const {
        return _Stringbuffer.str(_Al);
    }

    [[nodiscard]] _Mystr str() && {
        return ::std:: move(_Stringbuffer).str();
    }

    [[nodiscard]] _Mystr_view view() const noexcept {
        return _Stringbuffer.view();
    }

    template <class _Alloc2, enable_if_t<!is_same_v<_Alloc2, _Alloc>, int> = 0>
    void str(const basic_string<_Elem, _Traits, _Alloc2>& _Newstr) {
        _Stringbuffer.str(_Newstr);
    }

    void str(_Mystr&& _Newstr) {
        _Stringbuffer.str(::std:: move(_Newstr));
    }
#line 891 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sstream"

private:
    _Mysb _Stringbuffer;
};

template <class _Elem, class _Traits, class _Alloc>
void swap(basic_stringstream<_Elem, _Traits, _Alloc>& _Left, basic_stringstream<_Elem, _Traits, _Alloc>& _Right) {
    _Left.swap(_Right);
}
}


#pragma warning(pop)
#pragma pack(pop)
#line 906 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sstream"
#line 907 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\sstream"
#line 29 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"


#pragma once


#line 16 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
template <class _Myvec>
class _Vector_const_iterator : public _Iterator_base {
public:

    using iterator_concept = contiguous_iterator_tag;
#line 31 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"
    using iterator_category = random_access_iterator_tag;
    using value_type        = typename _Myvec::value_type;
    using difference_type   = typename _Myvec::difference_type;
    using pointer           = typename _Myvec::const_pointer;
    using reference         = const value_type&;

    using _Tptr = typename _Myvec::pointer;

    constexpr _Vector_const_iterator() noexcept : _Ptr() {}

    constexpr _Vector_const_iterator(_Tptr _Parg, const _Container_base* _Pvector) noexcept : _Ptr(_Parg) {
        this->_Adopt(_Pvector);
    }

    [[nodiscard]] constexpr reference operator*() const noexcept {


#line 52 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        return *_Ptr;
    }

    [[nodiscard]] constexpr pointer operator->() const noexcept {


#line 63 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        return _Ptr;
    }

    constexpr _Vector_const_iterator& operator++() noexcept {


#line 73 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        ++_Ptr;
        return *this;
    }

    constexpr _Vector_const_iterator operator++(int) noexcept {
        _Vector_const_iterator _Tmp = *this;
        ++*this;
        return _Tmp;
    }

    constexpr _Vector_const_iterator& operator--() noexcept {


#line 90 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        --_Ptr;
        return *this;
    }

    constexpr _Vector_const_iterator operator--(int) noexcept {
        _Vector_const_iterator _Tmp = *this;
        --*this;
        return _Tmp;
    }

    constexpr void _Verify_offset(const difference_type _Off) const noexcept {

        (void) _Off;


#line 115 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"
    }

    constexpr _Vector_const_iterator& operator+=(const difference_type _Off) noexcept {
        _Verify_offset(_Off);
        _Ptr += _Off;
        return *this;
    }

    [[nodiscard]] constexpr _Vector_const_iterator operator+(const difference_type _Off) const noexcept {
        _Vector_const_iterator _Tmp = *this;
        _Tmp += _Off;
        return _Tmp;
    }

    constexpr _Vector_const_iterator& operator-=(const difference_type _Off) noexcept {
        return *this += -_Off;
    }

    [[nodiscard]] constexpr _Vector_const_iterator operator-(const difference_type _Off) const noexcept {
        _Vector_const_iterator _Tmp = *this;
        _Tmp -= _Off;
        return _Tmp;
    }

    [[nodiscard]] constexpr difference_type operator-(const _Vector_const_iterator& _Right) const noexcept {
        _Compat(_Right);
        return _Ptr - _Right._Ptr;
    }

    [[nodiscard]] constexpr reference operator[](const difference_type _Off) const noexcept {
        return *(*this + _Off);
    }

    [[nodiscard]] constexpr bool operator==(const _Vector_const_iterator& _Right) const noexcept {
        _Compat(_Right);
        return _Ptr == _Right._Ptr;
    }


    [[nodiscard]] constexpr strong_ordering operator<=>(const _Vector_const_iterator& _Right) const noexcept {
        _Compat(_Right);
        return _Unfancy(_Ptr) <=> _Unfancy(_Right._Ptr);
    }


#line 180 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

    constexpr void _Compat(const _Vector_const_iterator& _Right) const noexcept {
        

        (void) _Right;


#line 188 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"
    }


#line 197 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

    using _Prevent_inheriting_unwrap = _Vector_const_iterator;

    [[nodiscard]] constexpr const value_type* _Unwrapped() const noexcept {
        return _Unfancy(_Ptr);
    }

    constexpr void _Seek_to(const value_type* _It) noexcept {
        _Ptr = _Refancy<_Tptr>(const_cast<value_type*>(_It));
    }

    _Tptr _Ptr; 
};

template <class _Myvec>
[[nodiscard]] constexpr _Vector_const_iterator<_Myvec> operator+(
    typename _Vector_const_iterator<_Myvec>::difference_type _Off, _Vector_const_iterator<_Myvec> _Next) noexcept {
    _Next += _Off;
    return _Next;
}


template <class _Myvec>
struct pointer_traits<_Vector_const_iterator<_Myvec>> {
    using pointer         = _Vector_const_iterator<_Myvec>;
    using element_type    = const typename pointer::value_type;
    using difference_type = typename pointer::difference_type;

    [[nodiscard]] static constexpr element_type* to_address(const pointer _Iter) noexcept {


#line 239 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        return ::std:: to_address(_Iter._Ptr);
    }
};
#line 244 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

template <class _Myvec>
class _Vector_iterator : public _Vector_const_iterator<_Myvec> {
public:
    using _Mybase = _Vector_const_iterator<_Myvec>;


    using iterator_concept = contiguous_iterator_tag;
#line 253 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"
    using iterator_category = random_access_iterator_tag;
    using value_type        = typename _Myvec::value_type;
    using difference_type   = typename _Myvec::difference_type;
    using pointer           = typename _Myvec::pointer;
    using reference         = value_type&;

    using _Mybase::_Mybase;

    [[nodiscard]] constexpr reference operator*() const noexcept {
        return const_cast<reference>(_Mybase::operator*());
    }

    [[nodiscard]] constexpr pointer operator->() const noexcept {


#line 272 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        return this->_Ptr;
    }

    constexpr _Vector_iterator& operator++() noexcept {
        _Mybase::operator++();
        return *this;
    }

    constexpr _Vector_iterator operator++(int) noexcept {
        _Vector_iterator _Tmp = *this;
        _Mybase::operator++();
        return _Tmp;
    }

    constexpr _Vector_iterator& operator--() noexcept {
        _Mybase::operator--();
        return *this;
    }

    constexpr _Vector_iterator operator--(int) noexcept {
        _Vector_iterator _Tmp = *this;
        _Mybase::operator--();
        return _Tmp;
    }

    constexpr _Vector_iterator& operator+=(const difference_type _Off) noexcept {
        _Mybase::operator+=(_Off);
        return *this;
    }

    [[nodiscard]] constexpr _Vector_iterator operator+(const difference_type _Off) const noexcept {
        _Vector_iterator _Tmp = *this;
        _Tmp += _Off;
        return _Tmp;
    }

    constexpr _Vector_iterator& operator-=(const difference_type _Off) noexcept {
        _Mybase::operator-=(_Off);
        return *this;
    }

    using _Mybase::operator-;

    [[nodiscard]] constexpr _Vector_iterator operator-(const difference_type _Off) const noexcept {
        _Vector_iterator _Tmp = *this;
        _Tmp -= _Off;
        return _Tmp;
    }

    [[nodiscard]] constexpr reference operator[](const difference_type _Off) const noexcept {
        return const_cast<reference>(_Mybase::operator[](_Off));
    }

    using _Prevent_inheriting_unwrap = _Vector_iterator;

    [[nodiscard]] constexpr value_type* _Unwrapped() const noexcept {
        return _Unfancy(this->_Ptr);
    }
};

template <class _Myvec>
[[nodiscard]] constexpr _Vector_iterator<_Myvec> operator+(
    typename _Vector_iterator<_Myvec>::difference_type _Off, _Vector_iterator<_Myvec> _Next) noexcept {
    _Next += _Off;
    return _Next;
}


template <class _Myvec>
struct pointer_traits<_Vector_iterator<_Myvec>> {
    using pointer         = _Vector_iterator<_Myvec>;
    using element_type    = typename pointer::value_type;
    using difference_type = typename pointer::difference_type;

    [[nodiscard]] static constexpr element_type* to_address(const pointer _Iter) noexcept {


#line 361 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        return ::std:: to_address(_Iter._Ptr);
    }
};
#line 366 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

template <class _Value_type, class _Size_type, class _Difference_type, class _Pointer, class _Const_pointer,
    class _Reference, class _Const_reference>
struct _Vec_iter_types {
    using value_type      = _Value_type;
    using size_type       = _Size_type;
    using difference_type = _Difference_type;
    using pointer         = _Pointer;
    using const_pointer   = _Const_pointer;
};

struct _Value_init_tag { 
    explicit _Value_init_tag() = default;
};

template <class _Val_types>
class _Vector_val : public _Container_base {
public:
    using value_type      = typename _Val_types::value_type;
    using size_type       = typename _Val_types::size_type;
    using difference_type = typename _Val_types::difference_type;
    using pointer         = typename _Val_types::pointer;
    using const_pointer   = typename _Val_types::const_pointer;
    using reference       = value_type&;
    using const_reference = const value_type&;

    constexpr _Vector_val() noexcept : _Myfirst(), _Mylast(), _Myend() {}

    constexpr _Vector_val(pointer _First, pointer _Last, pointer _End) noexcept
        : _Myfirst(_First), _Mylast(_Last), _Myend(_End) {}

    constexpr void _Swap_val(_Vector_val& _Right) noexcept {
        this->_Swap_proxy_and_iterators(_Right);
        _Swap_adl(_Myfirst, _Right._Myfirst);
        _Swap_adl(_Mylast, _Right._Mylast);
        _Swap_adl(_Myend, _Right._Myend);
    }

    constexpr void _Take_contents(_Vector_val& _Right) noexcept {
        this->_Swap_proxy_and_iterators(_Right);
        _Myfirst = _Right._Myfirst;
        _Mylast  = _Right._Mylast;
        _Myend   = _Right._Myend;

        _Right._Myfirst = nullptr;
        _Right._Mylast  = nullptr;
        _Right._Myend   = nullptr;
    }

    pointer _Myfirst; 
    pointer _Mylast; 
    pointer _Myend; 
};

template <class _Ptrty>
constexpr auto _Unfancy_maybe_null(_Ptrty _Ptr) noexcept {
    
    return _Ptr ? ::std:: addressof(*_Ptr) : nullptr;
}

template <class _Ty>
constexpr _Ty* _Unfancy_maybe_null(_Ty* _Ptr) noexcept { 
    return _Ptr;
}


#line 436 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"


#line 442 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

#line 444 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"
#line 445 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"


#pragma detect_mismatch("annotate_vector", "0")
#line 478 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

template <class _Ty, class _Alloc = allocator<_Ty>>
class vector { 
private:
    template <class>
    friend class _Vb_val;
    friend _Tidy_guard<vector>;

    using _Alty        = _Rebind_alloc_t<_Alloc, _Ty>;
    using _Alty_traits = allocator_traits<_Alty>;

public:
    static_assert(!1 || is_same_v<_Ty, typename _Alloc::value_type>,
        "vector<T, Allocator>" " requires that Allocator's value_type match " "T" " (See N4659 26.2.1 [container.requirements.general]/16 allocator_type)" " Either fix the allocator value_type or define _ENFORCE_MATCHING_ALLOCATORS=0" " to suppress this diagnostic.");

    using value_type      = _Ty;
    using allocator_type  = _Alloc;
    using pointer         = typename _Alty_traits::pointer;
    using const_pointer   = typename _Alty_traits::const_pointer;
    using reference       = _Ty&;
    using const_reference = const _Ty&;
    using size_type       = typename _Alty_traits::size_type;
    using difference_type = typename _Alty_traits::difference_type;

private:


#line 649 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

    using _Scary_val = _Vector_val<conditional_t<_Is_simple_alloc_v<_Alty>, _Simple_types<_Ty>,
        _Vec_iter_types<_Ty, size_type, difference_type, pointer, const_pointer, _Ty&, const _Ty&>>>;

public:
    using iterator               = _Vector_iterator<_Scary_val>;
    using const_iterator         = _Vector_const_iterator<_Scary_val>;
    using reverse_iterator       = ::std:: reverse_iterator<iterator>;
    using const_reverse_iterator = ::std:: reverse_iterator<const_iterator>;

    constexpr vector() noexcept(is_nothrow_default_constructible_v<_Alty>) : _Mypair(_Zero_then_variadic_args_t{}) {
        _Mypair._Myval2._Alloc_proxy(_Fake_alloc);
    }

    constexpr explicit vector(const _Alloc& _Al) noexcept : _Mypair(_One_then_variadic_args_t{}, _Al) {
        _Mypair._Myval2._Alloc_proxy(_Fake_alloc);
    }

    constexpr explicit vector( const size_type _Count, const _Alloc& _Al = _Alloc())
        : _Mypair(_One_then_variadic_args_t{}, _Al) {
        _Construct_n(_Count);
    }

    constexpr vector( const size_type _Count, const _Ty& _Val, const _Alloc& _Al = _Alloc())
        : _Mypair(_One_then_variadic_args_t{}, _Al) {
        _Construct_n(_Count, _Val);
    }

    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
    constexpr vector(_Iter _First, _Iter _Last, const _Alloc& _Al = _Alloc())
        : _Mypair(_One_then_variadic_args_t{}, _Al) {
        _Adl_verify_range(_First, _Last);
        auto _UFirst = _Get_unwrapped(_First);
        auto _ULast  = _Get_unwrapped(_Last);
        if constexpr (_Is_fwd_iter_v<_Iter>) {
            const auto _Count = _Convert_size<size_type>(static_cast<size_t>(::std:: distance(_UFirst, _ULast)));
            _Construct_n(_Count, ::std:: move(_UFirst), ::std:: move(_ULast));
        } else {
            auto&& _Alproxy = _Fake_alloc;
            _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
            _Tidy_guard<vector> _Guard{this};

            for (; _UFirst != _ULast; ++_UFirst) {
                
                _Emplace_one_at_back(*_UFirst);
            }

            _Guard._Target = nullptr;
            _Proxy._Release();
        }
    }

    constexpr vector(initializer_list<_Ty> _Ilist, const _Alloc& _Al = _Alloc())
        : _Mypair(_One_then_variadic_args_t{}, _Al) {
        _Construct_n(_Convert_size<size_type>(_Ilist.size()), _Ilist.begin(), _Ilist.end());
    }

    constexpr vector(const vector& _Right)
        : _Mypair(_One_then_variadic_args_t{}, _Alty_traits::select_on_container_copy_construction(_Right._Getal())) {
        const auto& _Right_data = _Right._Mypair._Myval2;
        const auto _Count       = static_cast<size_type>(_Right_data._Mylast - _Right_data._Myfirst);
        _Construct_n(_Count, _Right_data._Myfirst, _Right_data._Mylast);
    }

    constexpr vector(const vector& _Right, const _Identity_t<_Alloc>& _Al)
        : _Mypair(_One_then_variadic_args_t{}, _Al) {
        const auto& _Right_data = _Right._Mypair._Myval2;
        const auto _Count       = static_cast<size_type>(_Right_data._Mylast - _Right_data._Myfirst);
        _Construct_n(_Count, _Right_data._Myfirst, _Right_data._Mylast);
    }

    constexpr vector(vector&& _Right) noexcept
        : _Mypair(_One_then_variadic_args_t{}, ::std:: move(_Right._Getal()),
            ::std:: exchange(_Right._Mypair._Myval2._Myfirst, nullptr),
            ::std:: exchange(_Right._Mypair._Myval2._Mylast, nullptr),
            ::std:: exchange(_Right._Mypair._Myval2._Myend, nullptr)) {
        _Mypair._Myval2._Alloc_proxy(_Fake_alloc);
        _Mypair._Myval2._Swap_proxy_and_iterators(_Right._Mypair._Myval2);
    }

    constexpr vector(vector&& _Right, const _Identity_t<_Alloc>& _Al_) noexcept(
        _Alty_traits::is_always_equal::value) 
        : _Mypair(_One_then_variadic_args_t{}, _Al_) {
        _Alty& _Al        = _Getal();
        auto&& _Alproxy   = _Fake_alloc;
        auto& _My_data    = _Mypair._Myval2;
        auto& _Right_data = _Right._Mypair._Myval2;
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _My_data);

        if constexpr (!_Alty_traits::is_always_equal::value) {
            if (_Al != _Right._Getal()) {
                const auto _Count = static_cast<size_type>(_Right_data._Mylast - _Right_data._Myfirst);
                if (_Count != 0) {
                    _Buy_raw(_Count);
                    _Tidy_guard<vector> _Guard{this};
                    _My_data._Mylast =
                        _Uninitialized_move(_Right_data._Myfirst, _Right_data._Mylast, _My_data._Myfirst, _Al);

                    ;
                    _Guard._Target = nullptr;
                }
                _Proxy._Release();
                return;
            }
        }

        _My_data._Take_contents(_Right_data);
        _Proxy._Release();
    }

    constexpr vector& operator=(vector&& _Right) noexcept(
        _Choose_pocma_v<_Alty> != _Pocma_values::_No_propagate_allocators) {
        if (this == ::std:: addressof(_Right)) {
            return *this;
        }

        _Alty& _Al                = _Getal();
        _Alty& _Right_al          = _Right._Getal();
        constexpr auto _Pocma_val = _Choose_pocma_v<_Alty>;
        if constexpr (_Pocma_val == _Pocma_values::_No_propagate_allocators) {
            if (_Al != _Right_al) {
                _Move_assign_unequal_alloc(_Right);
                return *this;
            }
        }

        _Tidy();


#line 784 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        _Pocma(_Al, _Right_al);
        _Mypair._Myval2._Take_contents(_Right._Mypair._Myval2);
        return *this;
    }

    constexpr ~vector() noexcept {
        _Tidy();


#line 796 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"
    }

private:
    template <class... _Valty>
    constexpr _Ty& _Emplace_one_at_back(_Valty&&... _Val) {
        
        auto& _My_data   = _Mypair._Myval2;
        pointer& _Mylast = _My_data._Mylast;

        if (_Mylast != _My_data._Myend) {
            return _Emplace_back_with_unused_capacity(::std:: forward<_Valty>(_Val)...);
        }

        return *_Emplace_reallocate(_Mylast, ::std:: forward<_Valty>(_Val)...);
    }

    template <class... _Valty>
    constexpr _Ty& _Emplace_back_with_unused_capacity(_Valty&&... _Val) {
        
        auto& _My_data   = _Mypair._Myval2;
        pointer& _Mylast = _My_data._Mylast;
        ; 
        if constexpr (conjunction_v<is_nothrow_constructible<_Ty, _Valty...>,
                          _Uses_default_construct<_Alloc, _Ty*, _Valty...>>) {
            ;
            _Construct_in_place(*_Mylast, ::std:: forward<_Valty>(_Val)...);
        } else {
            ;
            _Alty_traits::construct(_Getal(), _Unfancy(_Mylast), ::std:: forward<_Valty>(_Val)...);
            ;
        }

        _Orphan_range(_Mylast, _Mylast);
        _Ty& _Result = *_Mylast;
        ++_Mylast;

        return _Result;
    }

    template <class... _Valty>
    constexpr pointer _Emplace_reallocate(const pointer _Whereptr, _Valty&&... _Val) {
        
        _Alty& _Al        = _Getal();
        auto& _My_data    = _Mypair._Myval2;
        pointer& _Myfirst = _My_data._Myfirst;
        pointer& _Mylast  = _My_data._Mylast;

        ; 

        const auto _Whereoff = static_cast<size_type>(_Whereptr - _Myfirst);
        const auto _Oldsize  = static_cast<size_type>(_Mylast - _Myfirst);

        if (_Oldsize == max_size()) {
            _Xlength();
        }

        const size_type _Newsize     = _Oldsize + 1;
        const size_type _Newcapacity = _Calculate_growth(_Newsize);

        const pointer _Newvec           = _Al.allocate(_Newcapacity);
        const pointer _Constructed_last = _Newvec + _Whereoff + 1;
        pointer _Constructed_first      = _Constructed_last;

        try {
        _Alty_traits::construct(_Al, _Unfancy(_Newvec + _Whereoff), ::std:: forward<_Valty>(_Val)...);
        _Constructed_first = _Newvec + _Whereoff;

        if (_Whereptr == _Mylast) { 
            if constexpr (is_nothrow_move_constructible_v<_Ty> || !is_copy_constructible_v<_Ty>) {
                _Uninitialized_move(_Myfirst, _Mylast, _Newvec, _Al);
            } else {
                _Uninitialized_copy(_Myfirst, _Mylast, _Newvec, _Al);
            }
        } else { 
            _Uninitialized_move(_Myfirst, _Whereptr, _Newvec, _Al);
            _Constructed_first = _Newvec;
            _Uninitialized_move(_Whereptr, _Mylast, _Newvec + _Whereoff + 1, _Al);
        }
        } catch (...) {
        _Destroy_range(_Constructed_first, _Constructed_last, _Al);
        _Al.deallocate(_Newvec, _Newcapacity);
        throw;
        }

        _Change_array(_Newvec, _Newsize, _Newcapacity);
        return _Newvec + _Whereoff;
    }

public:
    template <class... _Valty>
    constexpr decltype(auto) emplace_back(_Valty&&... _Val) {
        
        _Ty& _Result = _Emplace_one_at_back(::std:: forward<_Valty>(_Val)...);

        return _Result;


#line 894 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"
    }

    constexpr void push_back(const _Ty& _Val) { 
        emplace_back(_Val);
    }

    constexpr void push_back(_Ty&& _Val) {
        
        emplace_back(::std:: move(_Val));
    }

    template <class... _Valty>
    constexpr iterator emplace(const_iterator _Where, _Valty&&... _Val) {
        
        const pointer _Whereptr = _Where._Ptr;
        auto& _My_data          = _Mypair._Myval2;
        const pointer _Oldlast  = _My_data._Mylast;


#line 916 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        if (_Oldlast != _My_data._Myend) {
            if (_Whereptr == _Oldlast) { 
                _Emplace_back_with_unused_capacity(::std:: forward<_Valty>(_Val)...);
            } else {
                auto& _Al = _Getal();
                _Alloc_temporary2<_Alty> _Obj(_Al, ::std:: forward<_Valty>(_Val)...); 
                
                _Orphan_range(_Whereptr, _Oldlast);
                ;
                _Alty_traits::construct(_Al, _Unfancy(_Oldlast), ::std:: move(_Oldlast[-1]));
                ;
                ++_My_data._Mylast;
                _Move_backward_unchecked(_Whereptr, _Oldlast - 1, _Oldlast);
                *_Whereptr = ::std:: move(_Obj._Get_value());
            }

            return _Make_iterator(_Whereptr);
        }

        return _Make_iterator(_Emplace_reallocate(_Whereptr, ::std:: forward<_Valty>(_Val)...));
    }

    constexpr iterator insert(const_iterator _Where, const _Ty& _Val) { 
        return emplace(_Where, _Val);
    }

    constexpr iterator insert(const_iterator _Where, _Ty&& _Val) { 
        return emplace(_Where, ::std:: move(_Val));
    }

    constexpr iterator insert(const_iterator _Where,  const size_type _Count, const _Ty& _Val) {
        
        const pointer _Whereptr = _Where._Ptr;

        auto& _Al        = _Getal();
        auto& _My_data   = _Mypair._Myval2;
        pointer& _Mylast = _My_data._Mylast;

        const pointer _Oldfirst = _My_data._Myfirst;
        const pointer _Oldlast  = _Mylast;


#line 961 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        const auto _Whereoff        = static_cast<size_type>(_Whereptr - _Oldfirst);
        const auto _Unused_capacity = static_cast<size_type>(_My_data._Myend - _Oldlast);
        const bool _One_at_back     = _Count == 1 && _Whereptr == _Oldlast;
        if (_Count == 0) { 
        } else if (_Count > _Unused_capacity) { 
            const auto _Oldsize = static_cast<size_type>(_Oldlast - _Oldfirst);

            if (_Count > max_size() - _Oldsize) {
                _Xlength();
            }

            const size_type _Newsize     = _Oldsize + _Count;
            const size_type _Newcapacity = _Calculate_growth(_Newsize);

            const pointer _Newvec           = _Al.allocate(_Newcapacity);
            const pointer _Constructed_last = _Newvec + _Whereoff + _Count;
            pointer _Constructed_first      = _Constructed_last;

            try {
            _Uninitialized_fill_n(_Newvec + _Whereoff, _Count, _Val, _Al);
            _Constructed_first = _Newvec + _Whereoff;

            if (_One_at_back) { 
                if constexpr (is_nothrow_move_constructible_v<_Ty> || !is_copy_constructible_v<_Ty>) {
                    _Uninitialized_move(_Oldfirst, _Oldlast, _Newvec, _Al);
                } else {
                    _Uninitialized_copy(_Oldfirst, _Oldlast, _Newvec, _Al);
                }
            } else { 
                _Uninitialized_move(_Oldfirst, _Whereptr, _Newvec, _Al);
                _Constructed_first = _Newvec;
                _Uninitialized_move(_Whereptr, _Oldlast, _Newvec + _Whereoff + _Count, _Al);
            }
            } catch (...) {
            _Destroy_range(_Constructed_first, _Constructed_last, _Al);
            _Al.deallocate(_Newvec, _Newcapacity);
            throw;
            }

            _Change_array(_Newvec, _Newsize, _Newcapacity);
        } else if (_One_at_back) { 
            _Emplace_back_with_unused_capacity(_Val);
        } else { 
            const _Alloc_temporary2<_Alty> _Tmp_storage(_Al, _Val); 
            const auto& _Tmp              = _Tmp_storage._Get_value();
            const auto _Affected_elements = static_cast<size_type>(_Oldlast - _Whereptr);
            _Orphan_range(_Whereptr, _Oldlast);

            ;
            if (_Count > _Affected_elements) { 
                _Mylast = _Uninitialized_fill_n(_Oldlast, _Count - _Affected_elements, _Tmp, _Al);
                _Mylast = _Uninitialized_move(_Whereptr, _Oldlast, _Mylast, _Al);
                ::std:: fill(_Whereptr, _Oldlast, _Tmp);
            } else { 
                _Mylast = _Uninitialized_move(_Oldlast - _Count, _Oldlast, _Oldlast, _Al);
                _Move_backward_unchecked(_Whereptr, _Oldlast - _Count, _Oldlast);
                ::std:: fill(_Whereptr, _Whereptr + _Count, _Tmp);
            }
            ;
        }

        return _Make_iterator_offset(_Whereoff);
    }

private:
    template <class _Iter>
    constexpr void _Insert_range(const_iterator _Where, _Iter _First, _Iter _Last, input_iterator_tag) {
        
        if (_First == _Last) {
            return; 
        }

        auto& _My_data       = _Mypair._Myval2;
        pointer& _Myfirst    = _My_data._Myfirst;
        pointer& _Mylast     = _My_data._Mylast;
        const auto _Whereoff = static_cast<size_type>(_Where._Ptr - _Myfirst);
        const auto _Oldsize  = static_cast<size_type>(_Mylast - _Myfirst);

        
        for (; _First != _Last; ++_First) {
            _Emplace_one_at_back(*_First);
        }

        _Orphan_range(_Myfirst + _Whereoff, _Myfirst + _Oldsize);

        ::std:: rotate(_Myfirst + _Whereoff, _Myfirst + _Oldsize, _Mylast);
    }

    template <class _Iter>
    constexpr void _Insert_range(const_iterator _Where, _Iter _First, _Iter _Last, forward_iterator_tag) {
        
        const pointer _Whereptr = _Where._Ptr;
        const auto _Count       = _Convert_size<size_type>(static_cast<size_t>(::std:: distance(_First, _Last)));

        auto& _Al        = _Getal();
        auto& _My_data   = _Mypair._Myval2;
        pointer& _Mylast = _My_data._Mylast;

        const pointer _Oldfirst     = _My_data._Myfirst;
        const pointer _Oldlast      = _Mylast;
        const auto _Unused_capacity = static_cast<size_type>(_My_data._Myend - _Oldlast);

        if (_Count == 0) { 
        } else if (_Count > _Unused_capacity) { 
            const auto _Oldsize = static_cast<size_type>(_Oldlast - _Oldfirst);

            if (_Count > max_size() - _Oldsize) {
                _Xlength();
            }

            const size_type _Newsize     = _Oldsize + _Count;
            const size_type _Newcapacity = _Calculate_growth(_Newsize);

            const pointer _Newvec           = _Al.allocate(_Newcapacity);
            const auto _Whereoff            = static_cast<size_type>(_Whereptr - _Oldfirst);
            const pointer _Constructed_last = _Newvec + _Whereoff + _Count;
            pointer _Constructed_first      = _Constructed_last;

            try {
            _Uninitialized_copy(_First, _Last, _Newvec + _Whereoff, _Al);
            _Constructed_first = _Newvec + _Whereoff;

            if (_Count == 1 && _Whereptr == _Oldlast) { 
                if constexpr (is_nothrow_move_constructible_v<_Ty> || !is_copy_constructible_v<_Ty>) {
                    _Uninitialized_move(_Oldfirst, _Oldlast, _Newvec, _Al);
                } else {
                    _Uninitialized_copy(_Oldfirst, _Oldlast, _Newvec, _Al);
                }
            } else { 
                _Uninitialized_move(_Oldfirst, _Whereptr, _Newvec, _Al);
                _Constructed_first = _Newvec;
                _Uninitialized_move(_Whereptr, _Oldlast, _Newvec + _Whereoff + _Count, _Al);
            }
            } catch (...) {
            _Destroy_range(_Constructed_first, _Constructed_last, _Al);
            _Al.deallocate(_Newvec, _Newcapacity);
            throw;
            }

            _Change_array(_Newvec, _Newsize, _Newcapacity);
        } else { 
                 
                 
            const auto _Affected_elements = static_cast<size_type>(_Oldlast - _Whereptr);

            ;
            if (_Count < _Affected_elements) { 
                _Mylast = _Uninitialized_move(_Oldlast - _Count, _Oldlast, _Oldlast, _Al);
                _Move_backward_unchecked(_Whereptr, _Oldlast - _Count, _Oldlast);
                _Destroy_range(_Whereptr, _Whereptr + _Count, _Al);

                try {
                _Uninitialized_copy(_First, _Last, _Whereptr, _Al);
                } catch (...) {
                

                try {
                _Uninitialized_move(_Whereptr + _Count, _Whereptr + 2 * _Count, _Whereptr, _Al);
                } catch (...) {
                
                _Orphan_range(_Whereptr, _Oldlast);
                _Destroy_range(_Whereptr + _Count, _Mylast, _Al);
                _Mylast = _Whereptr;
                throw;
                }

                _Move_unchecked(_Whereptr + 2 * _Count, _Mylast, _Whereptr + _Count);
                _Destroy_range(_Oldlast, _Mylast, _Al);
                _Mylast = _Oldlast;
                throw;
                }
            } else { 
                const pointer _Relocated = _Whereptr + _Count;
                _Mylast                  = _Uninitialized_move(_Whereptr, _Oldlast, _Relocated, _Al);
                _Destroy_range(_Whereptr, _Oldlast, _Al);

                try {
                _Uninitialized_copy(_First, _Last, _Whereptr, _Al);
                } catch (...) {
                

                try {
                _Uninitialized_move(_Relocated, _Mylast, _Whereptr, _Al);
                } catch (...) {
                
                _Orphan_range(_Whereptr, _Oldlast);
                _Destroy_range(_Relocated, _Mylast, _Al);
                _Mylast = _Whereptr;
                throw;
                }

                _Destroy_range(_Relocated, _Mylast, _Al);
                _Mylast = _Oldlast;
                throw;
                }
            }

            _Orphan_range(_Whereptr, _Oldlast);
            ;
        }
    }

public:
    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
    constexpr iterator insert(const_iterator _Where, _Iter _First, _Iter _Last) {
        const pointer _Whereptr = _Where._Ptr;
        auto& _My_data          = _Mypair._Myval2;
        const pointer _Oldfirst = _My_data._Myfirst;


#line 1179 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        _Adl_verify_range(_First, _Last);
        const auto _Whereoff = static_cast<size_type>(_Whereptr - _Oldfirst);
        _Insert_range(_Where, _Get_unwrapped(_First), _Get_unwrapped(_Last), _Iter_cat_t<_Iter>{});
        return _Make_iterator_offset(_Whereoff);
    }

    constexpr iterator insert(const_iterator _Where, initializer_list<_Ty> _Ilist) {
        return insert(_Where, _Ilist.begin(), _Ilist.end());
    }

    constexpr void assign( const size_type _Newsize, const _Ty& _Val) {
        
        auto& _Al         = _Getal();
        auto& _My_data    = _Mypair._Myval2;
        pointer& _Myfirst = _My_data._Myfirst;
        pointer& _Mylast  = _My_data._Mylast;

        constexpr bool _Nothrow_construct =
            conjunction_v<is_nothrow_copy_constructible<_Ty>, _Uses_default_construct<_Alloc, _Ty*, const _Ty&>>;

        _My_data._Orphan_all();
        const auto _Oldcapacity = static_cast<size_type>(_My_data._Myend - _Myfirst);
        if (_Newsize > _Oldcapacity) { 
            _Clear_and_reserve_geometric(_Newsize);
            if constexpr (_Nothrow_construct) {
                _Mylast = _Uninitialized_fill_n(_Myfirst, _Newsize, _Val, _Al);
                ;
            } else {
                ;
                _Mylast = _Uninitialized_fill_n(_Myfirst, _Newsize, _Val, _Al);
            }

            return;
        }

        const auto _Oldsize = static_cast<size_type>(_Mylast - _Myfirst);
        if (_Newsize > _Oldsize) {
            ::std:: fill(_Myfirst, _Mylast, _Val);
            if constexpr (_Nothrow_construct) {
                ;
                _Mylast = _Uninitialized_fill_n(_Mylast, _Newsize - _Oldsize, _Val, _Al);
            } else {
                ;
                _Mylast = _Uninitialized_fill_n(_Mylast, _Newsize - _Oldsize, _Val, _Al);
                ;
            }
        } else {
            const pointer _Newlast = _Myfirst + _Newsize;
            ::std:: fill(_Myfirst, _Newlast, _Val);
            _Destroy_range(_Newlast, _Mylast, _Al);
            ;
            _Mylast = _Newlast;
        }
    }

private:
    template <class _Iter>
    constexpr void _Assign_range(_Iter _First, _Iter _Last, input_iterator_tag) {
        
        auto& _My_data    = _Mypair._Myval2;
        pointer& _Myfirst = _My_data._Myfirst;
        pointer& _Mylast  = _My_data._Mylast;

        _My_data._Orphan_all();

        pointer _Next = _Myfirst;
        for (; _First != _Last && _Next != _Mylast; ++_First, (void) ++_Next) {
            *_Next = *_First;
        }

        
        _Destroy_range(_Next, _Mylast, _Getal());
        ; 
        _Mylast = _Next;

        
        for (; _First != _Last; ++_First) {
            
            _Emplace_one_at_back(*_First);
        }
    }

    template <class _Iter>
    constexpr void _Assign_range(_Iter _First, _Iter _Last, forward_iterator_tag) {
        
        const auto _Newsize = _Convert_size<size_type>(static_cast<size_t>(::std:: distance(_First, _Last)));
        auto& _Al           = _Getal();
        auto& _My_data      = _Mypair._Myval2;
        pointer& _Myfirst   = _My_data._Myfirst;
        pointer& _Mylast    = _My_data._Mylast;
        pointer& _Myend     = _My_data._Myend;

        constexpr bool _Nothrow_construct = conjunction_v<is_nothrow_constructible<_Ty, _Iter_ref_t<_Iter>>,
            _Uses_default_construct<_Alloc, _Ty*, _Iter_ref_t<_Iter>>>;

        _My_data._Orphan_all();
        const auto _Oldcapacity = static_cast<size_type>(_Myend - _Myfirst);
        if (_Newsize > _Oldcapacity) {
            _Clear_and_reserve_geometric(_Newsize);
            if constexpr (_Nothrow_construct) {
                _Mylast = _Uninitialized_copy(_First, _Last, _Myfirst, _Al);
                ;
            } else {
                ;
                _Mylast = _Uninitialized_copy(_First, _Last, _Myfirst, _Al);
            }
            return;
        }

        const auto _Oldsize = static_cast<size_type>(_Mylast - _Myfirst);
        if (_Newsize > _Oldsize) {
            
            const _Iter _Mid = ::std:: next(_First, static_cast<difference_type>(_Oldsize));
            _Copy_unchecked(_First, _Mid, _Myfirst);

            if constexpr (_Nothrow_construct) {
                ;
                _Mylast = _Uninitialized_copy(_Mid, _Last, _Mylast, _Al);
            } else {
                ;
                _Mylast = _Uninitialized_copy(_Mid, _Last, _Mylast, _Al);
                ;
            }
        } else {
            const pointer _Newlast = _Myfirst + _Newsize;
            _Copy_unchecked(_First, _Last, _Myfirst);
            _Destroy_range(_Newlast, _Mylast, _Al);
            ;
            _Mylast = _Newlast;
        }
    }

public:
    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
    constexpr void assign(_Iter _First, _Iter _Last) {
        _Adl_verify_range(_First, _Last);
        _Assign_range(_Get_unwrapped(_First), _Get_unwrapped(_Last), _Iter_cat_t<_Iter>{});
    }

    constexpr void assign(initializer_list<_Ty> _Ilist) {
        _Assign_range(_Ilist.begin(), _Ilist.end(), random_access_iterator_tag{});
    }

public:
    constexpr vector& operator=(const vector& _Right) {
        if (this == ::std:: addressof(_Right)) {
            return *this;
        }

        auto& _Al       = _Getal();
        auto& _Right_al = _Right._Getal();
        if constexpr (_Choose_pocca_v<_Alty>) {
            if (_Al != _Right_al) {
                _Tidy();
                _Mypair._Myval2._Reload_proxy(_Fake_alloc, _Fake_alloc);
            }
        }

        _Pocca(_Al, _Right_al);
        auto& _Right_data = _Right._Mypair._Myval2;
        assign(_Right_data._Myfirst, _Right_data._Mylast);

        return *this;
    }

    constexpr vector& operator=(initializer_list<_Ty> _Ilist) {
        _Assign_range(_Ilist.begin(), _Ilist.end(), random_access_iterator_tag{});
        return *this;
    }

private:
    template <class _Ty2>
    constexpr void _Resize_reallocate(const size_type _Newsize, const _Ty2& _Val) {
        if (_Newsize > max_size()) {
            _Xlength();
        }

        auto& _Al         = _Getal();
        auto& _My_data    = _Mypair._Myval2;
        pointer& _Myfirst = _My_data._Myfirst;
        pointer& _Mylast  = _My_data._Mylast;

        const auto _Oldsize          = static_cast<size_type>(_Mylast - _Myfirst);
        const size_type _Newcapacity = _Calculate_growth(_Newsize);

        const pointer _Newvec         = _Al.allocate(_Newcapacity);
        const pointer _Appended_first = _Newvec + _Oldsize;
        pointer _Appended_last        = _Appended_first;

        try {
        if constexpr (is_same_v<_Ty2, _Ty>) {
            _Appended_last = _Uninitialized_fill_n(_Appended_first, _Newsize - _Oldsize, _Val, _Al);
        } else {
            ;
            _Appended_last = _Uninitialized_value_construct_n(_Appended_first, _Newsize - _Oldsize, _Al);
        }

        if constexpr (is_nothrow_move_constructible_v<_Ty> || !is_copy_constructible_v<_Ty>) {
            _Uninitialized_move(_Myfirst, _Mylast, _Newvec, _Al);
        } else {
            _Uninitialized_copy(_Myfirst, _Mylast, _Newvec, _Al);
        }
        } catch (...) {
        _Destroy_range(_Appended_first, _Appended_last, _Al);
        _Al.deallocate(_Newvec, _Newcapacity);
        throw;
        }

        _Change_array(_Newvec, _Newsize, _Newcapacity);
    }

    template <class _Ty2>
    constexpr void _Resize(const size_type _Newsize, const _Ty2& _Val) {
        
        auto& _Al           = _Getal();
        auto& _My_data      = _Mypair._Myval2;
        pointer& _Myfirst   = _My_data._Myfirst;
        pointer& _Mylast    = _My_data._Mylast;
        const auto _Oldsize = static_cast<size_type>(_Mylast - _Myfirst);
        if (_Newsize < _Oldsize) { 
            const pointer _Newlast = _Myfirst + _Newsize;
            _Orphan_range(_Newlast, _Mylast);
            _Destroy_range(_Newlast, _Mylast, _Al);
            ;
            _Mylast = _Newlast;
            return;
        }

        if (_Newsize > _Oldsize) { 
            const auto _Oldcapacity = static_cast<size_type>(_My_data._Myend - _Myfirst);
            if (_Newsize > _Oldcapacity) { 
                _Resize_reallocate(_Newsize, _Val);
                return;
            }

            ;
            const pointer _Oldlast = _Mylast;
            if constexpr (is_same_v<_Ty2, _Ty>) {
                _Mylast = _Uninitialized_fill_n(_Oldlast, _Newsize - _Oldsize, _Val, _Al);
            } else {
                ;
                _Mylast = _Uninitialized_value_construct_n(_Oldlast, _Newsize - _Oldsize, _Al);
            }
            ;
            _Orphan_range(_Oldlast, _Oldlast);
        }

        
    }

public:
    constexpr void resize( const size_type _Newsize) {
        
        _Resize(_Newsize, _Value_init_tag{});
    }

    constexpr void resize( const size_type _Newsize, const _Ty& _Val) {
        
        _Resize(_Newsize, _Val);
    }

private:
    constexpr void _Reallocate_exactly(const size_type _Newcapacity) {
        
        auto& _Al         = _Getal();
        auto& _My_data    = _Mypair._Myval2;
        pointer& _Myfirst = _My_data._Myfirst;
        pointer& _Mylast  = _My_data._Mylast;

        const auto _Size = static_cast<size_type>(_Mylast - _Myfirst);

        const pointer _Newvec = _Al.allocate(_Newcapacity);

        try {
        if constexpr (is_nothrow_move_constructible_v<_Ty> || !is_copy_constructible_v<_Ty>) {
            _Uninitialized_move(_Myfirst, _Mylast, _Newvec, _Al);
        } else {
            _Uninitialized_copy(_Myfirst, _Mylast, _Newvec, _Al);
        }
        } catch (...) {
        _Al.deallocate(_Newvec, _Newcapacity);
        throw;
        }

        _Change_array(_Newvec, _Size, _Newcapacity);
    }


#line 1491 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

    constexpr void _Clear_and_reserve_geometric(const size_type _Newsize) {
        auto& _Al         = _Getal();
        auto& _My_data    = _Mypair._Myval2;
        pointer& _Myfirst = _My_data._Myfirst;
        pointer& _Mylast  = _My_data._Mylast;
        pointer& _Myend   = _My_data._Myend;


#line 1503 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        if (_Newsize > max_size()) {
            _Xlength();
        }

        const size_type _Newcapacity = _Calculate_growth(_Newsize);

        if (_Myfirst) { 
            _Destroy_range(_Myfirst, _Mylast, _Al);
            ;
            _Al.deallocate(_Myfirst, static_cast<size_type>(_Myend - _Myfirst));

            _Myfirst = nullptr;
            _Mylast  = nullptr;
            _Myend   = nullptr;
        }

        _Buy_raw(_Newcapacity);
    }

public:
    constexpr void reserve( const size_type _Newcapacity) {
        
        if (_Newcapacity > capacity()) { 
            if (_Newcapacity > max_size()) {
                _Xlength();
            }

            _Reallocate_exactly(_Newcapacity);
        }
    }

    constexpr void shrink_to_fit() { 
        auto& _My_data         = _Mypair._Myval2;
        const pointer _Oldlast = _My_data._Mylast;
        if (_Oldlast != _My_data._Myend) { 
            const pointer _Oldfirst = _My_data._Myfirst;
            if (_Oldfirst == _Oldlast) {
                _Tidy();
            } else {
                _Reallocate_exactly(static_cast<size_type>(_Oldlast - _Oldfirst));
            }
        }
    }

    constexpr void pop_back() noexcept  {
        auto& _My_data   = _Mypair._Myval2;
        pointer& _Mylast = _My_data._Mylast;


#line 1555 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        _Orphan_range(_Mylast - 1, _Mylast);
        _Alty_traits::destroy(_Getal(), _Unfancy(_Mylast - 1));
        ;
        --_Mylast;
    }

    constexpr iterator erase(const_iterator _Where) noexcept(
        is_nothrow_move_assignable_v<value_type>)  {
        const pointer _Whereptr = _Where._Ptr;
        auto& _My_data          = _Mypair._Myval2;
        pointer& _Mylast        = _My_data._Mylast;


#line 1573 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        _Orphan_range(_Whereptr, _Mylast);
        _Move_unchecked(_Whereptr + 1, _Mylast, _Whereptr);
        _Alty_traits::destroy(_Getal(), _Unfancy(_Mylast - 1));
        ;
        --_Mylast;
        return iterator(_Whereptr, ::std:: addressof(_My_data));
    }

    constexpr iterator erase(const_iterator _First, const_iterator _Last) noexcept(
        is_nothrow_move_assignable_v<value_type>)  {
        const pointer _Firstptr = _First._Ptr;
        const pointer _Lastptr  = _Last._Ptr;
        auto& _My_data          = _Mypair._Myval2;
        pointer& _Mylast        = _My_data._Mylast;


#line 1594 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        if (_Firstptr != _Lastptr) { 
            _Orphan_range(_Firstptr, _Mylast);

            const pointer _Newlast = _Move_unchecked(_Lastptr, _Mylast, _Firstptr);
            _Destroy_range(_Newlast, _Mylast, _Getal());
            ; 
            _Mylast = _Newlast;
        }

        return iterator(_Firstptr, ::std:: addressof(_My_data));
    }

    constexpr void clear() noexcept { 
        auto& _My_data    = _Mypair._Myval2;
        pointer& _Myfirst = _My_data._Myfirst;
        pointer& _Mylast  = _My_data._Mylast;

        if (_Myfirst == _Mylast) { 
            
            
            return;
        }

        _My_data._Orphan_all();
        _Destroy_range(_Myfirst, _Mylast, _Getal());
        ; 
        _Mylast = _Myfirst;
    }

    constexpr void swap(vector& _Right) noexcept  {
        if (this != ::std:: addressof(_Right)) {
            _Pocs(_Getal(), _Right._Getal());
            _Mypair._Myval2._Swap_val(_Right._Mypair._Myval2);
        }
    }

    [[nodiscard]] constexpr _Ty* data() noexcept {
        return _Unfancy_maybe_null(_Mypair._Myval2._Myfirst);
    }

    [[nodiscard]] constexpr const _Ty* data() const noexcept {
        return _Unfancy_maybe_null(_Mypair._Myval2._Myfirst);
    }

    [[nodiscard]] constexpr iterator begin() noexcept {
        auto& _My_data = _Mypair._Myval2;
        return iterator(_My_data._Myfirst, ::std:: addressof(_My_data));
    }

    [[nodiscard]] constexpr const_iterator begin() const noexcept {
        auto& _My_data = _Mypair._Myval2;
        return const_iterator(_My_data._Myfirst, ::std:: addressof(_My_data));
    }

    [[nodiscard]] constexpr iterator end() noexcept {
        auto& _My_data = _Mypair._Myval2;
        return iterator(_My_data._Mylast, ::std:: addressof(_My_data));
    }

    [[nodiscard]] constexpr const_iterator end() const noexcept {
        auto& _My_data = _Mypair._Myval2;
        return const_iterator(_My_data._Mylast, ::std:: addressof(_My_data));
    }

    [[nodiscard]] constexpr reverse_iterator rbegin() noexcept {
        return reverse_iterator(end());
    }

    [[nodiscard]] constexpr const_reverse_iterator rbegin() const noexcept {
        return const_reverse_iterator(end());
    }

    [[nodiscard]] constexpr reverse_iterator rend() noexcept {
        return reverse_iterator(begin());
    }

    [[nodiscard]] constexpr const_reverse_iterator rend() const noexcept {
        return const_reverse_iterator(begin());
    }

    [[nodiscard]] constexpr const_iterator cbegin() const noexcept {
        return begin();
    }

    [[nodiscard]] constexpr const_iterator cend() const noexcept {
        return end();
    }

    [[nodiscard]] constexpr const_reverse_iterator crbegin() const noexcept {
        return rbegin();
    }

    [[nodiscard]] constexpr const_reverse_iterator crend() const noexcept {
        return rend();
    }

    [[nodiscard]] constexpr pointer _Unchecked_begin() noexcept {
        return _Mypair._Myval2._Myfirst;
    }

    [[nodiscard]] constexpr const_pointer _Unchecked_begin() const noexcept {
        return _Mypair._Myval2._Myfirst;
    }

    [[nodiscard]] constexpr pointer _Unchecked_end() noexcept {
        return _Mypair._Myval2._Mylast;
    }

    [[nodiscard]] constexpr const_pointer _Unchecked_end() const noexcept {
        return _Mypair._Myval2._Mylast;
    }

    [[nodiscard]] constexpr bool empty() const noexcept {
        auto& _My_data = _Mypair._Myval2;
        return _My_data._Myfirst == _My_data._Mylast;
    }

    [[nodiscard]] constexpr size_type size() const noexcept {
        auto& _My_data = _Mypair._Myval2;
        return static_cast<size_type>(_My_data._Mylast - _My_data._Myfirst);
    }

    [[nodiscard]] constexpr size_type max_size() const noexcept {
        return (::std:: min)(
            static_cast<size_type>((numeric_limits<difference_type>::max)()), _Alty_traits::max_size(_Getal()));
    }

    [[nodiscard]] constexpr size_type capacity() const noexcept {
        auto& _My_data = _Mypair._Myval2;
        return static_cast<size_type>(_My_data._Myend - _My_data._Myfirst);
    }

    [[nodiscard]] constexpr _Ty& operator[](const size_type _Pos) noexcept  {
        auto& _My_data = _Mypair._Myval2;


#line 1734 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        return _My_data._Myfirst[_Pos];
    }

    [[nodiscard]] constexpr const _Ty& operator[](const size_type _Pos) const noexcept  {
        auto& _My_data = _Mypair._Myval2;


#line 1744 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        return _My_data._Myfirst[_Pos];
    }

    [[nodiscard]] constexpr _Ty& at(const size_type _Pos) {
        auto& _My_data = _Mypair._Myval2;
        if (static_cast<size_type>(_My_data._Mylast - _My_data._Myfirst) <= _Pos) {
            _Xrange();
        }

        return _My_data._Myfirst[_Pos];
    }

    [[nodiscard]] constexpr const _Ty& at(const size_type _Pos) const {
        auto& _My_data = _Mypair._Myval2;
        if (static_cast<size_type>(_My_data._Mylast - _My_data._Myfirst) <= _Pos) {
            _Xrange();
        }

        return _My_data._Myfirst[_Pos];
    }

    [[nodiscard]] constexpr _Ty& front() noexcept  {
        auto& _My_data = _Mypair._Myval2;


#line 1771 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        return *_My_data._Myfirst;
    }

    [[nodiscard]] constexpr const _Ty& front() const noexcept  {
        auto& _My_data = _Mypair._Myval2;


#line 1780 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        return *_My_data._Myfirst;
    }

    [[nodiscard]] constexpr _Ty& back() noexcept  {
        auto& _My_data = _Mypair._Myval2;


#line 1789 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        return _My_data._Mylast[-1];
    }

    [[nodiscard]] constexpr const _Ty& back() const noexcept  {
        auto& _My_data = _Mypair._Myval2;


#line 1798 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        return _My_data._Mylast[-1];
    }

    [[nodiscard]] constexpr allocator_type get_allocator() const noexcept {
        return static_cast<allocator_type>(_Getal());
    }

private:
    constexpr size_type _Calculate_growth(const size_type _Newsize) const {
        
        const size_type _Oldcapacity = capacity();
        const auto _Max              = max_size();

        if (_Oldcapacity > _Max - _Oldcapacity / 2) {
            return _Max; 
        }

        const size_type _Geometric = _Oldcapacity + _Oldcapacity / 2;

        if (_Geometric < _Newsize) {
            return _Newsize; 
        }

        return _Geometric; 
    }

    constexpr void _Buy_raw(const size_type _Newcapacity) {
        
        auto& _My_data    = _Mypair._Myval2;
        pointer& _Myfirst = _My_data._Myfirst;
        pointer& _Mylast  = _My_data._Mylast;
        pointer& _Myend   = _My_data._Myend;

        ; 
        ;

        const auto _Newvec = _Getal().allocate(_Newcapacity);
        _Myfirst           = _Newvec;
        _Mylast            = _Newvec;
        _Myend             = _Newvec + _Newcapacity;
    }

    constexpr void _Buy_nonzero(const size_type _Newcapacity) {
        

        if (_Newcapacity > max_size()) {
            _Xlength();
        }

        _Buy_raw(_Newcapacity);
    }

    constexpr void _Change_array(const pointer _Newvec, const size_type _Newsize, const size_type _Newcapacity) {
        
        auto& _Al         = _Getal();
        auto& _My_data    = _Mypair._Myval2;
        pointer& _Myfirst = _My_data._Myfirst;
        pointer& _Mylast  = _My_data._Mylast;
        pointer& _Myend   = _My_data._Myend;

        _My_data._Orphan_all();

        if (_Myfirst) { 
            _Destroy_range(_Myfirst, _Mylast, _Al);
            ;
            _Al.deallocate(_Myfirst, static_cast<size_type>(_Myend - _Myfirst));
        }

        _Myfirst = _Newvec;
        _Mylast  = _Newvec + _Newsize;
        _Myend   = _Newvec + _Newcapacity;
        ;
    }

    constexpr void _Tidy() noexcept { 
        auto& _Al         = _Getal();
        auto& _My_data    = _Mypair._Myval2;
        pointer& _Myfirst = _My_data._Myfirst;
        pointer& _Mylast  = _My_data._Mylast;
        pointer& _Myend   = _My_data._Myend;

        _My_data._Orphan_all();

        if (_Myfirst) { 
            _Destroy_range(_Myfirst, _Mylast, _Al);
            ;
            _Al.deallocate(_Myfirst, static_cast<size_type>(_Myend - _Myfirst));

            _Myfirst = nullptr;
            _Mylast  = nullptr;
            _Myend   = nullptr;
        }
    }

    template <class... _Valty>
    constexpr void _Construct_n( const size_type _Count, _Valty&&... _Val) {
        
        
        auto& _Al       = _Getal();
        auto&& _Alproxy = _Fake_alloc;
        auto& _My_data  = _Mypair._Myval2;
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _My_data);
        if (_Count != 0) {
            _Buy_nonzero(_Count);
            _Tidy_guard<vector> _Guard{this};
            if constexpr (sizeof...(_Val) == 0) {
                _My_data._Mylast = _Uninitialized_value_construct_n(_My_data._Myfirst, _Count, _Al);
            } else if constexpr (sizeof...(_Val) == 1) {
                ;
                _My_data._Mylast = _Uninitialized_fill_n(_My_data._Myfirst, _Count, _Val..., _Al);
            } else if constexpr (sizeof...(_Val) == 2) {
                _My_data._Mylast = _Uninitialized_copy(::std:: forward<_Valty>(_Val)..., _My_data._Myfirst, _Al);
            } else {
                static_assert(_Always_false<_Ty>, "Should be unreachable");
            }
            ;
            _Guard._Target = nullptr;
        }

        _Proxy._Release();
    }

    constexpr void _Move_assign_unequal_alloc(vector& _Right) {
        auto& _Al         = _Getal();
        auto& _My_data    = _Mypair._Myval2;
        auto& _Right_data = _Right._Mypair._Myval2;

        const pointer _First = _Right_data._Myfirst;
        const pointer _Last  = _Right_data._Mylast;
        const auto _Newsize  = static_cast<size_type>(_Last - _First);

        pointer& _Myfirst = _My_data._Myfirst;
        pointer& _Mylast  = _My_data._Mylast;

        constexpr bool _Nothrow_construct =
            conjunction_v<is_nothrow_move_constructible<_Ty>, _Uses_default_construct<_Alloc, _Ty*, _Ty>>;

        _My_data._Orphan_all();
        const auto _Oldcapacity = static_cast<size_type>(_My_data._Myend - _Myfirst);
        if (_Newsize > _Oldcapacity) {
            _Clear_and_reserve_geometric(_Newsize);
            if constexpr (_Nothrow_construct) {
                _Mylast = _Uninitialized_move(_First, _Last, _Myfirst, _Al);
                ;
            } else {
                ;
                _Mylast = _Uninitialized_move(_First, _Last, _Myfirst, _Al);
            }

            return;
        }

        const auto _Oldsize = static_cast<size_type>(_Mylast - _Myfirst);
        if (_Newsize > _Oldsize) {
            const pointer _Mid = _First + _Oldsize;
            _Move_unchecked(_First, _Mid, _Myfirst);

            if constexpr (_Nothrow_construct) {
                ;
                _Mylast = _Uninitialized_move(_Mid, _Last, _Mylast, _Al);
            } else {
                ;
                _Mylast = _Uninitialized_move(_Mid, _Last, _Mylast, _Al);
                ;
            }
        } else {
            const pointer _Newlast = _Myfirst + _Newsize;
            _Move_unchecked(_First, _Last, _Myfirst);
            _Destroy_range(_Newlast, _Mylast, _Al);
            ;
            _Mylast = _Newlast;
        }
    }

    [[noreturn]] static void _Xlength() {
        _Xlength_error("vector too long");
    }

    [[noreturn]] static void _Xrange() {
        _Xout_of_range("invalid vector subscript");
    }


#line 2024 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"
    constexpr void _Orphan_range(pointer, pointer) const {}
#line 2026 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

    [[nodiscard]] constexpr _Alty& _Getal() noexcept {
        return _Mypair._Get_first();
    }

    [[nodiscard]] constexpr const _Alty& _Getal() const noexcept {
        return _Mypair._Get_first();
    }

    [[nodiscard]] constexpr iterator _Make_iterator(const pointer _Ptr) noexcept {
        return iterator(_Ptr, ::std:: addressof(_Mypair._Myval2));
    }

    [[nodiscard]] constexpr iterator _Make_iterator_offset(const size_type _Offset) noexcept {
        
        auto& _My_data = _Mypair._Myval2;
        return iterator(_My_data._Myfirst + _Offset, ::std:: addressof(_My_data));
    }

    _Compressed_pair<_Alty, _Scary_val> _Mypair;
};


template <class _Iter, class _Alloc = allocator<_Iter_value_t<_Iter>>,
    enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
vector(_Iter, _Iter, _Alloc = _Alloc()) -> vector<_Iter_value_t<_Iter>, _Alloc>;
#line 2053 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

template <class _Alloc>
class vector<bool, _Alloc>;

using _Vbase         = unsigned int; 
constexpr int _VBITS = 8 * sizeof(_Vbase); 

template <class _Ty, class _Alloc>
[[nodiscard]] constexpr bool operator==(const vector<_Ty, _Alloc>& _Left, const vector<_Ty, _Alloc>& _Right) {
    if (_Left.size() != _Right.size()) {
        return false;
    }

    if constexpr (is_same_v<_Ty, bool>) {
        return ::std:: equal(
            _Left._Myvec._Unchecked_begin(), _Left._Myvec._Unchecked_end(), _Right._Myvec._Unchecked_begin());
    } else {
        return ::std:: equal(_Left._Unchecked_begin(), _Left._Unchecked_end(), _Right._Unchecked_begin());
    }
}


#line 2080 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"


template <class _Ret>
struct _Vbase_compare_three_way {
    [[nodiscard]] constexpr _Ret operator()(const _Vbase _Left, const _Vbase _Right) const noexcept {
        const _Vbase _Differing_bits = _Left ^ _Right;

        if (_Differing_bits == 0) { 

            return strong_ordering::equal;


#line 2107 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"
        }

        const int _Bit_index = _Countr_zero(_Differing_bits); 
        ; 

        const _Vbase _Mask = _Vbase{1} << _Bit_index; 

        
        return (_Left & _Mask) == 0 ? strong_ordering::less : strong_ordering::greater;


#line 2120 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"
    }
};


template <class _Ty, class _Alloc>
[[nodiscard]] constexpr _Synth_three_way_result<_Ty> operator<=>(
    const vector<_Ty, _Alloc>& _Left, const vector<_Ty, _Alloc>& _Right) {
    if constexpr (is_same_v<_Ty, bool>) {
        
        const auto _Min_word_size = (::std:: min)(_Left._Myvec.size(), _Right._Myvec.size());
        const auto _Left_words    = _Left._Myvec._Unchecked_begin();
        const auto _Right_words   = _Right._Myvec._Unchecked_begin();

        using _Comp = _Vbase_compare_three_way<strong_ordering>;

        const strong_ordering _Word_comparison = ::std:: lexicographical_compare_three_way(
            _Left_words, _Left_words + _Min_word_size, _Right_words, _Right_words + _Min_word_size, _Comp{});

        if (_Word_comparison != 0) {
            return _Word_comparison;
        }

        return _Left.size() <=> _Right.size();
    } else {
        return ::std:: lexicographical_compare_three_way(_Left._Unchecked_begin(), _Left._Unchecked_end(),
            _Right._Unchecked_begin(), _Right._Unchecked_end(), _Synth_three_way{});
    }
}


#line 2191 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

template <class _Ty, class _Alloc>
constexpr void swap(vector<_Ty, _Alloc>& _Left, vector<_Ty, _Alloc>& _Right) noexcept  {
    _Left.swap(_Right);
}


template <class _Ty, class _Alloc, class _Uty>
constexpr typename vector<_Ty, _Alloc>::size_type erase(vector<_Ty, _Alloc>& _Cont, const _Uty& _Val) {
    return _Erase_remove(_Cont, _Val);
}

template <class _Ty, class _Alloc, class _Pr>
constexpr typename vector<_Ty, _Alloc>::size_type erase_if(vector<_Ty, _Alloc>& _Cont, _Pr _Pred) {
    return _Erase_remove_if(_Cont, _Pass_fn(_Pred));
}
#line 2208 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

template <class _Alloc0>
struct _Wrap_alloc { 
    using _Alloc = _Alloc0;
};

template <class _Alvbase_wrapped>
class _Vb_iter_base : public _Iterator_base {
    
public:
    using _Alvbase         = typename _Alvbase_wrapped::_Alloc;
    using _Size_type       = typename allocator_traits<_Alvbase>::size_type;
    using _Difference_type = typename allocator_traits<_Alvbase>::difference_type;
    using _Mycont          = vector<bool, _Rebind_alloc_t<_Alvbase, bool>>;

    constexpr _Vb_iter_base() = default;

    constexpr _Vb_iter_base(const _Vbase* _Ptr, _Size_type _Off, const _Container_base* _Mypvbool) noexcept
        : _Myptr(_Ptr), _Myoff(_Off) {
        this->_Adopt(_Mypvbool);
    }

    constexpr void _Advance(_Size_type _Off) noexcept {
        _Myoff += _Off;
        _Myptr += _Myoff / _VBITS;
        _Myoff %= _VBITS;
    }


#line 2241 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

    const _Vbase* _Myptr = nullptr;
    _Size_type _Myoff    = 0;
};

template <class _Alvbase_wrapped>
class _Vb_reference : public _Vb_iter_base<_Alvbase_wrapped> {
    
    using _Mybase          = _Vb_iter_base<_Alvbase_wrapped>;
    using _Mycont          = typename _Mybase::_Mycont;
    using _Difference_type = typename _Mybase::_Difference_type;

    
    constexpr _Vb_reference() = default;

public:
    constexpr _Vb_reference(const _Vb_reference&) = default;

    constexpr _Vb_reference(const _Mybase& _Right) noexcept
        : _Mybase(_Right._Myptr, _Right._Myoff, _Right._Getcont()) {}

    constexpr _Vb_reference& operator=(const _Vb_reference& _Right) noexcept {
        return *this = static_cast<bool>(_Right);
    }

    constexpr _Vb_reference& operator=(bool _Val) noexcept {
        if (_Val) {
            *const_cast<_Vbase*>(_Getptr()) |= _Mask();
        } else {
            *const_cast<_Vbase*>(_Getptr()) &= ~_Mask();
        }

        return *this;
    }

    constexpr void flip() noexcept {
        *const_cast<_Vbase*>(_Getptr()) ^= _Mask();
    }

    constexpr operator bool() const noexcept {
        return (*_Getptr() & _Mask()) != 0;
    }

    constexpr const _Vbase* _Getptr() const noexcept {


#line 2291 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        return this->_Myptr;
    }

    friend constexpr void swap(_Vb_reference _Left, _Vb_reference _Right) noexcept {
        bool _Val = _Left; 
        _Left     = _Right;
        _Right    = _Val;
    }

protected:
    constexpr _Vbase _Mask() const noexcept {
        return static_cast<_Vbase>(1) << this->_Myoff;
    }
};

template <class _Alvbase_wrapped>
class _Vb_const_iterator : public _Vb_iter_base<_Alvbase_wrapped> {
private:
    using _Mybase = _Vb_iter_base<_Alvbase_wrapped>;

public:
    using _Mycont          = typename _Mybase::_Mycont;
    using _Difference_type = typename _Mybase::_Difference_type;
    using _Size_type       = typename _Mybase::_Size_type;
    using _Reft            = _Vb_reference<_Alvbase_wrapped>;
    using const_reference  = bool;

    using iterator_category = random_access_iterator_tag;
    using value_type        = bool;
    using difference_type   = typename _Mybase::_Difference_type;
    using pointer           = const_reference*;
    using reference         = const_reference;

    constexpr _Vb_const_iterator() = default;

    constexpr _Vb_const_iterator(const _Vbase* _Ptr, const _Container_base* _Mypvbool) noexcept
        : _Mybase(_Ptr, 0, _Mypvbool) {}

    [[nodiscard]] constexpr const_reference operator*() const noexcept {


#line 2337 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        return _Reft(*this);
    }

    constexpr _Vb_const_iterator& operator++() noexcept {
        _Inc();
        return *this;
    }

    constexpr _Vb_const_iterator operator++(int) noexcept {
        _Vb_const_iterator _Tmp = *this;
        _Inc();
        return _Tmp;
    }

    constexpr _Vb_const_iterator& operator--() noexcept {
        _Dec();
        return *this;
    }

    constexpr _Vb_const_iterator operator--(int) noexcept {
        _Vb_const_iterator _Tmp = *this;
        _Dec();
        return _Tmp;
    }

    constexpr _Vb_const_iterator& operator+=(const difference_type _Off) noexcept {


#line 2377 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        if (_Off < 0 && this->_Myoff < 0 - static_cast<_Size_type>(_Off)) { 
            this->_Myoff += static_cast<_Size_type>(_Off);
            this->_Myptr -= 1 + (static_cast<_Size_type>(-1) - this->_Myoff) / _VBITS;
            this->_Myoff %= _VBITS;
        } else { 
            this->_Myoff += static_cast<_Size_type>(_Off);
            this->_Myptr += this->_Myoff / _VBITS;
            this->_Myoff %= _VBITS;
        }
        return *this;
    }

    [[nodiscard]] constexpr _Vb_const_iterator operator+(const difference_type _Off) const noexcept {
        _Vb_const_iterator _Tmp = *this;
        _Tmp += _Off;
        return _Tmp;
    }

    constexpr _Vb_const_iterator& operator-=(const difference_type _Off) noexcept {
        return *this += -_Off;
    }

    [[nodiscard]] constexpr _Vb_const_iterator operator-(const difference_type _Off) const noexcept {
        _Vb_const_iterator _Tmp = *this;
        _Tmp -= _Off;
        return _Tmp;
    }

    [[nodiscard]] constexpr difference_type operator-(const _Vb_const_iterator& _Right) const noexcept {
        _Compat(_Right);
        return static_cast<difference_type>(_VBITS * (this->_Myptr - _Right._Myptr))
             + static_cast<difference_type>(this->_Myoff) - static_cast<difference_type>(_Right._Myoff);
    }

    [[nodiscard]] constexpr const_reference operator[](const difference_type _Off) const noexcept {
        return *(*this + _Off);
    }

    [[nodiscard]] constexpr bool operator==(const _Vb_const_iterator& _Right) const noexcept {
        _Compat(_Right);
        return this->_Myptr == _Right._Myptr && this->_Myoff == _Right._Myoff;
    }


    [[nodiscard]] constexpr strong_ordering operator<=>(const _Vb_const_iterator& _Right) const noexcept {
        _Compat(_Right);
        if (const auto _CmpResult = this->_Myptr <=> _Right._Myptr; _CmpResult != 0) {
            return _CmpResult;
        }
        return this->_Myoff <=> _Right._Myoff;
    }


#line 2451 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

    constexpr void _Compat(const _Vb_const_iterator& _Right) const noexcept {
        

        (void) _Right;


#line 2459 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"
    }


#line 2469 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

    constexpr void _Dec() noexcept { 


#line 2476 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        if (this->_Myoff != 0) {
            --this->_Myoff;
        } else { 
            this->_Myoff = _VBITS - 1;
            --this->_Myptr;
        }
    }

    constexpr void _Inc() noexcept { 


#line 2492 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        if (this->_Myoff < _VBITS - 1) {
            ++this->_Myoff;
        } else { 
            this->_Myoff = 0;
            ++this->_Myptr;
        }
    }
};

template <class _Alvbase_wrapped>
[[nodiscard]] constexpr _Vb_const_iterator<_Alvbase_wrapped> operator+(
    typename _Vb_const_iterator<_Alvbase_wrapped>::difference_type _Off,
    _Vb_const_iterator<_Alvbase_wrapped> _Right) noexcept {
    _Right += _Off;
    return _Right;
}

template <class _Alvbase_wrapped>
class _Vb_iterator : public _Vb_const_iterator<_Alvbase_wrapped> {
public:
    using _Mybase          = _Vb_const_iterator<_Alvbase_wrapped>;
    using _Mycont          = typename _Mybase::_Mycont;
    using _Difference_type = typename _Mybase::_Difference_type;

    using _Reft           = _Vb_reference<_Alvbase_wrapped>;
    using const_reference = bool;

    using iterator_category = random_access_iterator_tag;
    using value_type        = bool;
    using difference_type   = typename _Mybase::difference_type;
    using pointer           = _Reft*;
    using reference         = _Reft;

    using _Mybase::_Mybase;

    [[nodiscard]] constexpr reference operator*() const noexcept {


#line 2535 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        return _Reft(*this);
    }

    constexpr _Vb_iterator& operator++() noexcept {
        _Mybase::operator++();
        return *this;
    }

    constexpr _Vb_iterator operator++(int) noexcept {
        _Vb_iterator _Tmp = *this;
        _Mybase::operator++();
        return _Tmp;
    }

    constexpr _Vb_iterator& operator--() noexcept {
        _Mybase::operator--();
        return *this;
    }

    constexpr _Vb_iterator operator--(int) noexcept {
        _Vb_iterator _Tmp = *this;
        _Mybase::operator--();
        return _Tmp;
    }

    constexpr _Vb_iterator& operator+=(const difference_type _Off) noexcept {
        _Mybase::operator+=(_Off);
        return *this;
    }

    [[nodiscard]] constexpr _Vb_iterator operator+(const difference_type _Off) const noexcept {
        _Vb_iterator _Tmp = *this;
        _Tmp += _Off;
        return _Tmp;
    }

    constexpr _Vb_iterator& operator-=(const difference_type _Off) noexcept {
        _Mybase::operator-=(_Off);
        return *this;
    }

    using _Mybase::operator-;

    [[nodiscard]] constexpr _Vb_iterator operator-(const difference_type _Off) const noexcept {
        _Vb_iterator _Tmp = *this;
        _Tmp -= _Off;
        return _Tmp;
    }

    [[nodiscard]] constexpr reference operator[](const difference_type _Off) const noexcept {
        return *(*this + _Off);
    }

    using _Prevent_inheriting_unwrap = _Vb_iterator;
};

template <class _Alvbase_wrapped>
[[nodiscard]] constexpr _Vb_iterator<_Alvbase_wrapped> operator+(
    typename _Vb_iterator<_Alvbase_wrapped>::difference_type _Off, _Vb_iterator<_Alvbase_wrapped> _Right) noexcept {
    _Right += _Off;
    return _Right;
}

template <class _Alloc>
class _Vb_val : public _Container_base {
public:
    using _Alvbase         = _Rebind_alloc_t<_Alloc, _Vbase>;
    using _Alvbase_traits  = allocator_traits<_Alvbase>;
    using _Vectype         = vector<_Vbase, _Alvbase>;
    using _Alvbase_wrapped = _Wrap_alloc<_Alvbase>;
    using size_type        = typename _Alvbase_traits::size_type;

    constexpr _Vb_val() noexcept(is_nothrow_default_constructible_v<_Vectype>) : _Myvec(), _Mysize(0) {
        this->_Alloc_proxy(_Fake_alloc);
    }

    constexpr _Vb_val(const _Alloc& _Al) noexcept(is_nothrow_constructible_v<_Vectype, _Alvbase>)
        : _Myvec(static_cast<_Alvbase>(_Al)), _Mysize(0) {
        this->_Alloc_proxy(_Fake_alloc);
    }

    constexpr _Vb_val(size_type _Count, const bool& _Val)
        : _Myvec(_Nw(_Count), static_cast<_Vbase>(_Val ? -1 : 0)), _Mysize(0) {
        this->_Alloc_proxy(_Fake_alloc);
    }

    constexpr _Vb_val(size_type _Count, const bool& _Val, const _Alloc& _Al)
        : _Myvec(_Nw(_Count), static_cast<_Vbase>(_Val ? -1 : 0), static_cast<_Alvbase>(_Al)), _Mysize(0) {
        this->_Alloc_proxy(_Fake_alloc);
    }

    constexpr _Vb_val(const _Vb_val& _Right) : _Myvec(_Right._Myvec), _Mysize(_Right._Mysize) {
        this->_Alloc_proxy(_Fake_alloc);
    }

    constexpr _Vb_val(const _Vb_val& _Right, const _Alloc& _Al)
        : _Myvec(_Right._Myvec, static_cast<_Alvbase>(_Al)), _Mysize(_Right._Mysize) {
        this->_Alloc_proxy(_Fake_alloc);
    }

    constexpr _Vb_val(_Vb_val&& _Right) noexcept(is_nothrow_move_constructible_v<_Vectype>)
        : _Myvec(::std:: move(_Right._Myvec)), _Mysize(::std:: exchange(_Right._Mysize, size_type{0})) {
        this->_Alloc_proxy(_Fake_alloc);
    }

    constexpr _Vb_val(_Vb_val&& _Right, const _Alloc& _Al) noexcept(
        is_nothrow_constructible_v<_Vectype, _Vectype, _Alvbase>)
        : _Myvec(::std:: move(_Right._Myvec), static_cast<_Alvbase>(_Al)), _Mysize(_Right._Mysize) {
        if (_Right._Myvec.empty()) {
            
            _Right._Mysize = 0;
        }

        this->_Alloc_proxy(_Fake_alloc);
    }

    constexpr ~_Vb_val() noexcept {


#line 2658 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"
    }

    constexpr _Alvbase& _Getal() noexcept {
        return _Myvec._Getal();
    }

    constexpr const _Alvbase& _Getal() const noexcept {
        return _Myvec._Getal();
    }

    static constexpr size_type _Nw(size_type _Count) noexcept {
        return (_Count + _VBITS - 1) / _VBITS;
    }

    _Vectype _Myvec; 
    size_type _Mysize; 
};

template <class _Alloc>
class vector<bool, _Alloc> : public _Vb_val<_Alloc> {
public:
    static_assert(!1 || is_same_v<bool, typename _Alloc::value_type>,
        "vector<bool, Allocator>" " requires that Allocator's value_type match " "bool" " (See N4659 26.2.1 [container.requirements.general]/16 allocator_type)" " Either fix the allocator value_type or define _ENFORCE_MATCHING_ALLOCATORS=0" " to suppress this diagnostic.");

    using _Mybase          = _Vb_val<_Alloc>;
    using _Alvbase_wrapped = typename _Mybase::_Alvbase_wrapped;
    using _Alvbase         = typename _Mybase::_Alvbase;
    using _Alvbase_traits  = typename _Mybase::_Alvbase_traits;

    using size_type       = typename _Alvbase_traits::size_type;
    using difference_type = typename _Alvbase_traits::difference_type;
    using allocator_type  = _Alloc;

    using reference       = _Vb_reference<_Alvbase_wrapped>;
    using const_reference = bool;
    using value_type      = bool;

    using _Reft          = reference;
    using iterator       = _Vb_iterator<_Alvbase_wrapped>;
    using const_iterator = _Vb_const_iterator<_Alvbase_wrapped>;

    using pointer                = iterator;
    using const_pointer          = const_iterator;
    using reverse_iterator       = ::std:: reverse_iterator<iterator>;
    using const_reverse_iterator = ::std:: reverse_iterator<const_iterator>;

    static const int _VBITS = ::std:: _VBITS;
    enum { _EEN_VBITS = _VBITS }; 

    constexpr vector() noexcept(is_nothrow_default_constructible_v<_Mybase>) 
        : _Mybase() {}

    constexpr explicit vector(const _Alloc& _Al) noexcept(
        is_nothrow_constructible_v<_Mybase, const _Alloc&>) 
        : _Mybase(_Al) {}

    constexpr explicit vector( size_type _Count, const _Alloc& _Al = _Alloc())
        : _Mybase(_Count, false, _Al) {
        _Trim(_Count);
    }

    constexpr vector( size_type _Count, const bool& _Val, const _Alloc& _Al = _Alloc())
        : _Mybase(_Count, _Val, _Al) {
        _Trim(_Count);
    }

    constexpr vector(const vector& _Right) : _Mybase(_Right) {}

    constexpr vector(const vector& _Right, const _Identity_t<_Alloc>& _Al) : _Mybase(_Right, _Al) {}

    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
    constexpr vector(_Iter _First, _Iter _Last, const _Alloc& _Al = _Alloc()) : _Mybase(_Al) {
        _BConstruct(_First, _Last);
    }

    template <class _Iter>
    constexpr void _BConstruct(_Iter _First, _Iter _Last) {
        insert(begin(), _First, _Last);
    }

    constexpr vector(vector&& _Right) noexcept(is_nothrow_move_constructible_v<_Mybase>) 
        : _Mybase(::std:: move(_Right)) {
        this->_Swap_proxy_and_iterators(_Right);
    }

    constexpr vector(vector&& _Right, const _Identity_t<_Alloc>& _Al) noexcept(
        is_nothrow_constructible_v<_Mybase, _Mybase, const _Alloc&>)
        : _Mybase(::std:: move(_Right), _Al) {
        if constexpr (!_Alvbase_traits::is_always_equal::value) {
            if (this->_Getal() != _Right._Getal()) {
                return;
            }
        }

        this->_Swap_proxy_and_iterators(_Right);
    }

public:
    constexpr vector& operator=(vector&& _Right) noexcept(is_nothrow_move_assignable_v<_Mybase>) {
        if (this == ::std:: addressof(_Right)) {
            return *this;
        }


        this->_Myvec  = ::std:: move(_Right._Myvec);
        this->_Mysize = ::std:: exchange(_Right._Mysize, size_type{0});


#line 2801 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"
        return *this;
    }

    template <class... _Valty>
    constexpr decltype(auto) emplace_back(_Valty&&... _Val) {
        bool _Tmp(::std:: forward<_Valty>(_Val)...);
        push_back(_Tmp);


        return back();
#line 2812 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"
    }

    template <class... _Valty>
    constexpr iterator emplace(const_iterator _Where, _Valty&&... _Val) {
        bool _Tmp(::std:: forward<_Valty>(_Val)...);
        return insert(_Where, _Tmp);
    }

    constexpr vector(initializer_list<bool> _Ilist, const _Alloc& _Al = allocator_type()) : _Mybase(0, false, _Al) {
        insert(begin(), _Ilist.begin(), _Ilist.end());
    }

    constexpr vector& operator=(initializer_list<bool> _Ilist) {
        assign(_Ilist.begin(), _Ilist.end());
        return *this;
    }

    constexpr void assign(initializer_list<bool> _Ilist) {
        assign(_Ilist.begin(), _Ilist.end());
    }

    constexpr iterator insert(const_iterator _Where, initializer_list<bool> _Ilist) {
        return insert(_Where, _Ilist.begin(), _Ilist.end());
    }

    constexpr ~vector() noexcept {}

public:
    constexpr vector& operator=(const vector& _Right) {
        if (this == ::std:: addressof(_Right)) {
            return *this;
        }


        this->_Myvec  = _Right._Myvec;
        this->_Mysize = _Right._Mysize;


#line 2869 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        return *this;
    }

    constexpr void reserve( size_type _Count) {
        this->_Myvec.reserve(this->_Nw(_Count));
    }

    [[nodiscard]] constexpr size_type capacity() const noexcept {
        return this->_Myvec.capacity() * _VBITS;
    }

    [[nodiscard]] constexpr iterator begin() noexcept {
        return iterator(this->_Myvec.data(), this);
    }

    [[nodiscard]] constexpr const_iterator begin() const noexcept {
        return const_iterator(this->_Myvec.data(), this);
    }

    [[nodiscard]] constexpr iterator end() noexcept {
        return begin() + static_cast<difference_type>(this->_Mysize);
    }

    [[nodiscard]] constexpr const_iterator end() const noexcept {
        return begin() + static_cast<difference_type>(this->_Mysize);
    }

    [[nodiscard]] constexpr const_iterator cbegin() const noexcept {
        return begin();
    }

    [[nodiscard]] constexpr const_iterator cend() const noexcept {
        return end();
    }

    [[nodiscard]] constexpr const_reverse_iterator crbegin() const noexcept {
        return rbegin();
    }

    [[nodiscard]] constexpr const_reverse_iterator crend() const noexcept {
        return rend();
    }

    [[nodiscard]] constexpr iterator _Unchecked_begin() noexcept {
        return iterator(this->_Myvec.data(), this);
    }

    [[nodiscard]] constexpr const_iterator _Unchecked_begin() const noexcept {
        return const_iterator(this->_Myvec.data(), this);
    }

    [[nodiscard]] constexpr iterator _Unchecked_end() noexcept {
        return _Unchecked_begin() + static_cast<difference_type>(this->_Mysize);
    }

    [[nodiscard]] constexpr const_iterator _Unchecked_end() const noexcept {
        return _Unchecked_begin() + static_cast<difference_type>(this->_Mysize);
    }

    constexpr void shrink_to_fit() {
        if (this->_Myvec.capacity() != this->_Myvec.size()) {
            this->_Orphan_all();
            this->_Myvec.shrink_to_fit();
        }
    }

    constexpr iterator _Make_iter(const_iterator _Where) noexcept {
        iterator _Tmp = begin();
        if (0 < this->_Mysize) {
            _Tmp += _Where - begin();
        }

        return _Tmp;
    }

    [[nodiscard]] constexpr reverse_iterator rbegin() noexcept {
        return reverse_iterator(end());
    }

    [[nodiscard]] constexpr const_reverse_iterator rbegin() const noexcept {
        return const_reverse_iterator(end());
    }

    [[nodiscard]] constexpr reverse_iterator rend() noexcept {
        return reverse_iterator(begin());
    }

    [[nodiscard]] constexpr const_reverse_iterator rend() const noexcept {
        return const_reverse_iterator(begin());
    }

    constexpr void resize( size_type _Newsize, bool _Val = false) {
        if (size() < _Newsize) {
            _Insert_n(end(), _Newsize - size(), _Val);
        } else if (_Newsize < size()) {
            erase(begin() + static_cast<difference_type>(_Newsize), end());
        }
    }

    [[nodiscard]] constexpr size_type size() const noexcept {
        return this->_Mysize;
    }

    [[nodiscard]] constexpr size_type max_size() const noexcept {
        constexpr auto _Diff_max  = static_cast<size_type>((numeric_limits<difference_type>::max)());
        const size_type _Ints_max = this->_Myvec.max_size();
        if (_Ints_max > _Diff_max / _VBITS) { 
            return _Diff_max;
        }

        
        return _Ints_max * _VBITS;
    }

    [[nodiscard]] constexpr bool empty() const noexcept {
        return this->_Mysize == 0;
    }

    [[nodiscard]] constexpr allocator_type get_allocator() const noexcept {
        return static_cast<allocator_type>(this->_Myvec.get_allocator());
    }

    [[nodiscard]] constexpr const_reference at(size_type _Off) const {
        if (size() <= _Off) {
            _Xran();
        }

        return (*this)[_Off];
    }

    [[nodiscard]] constexpr reference at(size_type _Off) {
        if (size() <= _Off) {
            _Xran();
        }

        return (*this)[_Off];
    }

    [[nodiscard]] constexpr const_reference operator[](size_type _Off) const noexcept  {


#line 3012 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        const_iterator _It = begin();
        _It._Advance(_Off);
        return *_It;
    }

    [[nodiscard]] constexpr reference operator[](size_type _Off) noexcept  {


#line 3022 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        iterator _It = begin();
        _It._Advance(_Off);
        return *_It;
    }

    [[nodiscard]] constexpr reference front() noexcept  {


#line 3032 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        return *begin();
    }

    [[nodiscard]] constexpr const_reference front() const noexcept  {


#line 3040 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        return *begin();
    }

    [[nodiscard]] constexpr reference back() noexcept  {


#line 3048 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        return *(end() - 1);
    }

    [[nodiscard]] constexpr const_reference back() const noexcept  {


#line 3056 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        return *(end() - 1);
    }

    constexpr void push_back(const bool& _Val) {
        insert(end(), _Val);
    }

    constexpr void pop_back() noexcept  {
        erase(end() - 1);
    }

    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
    constexpr void assign(_Iter _First, _Iter _Last) {
        clear();
        insert(begin(), _First, _Last);
    }

    constexpr void assign( size_type _Count, const bool& _Val) {
        clear();
        _Insert_n(begin(), _Count, _Val);
    }

    constexpr iterator insert(const_iterator _Where, const bool& _Val) {
        return _Insert_n(_Where, static_cast<size_type>(1), _Val);
    }

    constexpr iterator insert(const_iterator _Where,  size_type _Count, const bool& _Val) {
        return _Insert_n(_Where, _Count, _Val);
    }

    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
    constexpr iterator insert(const_iterator _Where, _Iter _First, _Iter _Last) {
        difference_type _Off = _Where - begin();
        _Insert(_Where, _First, _Last, _Iter_cat_t<_Iter>{});
        return begin() + _Off;
    }

    template <class _Iter>
    constexpr void _Insert(const_iterator _Where, _Iter _First, _Iter _Last, input_iterator_tag) {
        difference_type _Off = _Where - begin();

        for (; _First != _Last; ++_First, (void) ++_Off) {
            insert(begin() + _Off, *_First);
        }
    }

    template <class _Iter>
    constexpr void _Insert(const_iterator _Where, _Iter _First, _Iter _Last, forward_iterator_tag) {
        _Adl_verify_range(_First, _Last);
        auto _Count    = _Convert_size<size_type>(static_cast<size_t>(::std:: distance(_First, _Last)));
        size_type _Off = _Insert_x(_Where, _Count);
        _Copy_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last), begin() + static_cast<difference_type>(_Off));
    }

    constexpr iterator erase(const_iterator _Where_arg) noexcept  {
        iterator _Where      = _Make_iter(_Where_arg);
        difference_type _Off = _Where - begin();


#line 3121 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"
        ::std:: copy(_Next_iter(_Where), end(), _Where);
#line 3123 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        _Trim(this->_Mysize - 1);
        return begin() + _Off;
    }

    constexpr iterator erase(const_iterator _First_arg, const_iterator _Last_arg) noexcept
     {
        iterator _First      = _Make_iter(_First_arg);
        iterator _Last       = _Make_iter(_Last_arg);
        difference_type _Off = _First - begin();

        if (_First != _Last) { 


#line 3143 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"
            iterator _Next = ::std:: copy(_Last, end(), _First);
            _Trim(static_cast<size_type>(_Next - begin()));
#line 3146 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"
        }
        return begin() + _Off;
    }

    constexpr void clear() noexcept {
        this->_Orphan_all();
        this->_Myvec.clear();
        this->_Mysize = 0;
    }

    constexpr void flip() noexcept { 
        for (auto& _Elem : this->_Myvec) {
            _Elem = ~_Elem;
        }

        _Trim(this->_Mysize);
    }

    constexpr void swap(vector& _Right) noexcept  {
        if (this != ::std:: addressof(_Right)) {
            this->_Swap_proxy_and_iterators(_Right);
            this->_Myvec.swap(_Right._Myvec);
            ::std:: swap(this->_Mysize, _Right._Mysize);
        }
    }

    static constexpr void swap(reference _Left, reference _Right) noexcept {
        bool _Val = _Left; 
        _Left     = _Right;
        _Right    = _Val;
    }

    friend hash<vector<bool, _Alloc>>;

    constexpr iterator _Insert_n(const_iterator _Where, size_type _Count, const bool& _Val) {
        size_type _Off     = _Insert_x(_Where, _Count);
        const auto _Result = begin() + static_cast<difference_type>(_Off);
        ::std:: fill(_Result, _Result + static_cast<difference_type>(_Count), _Val);
        return _Result;
    }

    constexpr size_type _Insert_x(const_iterator _Where, size_type _Count) {
        difference_type _Off = _Where - begin();


#line 3194 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

        if (_Count != 0) {
            if (max_size() - size() < _Count) {
                _Xlen(); 
            }

            
            this->_Myvec.resize(this->_Nw(size() + _Count), 0);
            if (empty()) {
                this->_Mysize += _Count;
            } else { 
                iterator _Oldend = end();
                this->_Mysize += _Count;
                ::std:: copy_backward(begin() + _Off, _Oldend, end());
            }


#line 3213 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"
        }

        return static_cast<size_type>(_Off);
    }


#line 3257 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

    constexpr void _Trim(size_type _Size) {
        if (max_size() < _Size) {
            _Xlen(); 
        }

        const size_type _Words = this->_Nw(_Size);
        if (_Words < this->_Myvec.size()) {
            this->_Myvec.erase(this->_Myvec.begin() + static_cast<difference_type>(_Words), this->_Myvec.end());
        }

        this->_Mysize = _Size;
        _Size %= _VBITS;
        if (0 < _Size) {
            this->_Myvec[_Words - 1] &= (static_cast<_Vbase>(1) << _Size) - 1;
        }
    }

    [[noreturn]] void _Xlen() const {
        _Xlength_error("vector<bool> too long");
    }

    [[noreturn]] void _Xran() const {
        _Xout_of_range("invalid vector<bool> subscript");
    }
};

template <class _Alloc>
struct hash<vector<bool, _Alloc>> {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef vector<bool, _Alloc> _Unnameable_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef size_t _Unnameable_result;

    [[nodiscard]] size_t operator()(const vector<bool, _Alloc>& _Keyval) const noexcept {
        return _Hash_array_representation(_Keyval._Myvec.data(), _Keyval._Myvec.size());
    }
};


namespace pmr {
    template <class _Ty>
    using vector = ::std:: vector<_Ty, polymorphic_allocator<_Ty>>;
} 
#line 3300 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"

template <class _Alloc, bool _RequiresMutable>
inline constexpr bool _Is_vb_iterator<_Vb_iterator<_Alloc>, _RequiresMutable> = true;

template <class _Alloc>
inline constexpr bool _Is_vb_iterator<_Vb_const_iterator<_Alloc>, false> = true;

template <class _VbIt>
constexpr void _Fill_vbool(_VbIt _First, const _VbIt _Last, const bool _Val) noexcept {
    
    if (_First == _Last) {
        return;
    }

    _Vbase* _VbFirst      = const_cast<_Vbase*>(_First._Myptr);
    _Vbase* const _VbLast = const_cast<_Vbase*>(_Last._Myptr);

    const auto _FirstSourceMask = static_cast<_Vbase>(-1) << _First._Myoff;
    const auto _FirstDestMask   = ~_FirstSourceMask;
    const auto _FillVal         = static_cast<_Vbase>(_Val ? -1 : 0);

    if (_VbFirst == _VbLast) {
        
        const auto _LastSourceMask = static_cast<_Vbase>(-1) >> (_VBITS - _Last._Myoff);
        const auto _LastDestMask   = ~_LastSourceMask;
        const auto _SourceMask     = _FirstSourceMask & _LastSourceMask;
        const auto _DestMask       = _FirstDestMask | _LastDestMask;
        *_VbFirst                  = (*_VbFirst & _DestMask) | (_FillVal & _SourceMask);
        return;
    }

    *_VbFirst = (*_VbFirst & _FirstDestMask) | (_FillVal & _FirstSourceMask);
    ++_VbFirst;


    if (::std:: is_constant_evaluated()) {
        for (; _VbFirst != _VbLast; ++_VbFirst) {
            *_VbFirst = _FillVal;
        }
    } else
#line 3341 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"
    {
        const auto _VbFirst_ch = reinterpret_cast<const char*>(_VbFirst);
        const auto _VbLast_ch  = reinterpret_cast<const char*>(_VbLast);
        const auto _Count_ch   = static_cast<size_t>(_VbLast_ch - _VbFirst_ch);
        const auto _ValChar    = static_cast<unsigned char>(_Val ? -1 : 0);
        :: memset(_VbFirst, _ValChar, _Count_ch);
        _VbFirst = _VbLast;
    }

    if (_Last._Myoff != 0) {
        const auto _LastSourceMask = static_cast<_Vbase>(-1) >> (_VBITS - _Last._Myoff);
        const auto _LastDestMask   = ~_LastSourceMask;
        *_VbFirst                  = (*_VbFirst & _LastDestMask) | (_FillVal & _LastSourceMask);
    }
}

template <class _VbIt>
[[nodiscard]] constexpr _VbIt _Find_vbool(_VbIt _First, const _VbIt _Last, const bool _Val) noexcept {
    
    if (_First == _Last) {
        return _First;
    }

    const _Vbase* _VbFirst      = _First._Myptr;
    const _Vbase* const _VbLast = _Last._Myptr;

    const auto _FirstSourceMask = static_cast<_Vbase>(-1) << _First._Myoff;

    if (_VbFirst == _VbLast) {
        
        const auto _LastSourceMask = static_cast<_Vbase>(-1) >> (_VBITS - _Last._Myoff);
        const auto _SourceMask     = _FirstSourceMask & _LastSourceMask;
        const auto _SelectVal      = (_Val ? *_VbFirst : ~*_VbFirst) & _SourceMask;
        const auto _Count          = _Countr_zero(_SelectVal);
        return _Count == _VBITS ? _Last : _First + static_cast<ptrdiff_t>(_Count - _First._Myoff);
    }

    const auto _FirstVal   = (_Val ? *_VbFirst : ~*_VbFirst) & _FirstSourceMask;
    const auto _FirstCount = _Countr_zero(_FirstVal);
    if (_FirstCount != _VBITS) {
        return _First + static_cast<ptrdiff_t>(_FirstCount - _First._Myoff);
    }
    ++_VbFirst;

    _Iter_diff_t<_VbIt> _TotalCount = static_cast<ptrdiff_t>(_VBITS - _First._Myoff);
    for (; _VbFirst != _VbLast; ++_VbFirst, _TotalCount += _VBITS) {
        const auto _SelectVal = _Val ? *_VbFirst : ~*_VbFirst;
        const auto _Count     = _Countr_zero(_SelectVal);
        if (_Count != _VBITS) {
            return _First + (_TotalCount + _Count);
        }
    }

    if (_Last._Myoff != 0) {
        const auto _LastSourceMask = static_cast<_Vbase>(-1) >> (_VBITS - _Last._Myoff);
        const auto _LastVal        = (_Val ? *_VbFirst : ~*_VbFirst) & _LastSourceMask;
        const auto _Count          = _Countr_zero(_LastVal);
        if (_Count != _VBITS) {
            return _First + (_TotalCount + _Count);
        }
    }

    return _Last;
}

template <class _VbIt>
[[nodiscard]] constexpr _Iter_diff_t<_VbIt> _Count_vbool(_VbIt _First, const _VbIt _Last, const bool _Val) noexcept {
    if (_First == _Last) {
        return 0;
    }

    const _Vbase* _VbFirst      = _First._Myptr;
    const _Vbase* const _VbLast = _Last._Myptr;

    const auto _FirstSourceMask = static_cast<_Vbase>(-1) << _First._Myoff;

    if (_VbFirst == _VbLast) {
        
        const auto _LastSourceMask = static_cast<_Vbase>(-1) >> (_VBITS - _Last._Myoff);
        const auto _SourceMask     = _FirstSourceMask & _LastSourceMask;
        const auto _SelectVal      = (_Val ? *_VbFirst : ~*_VbFirst) & _SourceMask;
        return _Popcount(_SelectVal);
    }

    return _Select_popcount_impl<_Vbase>(
        [_Last, _Val, _VbFirst, _VbLast, _FirstSourceMask](auto _Popcount_impl) mutable noexcept {
            const auto _FirstVal       = (_Val ? *_VbFirst : ~*_VbFirst) & _FirstSourceMask;
            _Iter_diff_t<_VbIt> _Count = _Popcount_impl(_FirstVal);
            ++_VbFirst;

            for (; _VbFirst != _VbLast; ++_VbFirst) {
                const auto _SelectVal = _Val ? *_VbFirst : ~*_VbFirst;
                _Count += _Popcount_impl(_SelectVal);
            }

            if (_Last._Myoff != 0) {
                const auto _LastSourceMask = static_cast<_Vbase>(-1) >> (_VBITS - _Last._Myoff);
                const auto _LastVal        = (_Val ? *_VbFirst : ~*_VbFirst) & _LastSourceMask;
                _Count += _Popcount_impl(_LastVal);
            }

            return _Count;
        });
}


}


#pragma warning(pop)
#pragma pack(pop)
#line 3461 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"
#line 3462 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vector"
#line 31 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xloctime"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
struct  time_base : locale::facet { 
    enum dateorder { 
        no_order,
        dmy,
        mdy,
        ymd,
        ydm
    };

     time_base(size_t _Refs = 0) : locale::facet(_Refs) {}

     ~time_base() noexcept override {}
};

template <class _Elem, class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem>>>
class time_get : public time_base { 
private:
    friend _Tidy_guard<time_get>;

public:
    static_assert(!0 || _Is_any_of_v<_Elem, char, wchar_t, unsigned short>,
        "Unsupported facet specialization; see N4800 27.3.1.1.1 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this diagnostic.");

    using char_type = _Elem;
    using iter_type = _InIt;
    using _Ctype    = ctype<_Elem>;

     static locale::id id; 

    dateorder  date_order() const {
        return do_date_order();
    }

    _InIt  get_time(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
        tm* _Pt) const { 
        return do_get_time(_First, _Last, _Iosbase, _State, _Pt);
    }

    _InIt  get_date(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
        tm* _Pt) const { 
        return do_get_date(_First, _Last, _Iosbase, _State, _Pt);
    }

    _InIt  get_weekday(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
        tm* _Pt) const { 
        return do_get_weekday(_First, _Last, _Iosbase, _State, _Pt);
    }

    _InIt  get_monthname(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
        tm* _Pt) const { 
        return do_get_monthname(_First, _Last, _Iosbase, _State, _Pt);
    }

    _InIt  get_year(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
        tm* _Pt) const { 
        return do_get_year(_First, _Last, _Iosbase, _State, _Pt);
    }

    _InIt  get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State, tm* _Pt,
        char _Specifier, char _Modifier = '\0') const { 
        return do_get(_First, _Last, _Iosbase, _State, _Pt, _Specifier, _Modifier);
    }

    _InIt  get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State, tm* _Pt,
        const _Elem* _Fmtfirst, const _Elem* _Fmtlast) const { 
        _Adl_verify_range(_Fmtfirst, _Fmtlast);
        const _Ctype& _Ctype_fac = ::std:: use_facet<_Ctype>(_Iosbase.getloc());

        _State = ios_base::goodbit;

        for (; _Fmtfirst != _Fmtlast; ++_Fmtfirst) {
            if (_State != ios_base::goodbit) {
                
                
                break;
            } else if (_First == _Last) {
                
                _State = ios_base::eofbit | ios_base::failbit;
                break;
            } else if (_Ctype_fac.narrow(*_Fmtfirst) != '%') { 
                if (_Ctype_fac.is(_Ctype::space, *_Fmtfirst)) {
                    while (_First != _Last && _Ctype_fac.is(_Ctype::space, *_First)) {
                        ++_First;
                    }
                } else if (_Ctype_fac.tolower(*_First) != _Ctype_fac.tolower(*_Fmtfirst)) { 
                    _State |= ios_base::failbit;
                    break;
                } else {
                    ++_First;
                }
            } else if (++_Fmtfirst == _Fmtlast) {
                
                
                _State = ios_base::failbit;
                break;
            } else { 
                char _Specifier = _Ctype_fac.narrow(*_Fmtfirst);
                char _Modifier  = '\0';

                if (_Specifier == 'E' || _Specifier == 'O' || _Specifier == 'Q' || _Specifier == '#') {
                    if (++_Fmtfirst == _Fmtlast) { 
                        _State = ios_base::failbit;
                        break;
                    } else { 
                        _Modifier  = _Specifier;
                        _Specifier = _Ctype_fac.narrow(*_Fmtfirst);
                    }
                }

                _First = do_get(_First, _Last, _Iosbase, _State, _Pt, _Specifier, _Modifier); 
            }
        }

        return _First;
    }

    explicit  time_get(size_t _Refs = 0) : time_base(_Refs) { 
        { _Locinfo _Lobj;
        _Init(_Lobj);
        }
    }

     time_get(const _Locinfo& _Lobj, size_t _Refs = 0) : time_base(_Refs) {
        _Init(_Lobj);
    }

    static size_t __cdecl _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
        
        if (_Ppf && !*_Ppf) {
            *_Ppf = new time_get<_Elem, _InIt>(_Locinfo(_Ploc->c_str()));
        }

        return 5;
    }

protected:
     ~time_get() noexcept override {
        _Tidy();
    }

     time_get(const char* _Locname, size_t _Refs = 0) : time_base(_Refs) {
        { _Locinfo _Lobj(_Locname);
        _Init(_Lobj);
        }
    }

    template <class _Elem2>
    void  _Getvals(_Elem2, const _Locinfo& _Lobj) { 
        _Cvt = _Lobj._Getcvt();

        if (is_same_v<_Elem2, wchar_t>) {
            _Days = reinterpret_cast<const _Elem*>(_Maklocwcs(reinterpret_cast<const wchar_t*>(_Lobj._W_Getdays())));
            _Months =
                reinterpret_cast<const _Elem*>(_Maklocwcs(reinterpret_cast<const wchar_t*>(_Lobj._W_Getmonths())));
            _Ampm = reinterpret_cast<const _Elem*>(_Maklocwcs(L":AM:am:PM:pm"));
        } else {
            _Days   = _Maklocstr(_Lobj._Getdays(), static_cast<_Elem*>(nullptr), _Cvt);
            _Months = _Maklocstr(_Lobj._Getmonths(), static_cast<_Elem*>(nullptr), _Cvt);
            _Ampm   = _Maklocstr(":AM:am:PM:pm", static_cast<_Elem*>(nullptr), _Cvt);
        }
    }

    void  _Init(const _Locinfo& _Lobj) { 
        _Days   = nullptr;
        _Months = nullptr;
        _Ampm   = nullptr;

        _Tidy_guard<time_get> _Guard{this};
        _Getvals(_Elem{}, _Lobj);
        _Dateorder     = static_cast<dateorder>(_Lobj._Getdateorder());
        _Guard._Target = nullptr;
    }

    virtual dateorder  do_date_order() const {
        return _Dateorder;
    }

    virtual _InIt  do_get_time(_InIt _First, _InIt _Last, ios_base& _Iosbase,
        ios_base::iostate& _State, tm* _Pt) const { 
        const _Ctype& _Ctype_fac = ::std:: use_facet<_Ctype>(_Iosbase.getloc());

        _State |= _Getint(_First, _Last, 0, 23, _Pt->tm_hour, _Ctype_fac);

        if (_State != ios_base::goodbit || _Ctype_fac.narrow(*_First) != ':') {
            _State |= ios_base::failbit; 
        } else {
            _State |= _Getint(++_First, _Last, 0, 59, _Pt->tm_min, _Ctype_fac);
        }

        if (_State != ios_base::goodbit || _Ctype_fac.narrow(*_First) != ':') {
            _State |= ios_base::failbit; 
        } else {
            _State |= _Getint(++_First, _Last, 0, 60, _Pt->tm_sec, _Ctype_fac);
        }

        return _First;
    }

    virtual _InIt  do_get_date(_InIt _First, _InIt _Last, ios_base& _Iosbase,
        ios_base::iostate& _State, tm* _Pt) const { 
        const _Ctype& _Ctype_fac = ::std:: use_facet<_Ctype>(_Iosbase.getloc());

        dateorder _Dorder = date_order();
        if (_Dorder == no_order) {
            _Dorder = mdy;
        }

        if (_First != _Last) {
            if (!_Ctype_fac.is(_Ctype::digit, *_First)) { 
                _First  = get_monthname(_First, _Last, _Iosbase, _State, _Pt);
                _Dorder = mdy;
            } else if (_Dorder == mdy) { 
                _State |= _Getint(_First, _Last, 1, 12, _Pt->tm_mon, _Ctype_fac);
                --_Pt->tm_mon;
            } else if (_Dorder == dmy) {
                _State |= _Getint(_First, _Last, 1, 31, _Pt->tm_mday, _Ctype_fac);
            } else { 
                _First = get_year(_First, _Last, _Iosbase, _State, _Pt);
            }
        }

        while (_First != _Last && _Ctype_fac.is(_Ctype::space, *_First)) {
            ++_First; 
        }

        if (_First != _Last) { 
            char _Ch = _Ctype_fac.narrow(*_First);
            if (_Ch == ':' || _Ch == ',' || _Ch == '/') {
                ++_First;
            }
        }

        while (_First != _Last && _Ctype_fac.is(_Ctype::space, *_First)) {
            ++_First; 
        }

        if (_First != _Last) {
            if (!_Ctype_fac.is(_Ctype::digit, *_First)) {
                if (_Dorder == mdy) {
                    _State |= ios_base::failbit; 
                } else { 
                    _First = get_monthname(_First, _Last, _Iosbase, _State, _Pt);
                    if (_Dorder == ydm) {
                        _Dorder = ymd;
                    }
                }
            } else if (_Dorder == dmy || _Dorder == ymd) { 
                _State |= _Getint(_First, _Last, 1, 12, _Pt->tm_mon, _Ctype_fac);
                --_Pt->tm_mon;
            } else {
                _State |= _Getint(_First, _Last, 1, 31, _Pt->tm_mday, _Ctype_fac);
            }
        }

        while (_First != _Last && _Ctype_fac.is(_Ctype::space, *_First)) {
            ++_First; 
        }

        if (_First != _Last) { 
            char _Ch = _Ctype_fac.narrow(*_First);
            if (_Ch == ':' || _Ch == ',' || _Ch == '/') {
                ++_First;
            }
        }

        while (_First != _Last && _Ctype_fac.is(_Ctype::space, *_First)) {
            ++_First; 
        }

        if (_First == _Last) {
            _State |= ios_base::failbit; 
        } else if (!_Ctype_fac.is(_Ctype::digit, *_First)) {
            if (_Dorder != ydm) {
                _State |= ios_base::failbit; 
            } else {
                _First = get_monthname(_First, _Last, _Iosbase, _State, _Pt);
            }
        } else if (_Dorder == ydm) { 
            _State |= _Getint(_First, _Last, 1, 12, _Pt->tm_mon, _Ctype_fac);
            --_Pt->tm_mon;
        } else if (_Dorder == ymd) {
            _State |= _Getint(_First, _Last, 1, 31, _Pt->tm_mday, _Ctype_fac);
        } else { 
            _First = get_year(_First, _Last, _Iosbase, _State, _Pt);
        }

        if (_First == _Last) {
            _State |= ios_base::eofbit;
        }

        return _First;
    }

    virtual _InIt  do_get_weekday(_InIt _First, _InIt _Last, ios_base&, ios_base::iostate& _State,
        tm* _Pt) const { 
        int _Num = _Getloctxt(_First, _Last, 0, _Days, _Case_sensitive::_Nope);
        if (_Num < 0) {
            _State |= ios_base::failbit;
        } else {
            _Pt->tm_wday = _Num >> 1; 
        }

        return _First;
    }

    virtual _InIt  do_get_monthname(_InIt _First, _InIt _Last, ios_base&, ios_base::iostate& _State,
        tm* _Pt) const { 
        int _Num = _Getloctxt(_First, _Last, 0, _Months, _Case_sensitive::_Nope);

        if (_Num < 0) {
            _State |= ios_base::failbit;
        } else {
            _Pt->tm_mon = _Num >> 1; 
        }

        return _First;
    }

    virtual _InIt  do_get_year(_InIt _First, _InIt _Last, ios_base& _Iosbase,
        ios_base::iostate& _State, tm* _Pt) const { 
        const _Ctype& _Ctype_fac = ::std:: use_facet<_Ctype>(_Iosbase.getloc());

        int _Ans               = 0;
        ios_base::iostate _Res = _Getint(_First, _Last, 0, 9999, _Ans, _Ctype_fac);

        _State |= _Res; 
        if (!(_Res & ios_base::failbit)) {
            if (_Ans < 69) {
                _Pt->tm_year = _Ans + 100; 
            } else if (_Ans < 100) {
                _Pt->tm_year = _Ans; 
            } else {
                _Pt->tm_year = _Ans - 1900; 
            }
        }

        return _First;
    }

    virtual _InIt  do_get(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State,
        tm* _Pt, char _Specifier, char = 0) const { 
        const _Ctype& _Ctype_fac = ::std:: use_facet<_Ctype>(_Iosbase.getloc());
        int _Ans                 = 0;

        _State = ios_base::goodbit;

        switch (_Specifier) { 
        case 'a':
        case 'A':
            _First = get_weekday(_First, _Last, _Iosbase, _State, _Pt);
            break;

        case 'b':
        case 'B':
        case 'h':
            _First = get_monthname(_First, _Last, _Iosbase, _State, _Pt);
            break;

        case 'c':
            _First = _Getfmt(_First, _Last, _Iosbase, _State, _Pt, "%b %d %H : %M : %S %Y");
            break;

        case 'C':
            _State |= _Getint(_First, _Last, 0, 99, _Ans, _Ctype_fac);
            if (!(_State & ios_base::failbit)) {
                _Pt->tm_year = _Ans * 100 - 1900; 
            }

            break;

        case 'd':
        case 'e':
            _State |= _Getint(_First, _Last, 1, 31, _Pt->tm_mday, _Ctype_fac);
            break;

        case 'D':
            _First = _Getfmt(_First, _Last, _Iosbase, _State, _Pt, "%m / %d / %y");
            break;

        case 'H':
            _State |= _Getint(_First, _Last, 0, 23, _Pt->tm_hour, _Ctype_fac);
            break;

        case 'I':
            _State |= _Getint(_First, _Last, 1, 12, _Ans, _Ctype_fac);
            if (!(_State & ios_base::failbit)) {
                _Pt->tm_hour = _Ans == 12 ? 0 : _Ans;
            }

            break;

        case 'j':
            _State |= _Getint(_First, _Last, 1, 366, _Pt->tm_yday, _Ctype_fac);
            break;

        case 'm':
            _State |= _Getint(_First, _Last, 1, 12, _Ans, _Ctype_fac);
            if (!(_State & ios_base::failbit)) {
                _Pt->tm_mon = _Ans - 1;
            }

            break;

        case 'M':
            _State |= _Getint(_First, _Last, 0, 59, _Pt->tm_min, _Ctype_fac);
            break;

        case 'n':
        case 't':
            _First = _Getfmt(_First, _Last, _Iosbase, _State, _Pt, " ");
            break;

        case 'p':
            _Ans = _Getloctxt(_First, _Last, 0, ":AM:am:PM:pm", _Case_sensitive::_Nope);
            if (_Ans < 0) {
                _State |= ios_base::failbit;
            } else if (1 < _Ans) {
                _Pt->tm_hour += 12;
            }

            break;

        case 'r':
            _First = _Getfmt(_First, _Last, _Iosbase, _State, _Pt, "%I : %M : %S %p");
            break;

        case 'R':
            _First = _Getfmt(_First, _Last, _Iosbase, _State, _Pt, "%H : %M");
            break;

        case 'S':
            _State |= _Getint(_First, _Last, 0, 60, _Pt->tm_sec, _Ctype_fac);
            break;

        case 'T':
        case 'X':
            _First = _Getfmt(_First, _Last, _Iosbase, _State, _Pt, "%H : %M : %S");
            break;

        case 'U':
            _State |= _Getint(_First, _Last, 0, 53, _Pt->tm_yday, _Ctype_fac);
            break;

        case 'w':
            _State |= _Getint(_First, _Last, 0, 6, _Pt->tm_wday, _Ctype_fac);
            break;

        case 'W':
            _State |= _Getint(_First, _Last, 0, 53, _Pt->tm_yday, _Ctype_fac);
            break;

        case 'x':
            _First = _Getfmt(_First, _Last, _Iosbase, _State, _Pt, "%d / %m / %y");
            break;

        case 'y':
            _State |= _Getint(_First, _Last, 0, 99, _Ans, _Ctype_fac);
            if (!(_State & ios_base::failbit)) {
                _Pt->tm_year = _Ans < 69 ? _Ans + 100 : _Ans;
            }

            break;

        case 'Y':
            _First = get_year(_First, _Last, _Iosbase, _State, _Pt);
            break;

        default:
            _State |= ios_base::failbit; 
        }

        if (_First == _Last) {
            _State |= ios_base::eofbit;
        }

        return _First;
    }

    _InIt  _Getfmt(_InIt _First, _InIt _Last, ios_base& _Iosbase, ios_base::iostate& _State, tm* _Pt,
        const char* _Fmtfirst) const { 
        const _Ctype& _Ctype_fac = ::std:: use_facet<_Ctype>(_Iosbase.getloc());

        for (; *_Fmtfirst != '\0'; ++_Fmtfirst) {
            if (*_Fmtfirst == '%') {
                _First = do_get(_First, _Last, _Iosbase, _State, _Pt,
                    *++_Fmtfirst); 
            } else if (*_Fmtfirst == ' ') {
                while (_First != _Last && _Ctype_fac.is(_Ctype::space, *_First)) {
                    ++_First;
                }
            } else if (_Ctype_fac.narrow(*_First) != *_Fmtfirst) { 
                _State |= ios_base::failbit;
                break;
            } else {
                ++_First;
            }
        }

        if (_First == _Last) {
            _State |= ios_base::eofbit;
        }

        return _First;
    }

private:
    ios_base::iostate __cdecl _Getint(_InIt& _First, _InIt& _Last, int _Lo, int _Hi, int& _Val,
        const _Ctype& _Ctype_fac) const { 
        ;
        const int _Hi_digits = (_Hi <= 9 ? 1 : _Hi <= 99 ? 2 : _Hi <= 999 ? 3 : 4);
        char _Ac[32];
        char* _Ep;
        char* _Ptr = _Ac;
        char _Ch;

        int _Digits_seen = 0;

        while (_First != _Last && _Digits_seen < _Hi_digits && _Ctype_fac.is(ctype_base::space, *_First)) {
            ++_First;
            ++_Digits_seen;
        }

        if (_First != _Last && _Digits_seen < _Hi_digits) {
            if ((_Ch = _Ctype_fac.narrow(*_First)) == '+') { 
                *_Ptr++ = '+';
                ++_First;
            } else if (_Ch == '-') { 
                *_Ptr++ = '-';
                ++_First;
            }
        }

        for (; _First != _Last && _Digits_seen < _Hi_digits && _Ctype_fac.narrow(*_First) == '0';
             ++_First) { 
            ++_Digits_seen;
        }

        if (_Digits_seen > 0) {
            *_Ptr++ = '0'; 
        }

        for (char* const _Pe = &_Ac[32 - 1];
             _First != _Last && '0' <= (_Ch = _Ctype_fac.narrow(*_First)) && _Ch <= '9' && _Digits_seen < _Hi_digits;
             ++_Digits_seen, (void) ++_First) { 
            *_Ptr = _Ch;
            if (_Ptr < _Pe) {
                ++_Ptr; 
            }
        }

        if (_Digits_seen == 0) {
            _Ptr = _Ac;
        }

        *_Ptr                    = '\0';
        int _Errno               = 0;
        const long _Ans          = :: _Stolx(_Ac, &_Ep, 10, &_Errno);
        ios_base::iostate _State = ios_base::goodbit;

        if (_First == _Last) {
            _State |= ios_base::eofbit;
        }

        if (_Ep == _Ac || _Errno != 0 || _Ans < _Lo || _Hi < _Ans) {
            _State |= ios_base::failbit; 
        } else {
            _Val = _Ans; 
        }

        return _State;
    }

    void  _Tidy() noexcept { 
        :: free(const_cast<_Elem*>(_Days));
        :: free(const_cast<_Elem*>(_Months));
        :: free(const_cast<_Elem*>(_Ampm));
    }

    const _Elem* _Days; 
    const _Elem* _Months; 
    const _Elem* _Ampm; 
    dateorder _Dateorder;
    _Locinfo::_Cvtvec _Cvt; 
};


template <class _Elem, class _InIt>
 locale::id time_get<_Elem, _InIt>::id;


template <class _Elem, class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem>>>
class time_get_byname : public time_get<_Elem, _InIt> { 
public:
    static_assert(!0 || _Is_any_of_v<_Elem, char, wchar_t>, "Unsupported facet specialization; see N4800 27.3.1.1.1 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this diagnostic.");

    explicit time_get_byname(const char* _Locname, size_t _Refs = 0)
        : time_get<_Elem, _InIt>(_Locname, _Refs) {} 

    explicit time_get_byname(const string& _Str, size_t _Refs = 0)
        : time_get<_Elem, _InIt>(_Locinfo(_Str.c_str()), _Refs) {} 

protected:
     ~time_get_byname() noexcept override {}
};

template <class _Elem, class _OutIt = ostreambuf_iterator<_Elem, char_traits<_Elem>>>
class time_put : public locale::facet { 
public:
    static_assert(!0 || _Is_any_of_v<_Elem, char, wchar_t, unsigned short>,
        "Unsupported facet specialization; see N4800 27.3.1.1.1 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this diagnostic.");

    using char_type = _Elem;
    using iter_type = _OutIt;
    using _Ctype    = ctype<_Elem>;

    _OutIt  put(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, const tm* _Pt, const _Elem* _Fmtfirst,
        const _Elem* _Fmtlast) const { 
        const _Ctype& _Ctype_fac = ::std:: use_facet<_Ctype>(_Iosbase.getloc());

        for (; _Fmtfirst != _Fmtlast; ++_Fmtfirst) {
            if (_Ctype_fac.narrow(*_Fmtfirst) != '%') {
                *_Dest++ = *_Fmtfirst; 
            } else if (++_Fmtfirst == _Fmtlast) { 
                *_Dest++ = _Fmtfirst[-1];
                break;
            } else { 
                char _Specifier = _Ctype_fac.narrow(*_Fmtfirst);
                char _Modifier  = '\0';
                _Elem _Percent  = _Fmtfirst[-1];

                if (_Specifier == 'E' || _Specifier == 'O' || _Specifier == 'Q' || _Specifier == '#') {
                    if (++_Fmtfirst == _Fmtlast) { 
                        *_Dest++ = _Percent;
                        *_Dest++ = _Specifier;
                        break;
                    }

                    
                    _Modifier  = _Specifier;
                    _Specifier = _Ctype_fac.narrow(*_Fmtfirst);
                }

                _Dest = do_put(_Dest, _Iosbase, _Fill, _Pt, _Specifier, _Modifier); 
            }
        }

        return _Dest;
    }

    _OutIt  put(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, const tm* _Pt, char _Specifier,
        char _Modifier = '\0') const { 
        return do_put(_Dest, _Iosbase, _Fill, _Pt, _Specifier, _Modifier);
    }

     static locale::id id; 

    explicit  time_put(size_t _Refs = 0) : locale::facet(_Refs) { 
        { _Locinfo _Lobj;
        _Init(_Lobj);
        }
    }

     time_put(const _Locinfo& _Lobj, size_t _Refs = 0) : locale::facet(_Refs) {
        _Init(_Lobj);
    }

    static size_t __cdecl _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
        
        if (_Ppf && !*_Ppf) {
            *_Ppf = new time_put<_Elem, _OutIt>(_Locinfo(_Ploc->c_str()));
        }

        return 5;
    }

protected:
     ~time_put() noexcept override {}

    void  _Init(const _Locinfo& _Lobj) { 
        _Tnames = _Lobj._Gettnames();
    }

    virtual _OutIt  do_put(_OutIt _Dest, ios_base& _Iosbase, _Elem, const tm* _Pt, char _Specifier,
        char _Modifier = '\0') const { 
        char _Fmt[5] = "!%x\0"; 
        size_t _Count;
        size_t _Num;
        string _Str;

        if (_Modifier == '\0') {
            _Fmt[2] = _Specifier;
        } else { 
            _Fmt[2] = _Modifier;
            _Fmt[3] = _Specifier;
        }

        const int& _Errno_ref = (*_errno()); 

        for (_Num = 16;; _Num *= 2) { 
            _Str.append(_Num, '\0');
            _Count = _Strftime(&_Str[0], _Str.size(), _Fmt, _Pt, _Tnames._Getptr());
            if (0 < _Count) {
                break;
            } else if (_Errno_ref == 22) {
                _Iosbase.setstate(ios_base::badbit);
                return _Dest;
            }
        }

        return ::std:: copy(&_Str[1], &_Str[_Count], _Dest);
    }

private:
    _Locinfo::_Timevec _Tnames; 
};


template <class _Elem, class _OutIt>
 locale::id time_put<_Elem, _OutIt>::id;


template <class _OutIt>
class  time_put<wchar_t, _OutIt>
    : public locale::facet { 
public:
    using _Elem     = wchar_t;
    using char_type = _Elem;
    using iter_type = _OutIt;
    using _Ctype    = ctype<_Elem>;

    _OutIt  put(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, const tm* _Pt, const _Elem* _Fmtfirst,
        const _Elem* _Fmtlast) const { 
        const _Ctype& _Ctype_fac = ::std:: use_facet<_Ctype>(_Iosbase.getloc());

        for (; _Fmtfirst != _Fmtlast; ++_Fmtfirst) {
            if (_Ctype_fac.narrow(*_Fmtfirst) != '%') {
                *_Dest++ = *_Fmtfirst; 
            } else if (++_Fmtfirst == _Fmtlast) { 
                *_Dest++ = _Fmtfirst[-1];
                break;
            } else { 
                _Elem _Raw      = *_Fmtfirst;
                char _Specifier = _Ctype_fac.narrow(_Raw);
                char _Modifier  = '\0';
                _Elem _Percent  = _Fmtfirst[-1];

                if (_Specifier == 'E' || _Specifier == 'O' || _Specifier == 'Q' || _Specifier == '#') {
                    if (++_Fmtfirst == _Fmtlast) { 
                        *_Dest++ = _Percent;
                        *_Dest++ = _Raw;
                        break;
                    }

                    
                    _Modifier  = _Specifier;
                    _Specifier = _Ctype_fac.narrow(*_Fmtfirst);
                }

                _Dest = do_put(_Dest, _Iosbase, _Fill, _Pt, _Specifier, _Modifier); 
            }
        }

        return _Dest;
    }

    _OutIt  put(_OutIt _Dest, ios_base& _Iosbase, _Elem _Fill, const tm* _Pt, char _Specifier,
        char _Modifier = '\0') const { 
        return do_put(_Dest, _Iosbase, _Fill, _Pt, _Specifier, _Modifier);
    }

     static locale::id id; 

    explicit  time_put(size_t _Refs = 0) : locale::facet(_Refs) { 
        { _Locinfo _Lobj;
        _Init(_Lobj);
        }
    }

     time_put(const _Locinfo& _Lobj, size_t _Refs = 0) : locale::facet(_Refs) {
        _Init(_Lobj);
    }

    static size_t __cdecl _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
        
        if (_Ppf && !*_Ppf) {
            *_Ppf = new time_put<_Elem, _OutIt>(_Locinfo(_Ploc->c_str()));
        }

        return 5;
    }

protected:
     ~time_put() noexcept override {}

     time_put(const char* _Locname, size_t _Refs = 0) : locale::facet(_Refs) {
        { _Locinfo _Lobj(_Locname);
        _Init(_Lobj);
        }
    }

    void  _Init(const _Locinfo& _Lobj) { 
        _Tnames = _Lobj._W_Gettnames();
    }

    virtual _OutIt  do_put(_OutIt _Dest, ios_base& _Iosbase, _Elem, const tm* _Pt, char _Specifier,
        char _Modifier = '\0') const { 
        wchar_t _Fmt[5] = L"!%x\0"; 
        size_t _Count;
        size_t _Num;
        wstring _Str;

        if (_Modifier == '\0') {
            _Fmt[2] = static_cast<_Elem>(_Specifier); 
        } else { 
            _Fmt[2] = static_cast<_Elem>(_Modifier);
            _Fmt[3] = static_cast<_Elem>(_Specifier);
        }

        const int& _Errno_ref = (*_errno()); 

        for (_Num = 16;; _Num *= 2) { 
            _Str.append(_Num, '\0');
            _Count = _Wcsftime(&_Str[0], _Str.size(), _Fmt, _Pt, _Tnames._Getptr());
            if (0 < _Count) {
                break;
            } else if (_Errno_ref == 22) {
                _Iosbase.setstate(ios_base::badbit);
                return _Dest;
            }
        }
        return ::std:: copy(&_Str[1], &_Str[_Count], _Dest);
    }

private:
    _Locinfo::_Timevec _Tnames; 
};


template <class _OutIt>
 locale::id time_put<wchar_t, _OutIt>::id;


#line 1017 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xloctime"

template <class _Elem, class _OutIt = ostreambuf_iterator<_Elem, char_traits<_Elem>>>
class time_put_byname : public time_put<_Elem, _OutIt> { 
public:
    static_assert(!0 || _Is_any_of_v<_Elem, char, wchar_t>, "Unsupported facet specialization; see N4800 27.3.1.1.1 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this diagnostic.");

    explicit time_put_byname(const char* _Locname, size_t _Refs = 0)
        : time_put<_Elem, _OutIt>(_Locname, _Refs) {} 

    explicit time_put_byname(const string& _Str, size_t _Refs = 0)
        : time_put<_Elem, _OutIt>(_Str.c_str(), _Refs) {} 

protected:
     ~time_put_byname() noexcept override {}
};


#line 1057 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xloctime"
}


#pragma warning(pop)
#pragma pack(pop)
#line 1064 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xloctime"
#line 1065 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xloctime"
#line 32 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"


#line 37 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\format"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\charconv"


#pragma once


#line 15 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\charconv"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xbit_ops.h"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {

[[nodiscard]] inline unsigned long _Floor_of_log_2(size_t _Value) noexcept { 
    _Value |= size_t{1}; 
    unsigned long _Result;


    _BitScanReverse(&_Result, _Value);
#line 45 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xbit_ops.h"
#line 46 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xbit_ops.h"

    return _Result;
}

[[nodiscard]] inline unsigned long _Ceiling_of_log_2(const size_t _Value) noexcept { 
                                                                                  
    return 1 + _Floor_of_log_2(_Value - 1);
}

[[nodiscard]] inline uint32_t _Bit_scan_reverse(const uint32_t _Value) noexcept {
    unsigned long _Index; 

    if (_BitScanReverse(&_Index, _Value)) {
        return _Index + 1;
    }

    return 0;
}

[[nodiscard]] inline uint32_t _Bit_scan_reverse(const uint64_t _Value) noexcept {
    unsigned long _Index; 


    uint32_t _Ui32 = static_cast<uint32_t>(_Value >> 32);

    if (_BitScanReverse(&_Index, _Ui32)) {
        return _Index + 1 + 32;
    }

    _Ui32 = static_cast<uint32_t>(_Value);

    if (_BitScanReverse(&_Index, _Ui32)) {
        return _Index + 1;
    }
#line 85 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xbit_ops.h"

    return 0;
}

}


#pragma warning(pop)
#pragma pack(pop)
#line 96 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xbit_ops.h"
#line 97 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xbit_ops.h"
#line 18 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\charconv"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv.h"


#pragma once


#line 19 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv.h"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
enum class chars_format {
    scientific = 0b001,
    fixed      = 0b010,
    hex        = 0b100,
    general    = fixed | scientific,
};

[[nodiscard]] constexpr chars_format operator&(chars_format _Left, chars_format _Right) noexcept { using _IntTy = ::std:: underlying_type_t<chars_format>; return static_cast<chars_format>(static_cast<_IntTy>(_Left) & static_cast<_IntTy>(_Right)); } [[nodiscard]] constexpr chars_format operator|(chars_format _Left, chars_format _Right) noexcept { using _IntTy = ::std:: underlying_type_t<chars_format>; return static_cast<chars_format>(static_cast<_IntTy>(_Left) | static_cast<_IntTy>(_Right)); } [[nodiscard]] constexpr chars_format operator^(chars_format _Left, chars_format _Right) noexcept { using _IntTy = ::std:: underlying_type_t<chars_format>; return static_cast<chars_format>(static_cast<_IntTy>(_Left) ^ static_cast<_IntTy>(_Right)); } constexpr chars_format& operator&=(chars_format& _Left, chars_format _Right) noexcept { return _Left = _Left & _Right; } constexpr chars_format& operator|=(chars_format& _Left, chars_format _Right) noexcept { return _Left = _Left | _Right; } constexpr chars_format& operator^=(chars_format& _Left, chars_format _Right) noexcept { return _Left = _Left ^ _Right; } [[nodiscard]] constexpr chars_format operator~(chars_format _Left) noexcept { using _IntTy = ::std:: underlying_type_t<chars_format>; return static_cast<chars_format>(~static_cast<_IntTy>(_Left)); } [[nodiscard]] constexpr bool _Bitmask_includes( chars_format _Left, chars_format _Elements) noexcept { return (_Left & _Elements) != chars_format{}; } [[nodiscard]] constexpr bool _Bitmask_includes_all( chars_format _Left, chars_format _Elements) noexcept { return (_Left & _Elements) == _Elements; }

struct to_chars_result {
    char* ptr;
    errc ec;

    [[nodiscard]] friend bool operator==(const to_chars_result&, const to_chars_result&) = default;
#line 43 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv.h"
};

}


#pragma warning(pop)
#pragma pack(pop)

#line 53 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv.h"
#line 54 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv.h"
#line 19 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\charconv"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu.h"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu_tables.h"


#pragma once


#line 46 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu_tables.h"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {


template <class _CharT> inline constexpr _CharT __DIGIT_TABLE[] = {_CharT{}};

template <> inline constexpr char __DIGIT_TABLE<char>[200] = {
  '0','0','0','1','0','2','0','3','0','4','0','5','0','6','0','7','0','8','0','9',
  '1','0','1','1','1','2','1','3','1','4','1','5','1','6','1','7','1','8','1','9',
  '2','0','2','1','2','2','2','3','2','4','2','5','2','6','2','7','2','8','2','9',
  '3','0','3','1','3','2','3','3','3','4','3','5','3','6','3','7','3','8','3','9',
  '4','0','4','1','4','2','4','3','4','4','4','5','4','6','4','7','4','8','4','9',
  '5','0','5','1','5','2','5','3','5','4','5','5','5','6','5','7','5','8','5','9',
  '6','0','6','1','6','2','6','3','6','4','6','5','6','6','6','7','6','8','6','9',
  '7','0','7','1','7','2','7','3','7','4','7','5','7','6','7','7','7','8','7','9',
  '8','0','8','1','8','2','8','3','8','4','8','5','8','6','8','7','8','8','8','9',
  '9','0','9','1','9','2','9','3','9','4','9','5','9','6','9','7','9','8','9','9'
};

template <> inline constexpr wchar_t __DIGIT_TABLE<wchar_t>[200] = {
  L'0',L'0',L'0',L'1',L'0',L'2',L'0',L'3',L'0',L'4',L'0',L'5',L'0',L'6',L'0',L'7',L'0',L'8',L'0',L'9',
  L'1',L'0',L'1',L'1',L'1',L'2',L'1',L'3',L'1',L'4',L'1',L'5',L'1',L'6',L'1',L'7',L'1',L'8',L'1',L'9',
  L'2',L'0',L'2',L'1',L'2',L'2',L'2',L'3',L'2',L'4',L'2',L'5',L'2',L'6',L'2',L'7',L'2',L'8',L'2',L'9',
  L'3',L'0',L'3',L'1',L'3',L'2',L'3',L'3',L'3',L'4',L'3',L'5',L'3',L'6',L'3',L'7',L'3',L'8',L'3',L'9',
  L'4',L'0',L'4',L'1',L'4',L'2',L'4',L'3',L'4',L'4',L'4',L'5',L'4',L'6',L'4',L'7',L'4',L'8',L'4',L'9',
  L'5',L'0',L'5',L'1',L'5',L'2',L'5',L'3',L'5',L'4',L'5',L'5',L'5',L'6',L'5',L'7',L'5',L'8',L'5',L'9',
  L'6',L'0',L'6',L'1',L'6',L'2',L'6',L'3',L'6',L'4',L'6',L'5',L'6',L'6',L'6',L'7',L'6',L'8',L'6',L'9',
  L'7',L'0',L'7',L'1',L'7',L'2',L'7',L'3',L'7',L'4',L'7',L'5',L'7',L'6',L'7',L'7',L'7',L'8',L'7',L'9',
  L'8',L'0',L'8',L'1',L'8',L'2',L'8',L'3',L'8',L'4',L'8',L'5',L'8',L'6',L'8',L'7',L'8',L'8',L'8',L'9',
  L'9',L'0',L'9',L'1',L'9',L'2',L'9',L'3',L'9',L'4',L'9',L'5',L'9',L'6',L'9',L'7',L'9',L'8',L'9',L'9'
};


inline constexpr uint64_t __DOUBLE_POW5_INV_SPLIT[292][2] = {
  {                    1u, 288230376151711744u }, {  3689348814741910324u, 230584300921369395u },
  {  2951479051793528259u, 184467440737095516u }, { 17118578500402463900u, 147573952589676412u },
  { 12632330341676300947u, 236118324143482260u }, { 10105864273341040758u, 188894659314785808u },
  { 15463389048156653253u, 151115727451828646u }, { 17362724847566824558u, 241785163922925834u },
  { 17579528692795369969u, 193428131138340667u }, {  6684925324752475329u, 154742504910672534u },
  { 18074578149087781173u, 247588007857076054u }, { 18149011334012135262u, 198070406285660843u },
  {  3451162622983977240u, 158456325028528675u }, {  5521860196774363583u, 253530120045645880u },
  {  4417488157419490867u, 202824096036516704u }, {  7223339340677503017u, 162259276829213363u },
  {  7867994130342094503u, 259614842926741381u }, {  2605046489531765280u, 207691874341393105u },
  {  2084037191625412224u, 166153499473114484u }, { 10713157136084480204u, 265845599156983174u },
  { 12259874523609494487u, 212676479325586539u }, { 13497248433629505913u, 170141183460469231u },
  { 14216899864323388813u, 272225893536750770u }, { 11373519891458711051u, 217780714829400616u },
  {  5409467098425058518u, 174224571863520493u }, {  4965798542738183305u, 278759314981632789u },
  {  7661987648932456967u, 223007451985306231u }, {  2440241304404055250u, 178405961588244985u },
  {  3904386087046488400u, 285449538541191976u }, { 17880904128604832013u, 228359630832953580u },
  { 14304723302883865611u, 182687704666362864u }, { 15133127457049002812u, 146150163733090291u },
  { 16834306301794583852u, 233840261972944466u }, {  9778096226693756759u, 187072209578355573u },
  { 15201174610838826053u, 149657767662684458u }, {  2185786488890659746u, 239452428260295134u },
  {  5437978005854438120u, 191561942608236107u }, { 15418428848909281466u, 153249554086588885u },
  {  6222742084545298729u, 245199286538542217u }, { 16046240111861969953u, 196159429230833773u },
  {  1768945645263844993u, 156927543384667019u }, { 10209010661905972635u, 251084069415467230u },
  {  8167208529524778108u, 200867255532373784u }, { 10223115638361732810u, 160693804425899027u },
  {  1599589762411131202u, 257110087081438444u }, {  4969020624670815285u, 205688069665150755u },
  {  3975216499736652228u, 164550455732120604u }, { 13739044029062464211u, 263280729171392966u },
  {  7301886408508061046u, 210624583337114373u }, { 13220206756290269483u, 168499666669691498u },
  { 17462981995322520850u, 269599466671506397u }, {  6591687966774196033u, 215679573337205118u },
  { 12652048002903177473u, 172543658669764094u }, {  9175230360419352987u, 276069853871622551u },
  {  3650835473593572067u, 220855883097298041u }, { 17678063637842498946u, 176684706477838432u },
  { 13527506561580357021u, 282695530364541492u }, {  3443307619780464970u, 226156424291633194u },
  {  6443994910566282300u, 180925139433306555u }, {  5155195928453025840u, 144740111546645244u },
  { 15627011115008661990u, 231584178474632390u }, { 12501608892006929592u, 185267342779705912u },
  {  2622589484121723027u, 148213874223764730u }, {  4196143174594756843u, 237142198758023568u },
  { 10735612169159626121u, 189713759006418854u }, { 12277838550069611220u, 151771007205135083u },
  { 15955192865369467629u, 242833611528216133u }, {  1696107848069843133u, 194266889222572907u },
  { 12424932722681605476u, 155413511378058325u }, {  1433148282581017146u, 248661618204893321u },
  { 15903913885032455010u, 198929294563914656u }, {  9033782293284053685u, 159143435651131725u },
  { 14454051669254485895u, 254629497041810760u }, { 11563241335403588716u, 203703597633448608u },
  { 16629290697806691620u, 162962878106758886u }, {   781423413297334329u, 260740604970814219u },
  {  4314487545379777786u, 208592483976651375u }, {  3451590036303822229u, 166873987181321100u },
  {  5522544058086115566u, 266998379490113760u }, {  4418035246468892453u, 213598703592091008u },
  { 10913125826658934609u, 170878962873672806u }, { 10082303693170474728u, 273406340597876490u },
  {  8065842954536379782u, 218725072478301192u }, { 17520720807854834795u, 174980057982640953u },
  {  5897060404116273733u, 279968092772225526u }, {  1028299508551108663u, 223974474217780421u },
  { 15580034865808528224u, 179179579374224336u }, { 17549358155809824511u, 286687326998758938u },
  {  2971440080422128639u, 229349861599007151u }, { 17134547323305344204u, 183479889279205720u },
  { 13707637858644275364u, 146783911423364576u }, { 14553522944347019935u, 234854258277383322u },
  {  4264120725993795302u, 187883406621906658u }, { 10789994210278856888u, 150306725297525326u },
  {  9885293106962350374u, 240490760476040522u }, {   529536856086059653u, 192392608380832418u },
  {  7802327114352668369u, 153914086704665934u }, {  1415676938738538420u, 246262538727465495u },
  {  1132541550990830736u, 197010030981972396u }, { 15663428499760305882u, 157608024785577916u },
  { 17682787970132668764u, 252172839656924666u }, { 10456881561364224688u, 201738271725539733u },
  { 15744202878575200397u, 161390617380431786u }, { 17812026976236499989u, 258224987808690858u },
  {  3181575136763469022u, 206579990246952687u }, { 13613306553636506187u, 165263992197562149u },
  { 10713244041592678929u, 264422387516099439u }, { 12259944048016053467u, 211537910012879551u },
  {  6118606423670932450u, 169230328010303641u }, {  2411072648389671274u, 270768524816485826u },
  { 16686253377679378312u, 216614819853188660u }, { 13349002702143502650u, 173291855882550928u },
  { 17669055508687693916u, 277266969412081485u }, { 14135244406950155133u, 221813575529665188u },
  {   240149081334393137u, 177450860423732151u }, { 11452284974360759988u, 283921376677971441u },
  {  5472479164746697667u, 227137101342377153u }, { 11756680961281178780u, 181709681073901722u },
  {  2026647139541122378u, 145367744859121378u }, { 18000030682233437097u, 232588391774594204u },
  { 18089373360528660001u, 186070713419675363u }, {  3403452244197197031u, 148856570735740291u },
  { 16513570034941246220u, 238170513177184465u }, { 13210856027952996976u, 190536410541747572u },
  {  3189987192878576934u, 152429128433398058u }, {  1414630693863812771u, 243886605493436893u },
  {  8510402184574870864u, 195109284394749514u }, { 10497670562401807014u, 156087427515799611u },
  {  9417575270359070576u, 249739884025279378u }, { 14912757845771077107u, 199791907220223502u },
  {  4551508647133041040u, 159833525776178802u }, { 10971762650154775986u, 255733641241886083u },
  { 16156107749607641435u, 204586912993508866u }, {  9235537384944202825u, 163669530394807093u },
  { 11087511001168814197u, 261871248631691349u }, { 12559357615676961681u, 209496998905353079u },
  { 13736834907283479668u, 167597599124282463u }, { 18289587036911657145u, 268156158598851941u },
  { 10942320814787415393u, 214524926879081553u }, { 16132554281313752961u, 171619941503265242u },
  { 11054691591134363444u, 274591906405224388u }, { 16222450902391311402u, 219673525124179510u },
  { 12977960721913049122u, 175738820099343608u }, { 17075388340318968271u, 281182112158949773u },
  {  2592264228029443648u, 224945689727159819u }, {  5763160197165465241u, 179956551781727855u },
  {  9221056315464744386u, 287930482850764568u }, { 14755542681855616155u, 230344386280611654u },
  { 15493782960226403247u, 184275509024489323u }, {  1326979923955391628u, 147420407219591459u },
  {  9501865507812447252u, 235872651551346334u }, { 11290841220991868125u, 188698121241077067u },
  {  1653975347309673853u, 150958496992861654u }, { 10025058185179298811u, 241533595188578646u },
  {  4330697733401528726u, 193226876150862917u }, { 14532604630946953951u, 154581500920690333u },
  {  1116074521063664381u, 247330401473104534u }, {  4582208431592841828u, 197864321178483627u },
  { 14733813189500004432u, 158291456942786901u }, { 16195403473716186445u, 253266331108459042u },
  {  5577625149489128510u, 202613064886767234u }, {  8151448934333213131u, 162090451909413787u },
  { 16731667109675051333u, 259344723055062059u }, { 17074682502481951390u, 207475778444049647u },
  {  6281048372501740465u, 165980622755239718u }, {  6360328581260874421u, 265568996408383549u },
  {  8777611679750609860u, 212455197126706839u }, { 10711438158542398211u, 169964157701365471u },
  {  9759603424184016492u, 271942652322184754u }, { 11497031554089123517u, 217554121857747803u },
  { 16576322872755119460u, 174043297486198242u }, { 11764721337440549842u, 278469275977917188u },
  { 16790474699436260520u, 222775420782333750u }, { 13432379759549008416u, 178220336625867000u },
  {  3045063541568861850u, 285152538601387201u }, { 17193446092222730773u, 228122030881109760u },
  { 13754756873778184618u, 182497624704887808u }, { 18382503128506368341u, 145998099763910246u },
  {  3586563302416817083u, 233596959622256395u }, {  2869250641933453667u, 186877567697805116u },
  { 17052795772514404226u, 149502054158244092u }, { 12527077977055405469u, 239203286653190548u },
  { 17400360011128145022u, 191362629322552438u }, {  2852241564676785048u, 153090103458041951u },
  { 15631632947708587046u, 244944165532867121u }, {  8815957543424959314u, 195955332426293697u },
  { 18120812478965698421u, 156764265941034957u }, { 14235904707377476180u, 250822825505655932u },
  {  4010026136418160298u, 200658260404524746u }, { 17965416168102169531u, 160526608323619796u },
  {  2919224165770098987u, 256842573317791675u }, {  2335379332616079190u, 205474058654233340u },
  {  1868303466092863352u, 164379246923386672u }, {  6678634360490491686u, 263006795077418675u },
  {  5342907488392393349u, 210405436061934940u }, {  4274325990713914679u, 168324348849547952u },
  { 10528270399884173809u, 269318958159276723u }, { 15801313949391159694u, 215455166527421378u },
  {  1573004715287196786u, 172364133221937103u }, { 17274202803427156150u, 275782613155099364u },
  { 17508711057483635243u, 220626090524079491u }, { 10317620031244997871u, 176500872419263593u },
  { 12818843235250086271u, 282401395870821749u }, { 13944423402941979340u, 225921116696657399u },
  { 14844887537095493795u, 180736893357325919u }, { 15565258844418305359u, 144589514685860735u },
  {  6457670077359736959u, 231343223497377177u }, { 16234182506113520537u, 185074578797901741u },
  {  9297997190148906106u, 148059663038321393u }, { 11187446689496339446u, 236895460861314229u },
  { 12639306166338981880u, 189516368689051383u }, { 17490142562555006151u, 151613094951241106u },
  {  2158786396894637579u, 242580951921985771u }, { 16484424376483351356u, 194064761537588616u },
  {  9498190686444770762u, 155251809230070893u }, { 11507756283569722895u, 248402894768113429u },
  { 12895553841597688639u, 198722315814490743u }, { 17695140702761971558u, 158977852651592594u },
  { 17244178680193423523u, 254364564242548151u }, { 10105994129412828495u, 203491651394038521u },
  {  4395446488788352473u, 162793321115230817u }, { 10722063196803274280u, 260469313784369307u },
  {  1198952927958798777u, 208375451027495446u }, { 15716557601334680315u, 166700360821996356u },
  { 17767794532651667857u, 266720577315194170u }, { 14214235626121334286u, 213376461852155336u },
  {  7682039686155157106u, 170701169481724269u }, {  1223217053622520399u, 273121871170758831u },
  { 15735968901865657612u, 218497496936607064u }, { 16278123936234436413u, 174797997549285651u },
  {   219556594781725998u, 279676796078857043u }, {  7554342905309201445u, 223741436863085634u },
  {  9732823138989271479u, 178993149490468507u }, {   815121763415193074u, 286389039184749612u },
  { 11720143854957885429u, 229111231347799689u }, { 13065463898708218666u, 183288985078239751u },
  {  6763022304224664610u, 146631188062591801u }, {  3442138057275642729u, 234609900900146882u },
  { 13821756890046245153u, 187687920720117505u }, { 11057405512036996122u, 150150336576094004u },
  {  6623802375033462826u, 240240538521750407u }, { 16367088344252501231u, 192192430817400325u },
  { 13093670675402000985u, 153753944653920260u }, {  2503129006933649959u, 246006311446272417u },
  { 13070549649772650937u, 196805049157017933u }, { 17835137349301941396u, 157444039325614346u },
  {  2710778055689733971u, 251910462920982955u }, {  2168622444551787177u, 201528370336786364u },
  {  5424246770383340065u, 161222696269429091u }, {  1300097203129523457u, 257956314031086546u },
  { 15797473021471260058u, 206365051224869236u }, {  8948629602435097724u, 165092040979895389u },
  {  3249760919670425388u, 264147265567832623u }, {  9978506365220160957u, 211317812454266098u },
  { 15361502721659949412u, 169054249963412878u }, {  2442311466204457120u, 270486799941460606u },
  { 16711244431931206989u, 216389439953168484u }, { 17058344360286875914u, 173111551962534787u },
  { 12535955717491360170u, 276978483140055660u }, { 10028764573993088136u, 221582786512044528u },
  { 15401709288678291155u, 177266229209635622u }, {  9885339602917624555u, 283625966735416996u },
  {  4218922867592189321u, 226900773388333597u }, { 14443184738299482427u, 181520618710666877u },
  {  4175850161155765295u, 145216494968533502u }, { 10370709072591134795u, 232346391949653603u },
  { 15675264887556728482u, 185877113559722882u }, {  5161514280561562140u, 148701690847778306u },
  {   879725219414678777u, 237922705356445290u }, {   703780175531743021u, 190338164285156232u },
  { 11631070584651125387u, 152270531428124985u }, {   162968861732249003u, 243632850284999977u },
  { 11198421533611530172u, 194906280227999981u }, {  5269388412147313814u, 155925024182399985u },
  {  8431021459435702103u, 249480038691839976u }, {  3055468352806651359u, 199584030953471981u },
  { 17201769941212962380u, 159667224762777584u }, { 16454785461715008838u, 255467559620444135u },
  { 13163828369372007071u, 204374047696355308u }, { 17909760324981426303u, 163499238157084246u },
  {  2830174816776909822u, 261598781051334795u }, {  2264139853421527858u, 209279024841067836u },
  { 16568707141704863579u, 167423219872854268u }, {  4373838538276319787u, 267877151796566830u },
  {  3499070830621055830u, 214301721437253464u }, {  6488605479238754987u, 171441377149802771u },
  {  3003071137298187333u, 274306203439684434u }, {  6091805724580460189u, 219444962751747547u },
  { 15941491023890099121u, 175555970201398037u }, { 10748990379256517301u, 280889552322236860u },
  {  8599192303405213841u, 224711641857789488u }, { 14258051472207991719u, 179769313486231590u }
};

inline constexpr uint64_t __DOUBLE_POW5_SPLIT[326][2] = {
  {                    0u,  72057594037927936u }, {                    0u,  90071992547409920u },
  {                    0u, 112589990684262400u }, {                    0u, 140737488355328000u },
  {                    0u,  87960930222080000u }, {                    0u, 109951162777600000u },
  {                    0u, 137438953472000000u }, {                    0u,  85899345920000000u },
  {                    0u, 107374182400000000u }, {                    0u, 134217728000000000u },
  {                    0u,  83886080000000000u }, {                    0u, 104857600000000000u },
  {                    0u, 131072000000000000u }, {                    0u,  81920000000000000u },
  {                    0u, 102400000000000000u }, {                    0u, 128000000000000000u },
  {                    0u,  80000000000000000u }, {                    0u, 100000000000000000u },
  {                    0u, 125000000000000000u }, {                    0u,  78125000000000000u },
  {                    0u,  97656250000000000u }, {                    0u, 122070312500000000u },
  {                    0u,  76293945312500000u }, {                    0u,  95367431640625000u },
  {                    0u, 119209289550781250u }, {  4611686018427387904u,  74505805969238281u },
  { 10376293541461622784u,  93132257461547851u }, {  8358680908399640576u, 116415321826934814u },
  {   612489549322387456u,  72759576141834259u }, { 14600669991935148032u,  90949470177292823u },
  { 13639151471491547136u, 113686837721616029u }, {  3213881284082270208u, 142108547152020037u },
  {  4314518811765112832u,  88817841970012523u }, {   781462496279003136u, 111022302462515654u },
  { 10200200157203529728u, 138777878078144567u }, { 13292654125893287936u,  86736173798840354u },
  {  7392445620511834112u, 108420217248550443u }, {  4628871007212404736u, 135525271560688054u },
  { 16728102434789916672u,  84703294725430033u }, {  7075069988205232128u, 105879118406787542u },
  { 18067209522111315968u, 132348898008484427u }, {  8986162942105878528u,  82718061255302767u },
  {  6621017659204960256u, 103397576569128459u }, {  3664586055578812416u, 129246970711410574u },
  { 16125424340018921472u,  80779356694631608u }, {  1710036351314100224u, 100974195868289511u },
  { 15972603494424788992u, 126217744835361888u }, {  9982877184015493120u,  78886090522101180u },
  { 12478596480019366400u,  98607613152626475u }, { 10986559581596820096u, 123259516440783094u },
  {  2254913720070624656u,  77037197775489434u }, { 12042014186943056628u,  96296497219361792u },
  { 15052517733678820785u, 120370621524202240u }, {  9407823583549262990u,  75231638452626400u },
  { 11759779479436578738u,  94039548065783000u }, { 14699724349295723422u, 117549435082228750u },
  {  4575641699882439235u,  73468396926392969u }, { 10331238143280436948u,  91835496157991211u },
  {  8302361660673158281u, 114794370197489014u }, {  1154580038986672043u, 143492962746861268u },
  {  9944984561221445835u,  89683101716788292u }, { 12431230701526807293u, 112103877145985365u },
  {  1703980321626345405u, 140129846432481707u }, { 17205888765512323542u,  87581154020301066u },
  { 12283988920035628619u, 109476442525376333u }, {  1519928094762372062u, 136845553156720417u },
  { 12479170105294952299u,  85528470722950260u }, { 15598962631618690374u, 106910588403687825u },
  {  5663645234241199255u, 133638235504609782u }, { 17374836326682913246u,  83523897190381113u },
  {  7883487353071477846u, 104404871487976392u }, {  9854359191339347308u, 130506089359970490u },
  { 10770660513014479971u,  81566305849981556u }, { 13463325641268099964u, 101957882312476945u },
  {  2994098996302961243u, 127447352890596182u }, { 15706369927971514489u,  79654595556622613u },
  {  5797904354682229399u,  99568244445778267u }, {  2635694424925398845u, 124460305557222834u },
  {  6258995034005762182u,  77787690973264271u }, {  3212057774079814824u,  97234613716580339u },
  { 17850130272881932242u, 121543267145725423u }, { 18073860448192289507u,  75964541966078389u },
  {  8757267504958198172u,  94955677457597987u }, {  6334898362770359811u, 118694596821997484u },
  { 13182683513586250689u,  74184123013748427u }, { 11866668373555425458u,  92730153767185534u },
  {  5609963430089506015u, 115912692208981918u }, { 17341285199088104971u,  72445432630613698u },
  { 12453234462005355406u,  90556790788267123u }, { 10954857059079306353u, 113195988485333904u },
  { 13693571323849132942u, 141494985606667380u }, { 17781854114260483896u,  88434366004167112u },
  {  3780573569116053255u, 110542957505208891u }, {   114030942967678664u, 138178696881511114u },
  {  4682955357782187069u,  86361685550944446u }, { 15077066234082509644u, 107952106938680557u },
  {  5011274737320973344u, 134940133673350697u }, { 14661261756894078100u,  84337583545844185u },
  {  4491519140835433913u, 105421979432305232u }, {  5614398926044292391u, 131777474290381540u },
  { 12732371365632458552u,  82360921431488462u }, {  6692092170185797382u, 102951151789360578u },
  { 17588487249587022536u, 128688939736700722u }, { 15604490549419276989u,  80430587335437951u },
  { 14893927168346708332u, 100538234169297439u }, { 14005722942005997511u, 125672792711621799u },
  { 15671105866394830300u,  78545495444763624u }, {  1142138259283986260u,  98181869305954531u },
  { 15262730879387146537u, 122727336632443163u }, {  7233363790403272633u,  76704585395276977u },
  { 13653390756431478696u,  95880731744096221u }, {  3231680390257184658u, 119850914680120277u },
  {  4325643253124434363u,  74906821675075173u }, { 10018740084832930858u,  93633527093843966u },
  {  3300053069186387764u, 117041908867304958u }, { 15897591223523656064u,  73151193042065598u },
  { 10648616992549794273u,  91438991302581998u }, {  4087399203832467033u, 114298739128227498u },
  { 14332621041645359599u, 142873423910284372u }, { 18181260187883125557u,  89295889943927732u },
  {  4279831161144355331u, 111619862429909666u }, { 14573160988285219972u, 139524828037387082u },
  { 13719911636105650386u,  87203017523366926u }, {  7926517508277287175u, 109003771904208658u },
  {   684774848491833161u, 136254714880260823u }, {  7345513307948477581u,  85159196800163014u },
  { 18405263671790372785u, 106448996000203767u }, { 18394893571310578077u, 133061245000254709u },
  { 13802651491282805250u,  83163278125159193u }, {  3418256308821342851u, 103954097656448992u },
  {  4272820386026678563u, 129942622070561240u }, {  2670512741266674102u,  81214138794100775u },
  { 17173198981865506339u, 101517673492625968u }, {  3019754653622331308u, 126897091865782461u },
  {  4193189667727651020u,  79310682416114038u }, { 14464859121514339583u,  99138353020142547u },
  { 13469387883465536574u, 123922941275178184u }, {  8418367427165960359u,  77451838296986365u },
  { 15134645302384838353u,  96814797871232956u }, {   471562554271496325u, 121018497339041196u },
  {  9518098633274461011u,  75636560836900747u }, {  7285937273165688360u,  94545701046125934u },
  { 18330793628311886258u, 118182126307657417u }, {  4539216990053847055u,  73863828942285886u },
  { 14897393274422084627u,  92329786177857357u }, {  4786683537745442072u, 115412232722321697u },
  { 14520892257159371055u,  72132645451451060u }, { 18151115321449213818u,  90165806814313825u },
  {  8853836096529353561u, 112707258517892282u }, {  1843923083806916143u, 140884073147365353u },
  { 12681666973447792349u,  88052545717103345u }, {  2017025661527576725u, 110065682146379182u },
  { 11744654113764246714u, 137582102682973977u }, {   422879793461572340u,  85988814176858736u },
  {   528599741826965425u, 107486017721073420u }, {   660749677283706782u, 134357522151341775u },
  {  7330497575943398595u,  83973451344588609u }, { 13774807988356636147u, 104966814180735761u },
  {  3383451930163631472u, 131208517725919702u }, { 15949715511634433382u,  82005323578699813u },
  {  6102086334260878016u, 102506654473374767u }, {  3015921899398709616u, 128133318091718459u },
  { 18025852251620051174u,  80083323807324036u }, {  4085571240815512351u, 100104154759155046u },
  { 14330336087874166247u, 125130193448943807u }, { 15873989082562435760u,  78206370905589879u },
  { 15230800334775656796u,  97757963631987349u }, {  5203442363187407284u, 122197454539984187u },
  {   946308467778435600u,  76373409087490117u }, {  5794571603150432404u,  95466761359362646u },
  { 16466586540792816313u, 119333451699203307u }, {  7985773578781816244u,  74583407312002067u },
  {  5370530955049882401u,  93229259140002584u }, {  6713163693812353001u, 116536573925003230u },
  { 18030785363914884337u,  72835358703127018u }, { 13315109668038829614u,  91044198378908773u },
  {  2808829029766373305u, 113805247973635967u }, { 17346094342490130344u, 142256559967044958u },
  {  6229622945628943561u,  88910349979403099u }, {  3175342663608791547u, 111137937474253874u },
  { 13192550366365765242u, 138922421842817342u }, {  3633657960551215372u,  86826513651760839u },
  { 18377130505971182927u, 108533142064701048u }, {  4524669058754427043u, 135666427580876311u },
  {  9745447189362598758u,  84791517238047694u }, {  2958436949848472639u, 105989396547559618u },
  { 12921418224165366607u, 132486745684449522u }, { 12687572408530742033u,  82804216052780951u },
  { 11247779492236039638u, 103505270065976189u }, {   224666310012885835u, 129381587582470237u },
  {  2446259452971747599u,  80863492239043898u }, { 12281196353069460307u, 101079365298804872u },
  { 15351495441336825384u, 126349206623506090u }, { 14206370669262903769u,  78968254139691306u },
  {  8534591299723853903u,  98710317674614133u }, { 15279925143082205283u, 123387897093267666u },
  { 14161639232853766206u,  77117435683292291u }, { 13090363022639819853u,  96396794604115364u },
  { 16362953778299774816u, 120495993255144205u }, { 12532689120651053212u,  75309995784465128u },
  { 15665861400813816515u,  94137494730581410u }, { 10358954714162494836u, 117671868413226763u },
  {  4168503687137865320u,  73544917758266727u }, {   598943590494943747u,  91931147197833409u },
  {  5360365506546067587u, 114913933997291761u }, { 11312142901609972388u, 143642417496614701u },
  {  9375932322719926695u,  89776510935384188u }, { 11719915403399908368u, 112220638669230235u },
  { 10038208235822497557u, 140275798336537794u }, { 10885566165816448877u,  87672373960336121u },
  { 18218643725697949000u, 109590467450420151u }, { 18161618638695048346u, 136988084313025189u },
  { 13656854658398099168u,  85617552695640743u }, { 12459382304570236056u, 107021940869550929u },
  {  1739169825430631358u, 133777426086938662u }, { 14922039196176308311u,  83610891304336663u },
  { 14040862976792997485u, 104513614130420829u }, {  3716020665709083144u, 130642017663026037u },
  {  4628355925281870917u,  81651261039391273u }, { 10397130925029726550u, 102064076299239091u },
  {  8384727637859770284u, 127580095374048864u }, {  5240454773662356427u,  79737559608780540u },
  {  6550568467077945534u,  99671949510975675u }, {  3576524565420044014u, 124589936888719594u },
  {  6847013871814915412u,  77868710555449746u }, { 17782139376623420074u,  97335888194312182u },
  { 13004302183924499284u, 121669860242890228u }, { 17351060901807587860u,  76043662651806392u },
  {  3242082053549933210u,  95054578314757991u }, { 17887660622219580224u, 118818222893447488u },
  { 11179787888887237640u,  74261389308404680u }, { 13974734861109047050u,  92826736635505850u },
  {  8245046539531533005u, 116033420794382313u }, { 16682369133275677888u,  72520887996488945u },
  {  7017903361312433648u,  90651109995611182u }, { 17995751238495317868u, 113313887494513977u },
  {  8659630992836983623u, 141642359368142472u }, {  5412269370523114764u,  88526474605089045u },
  { 11377022731581281359u, 110658093256361306u }, {  4997906377621825891u, 138322616570451633u },
  { 14652906532082110942u,  86451635356532270u }, {  9092761128247862869u, 108064544195665338u },
  {  2142579373455052779u, 135080680244581673u }, { 12868327154477877747u,  84425425152863545u },
  {  2250350887815183471u, 105531781441079432u }, {  2812938609768979339u, 131914726801349290u },
  {  6369772649532999991u,  82446704250843306u }, { 17185587848771025797u, 103058380313554132u },
  {  3035240737254230630u, 128822975391942666u }, {  6508711479211282048u,  80514359619964166u },
  { 17359261385868878368u, 100642949524955207u }, { 17087390713908710056u, 125803686906194009u },
  {  3762090168551861929u,  78627304316371256u }, {  4702612710689827411u,  98284130395464070u },
  { 15101637925217060072u, 122855162994330087u }, { 16356052730901744401u,  76784476871456304u },
  {  1998321839917628885u,  95980596089320381u }, {  7109588318324424010u, 119975745111650476u },
  { 13666864735807540814u,  74984840694781547u }, { 12471894901332038114u,  93731050868476934u },
  {  6366496589810271835u, 117163813585596168u }, {  3979060368631419896u,  73227383490997605u },
  {  9585511479216662775u,  91534229363747006u }, {  2758517312166052660u, 114417786704683758u },
  { 12671518677062341634u, 143022233380854697u }, {  1002170145522881665u,  89388895863034186u },
  { 10476084718758377889u, 111736119828792732u }, { 13095105898447972362u, 139670149785990915u },
  {  5878598177316288774u,  87293843616244322u }, { 16571619758500136775u, 109117304520305402u },
  { 11491152661270395161u, 136396630650381753u }, {   264441385652915120u,  85247894156488596u },
  {   330551732066143900u, 106559867695610745u }, {  5024875683510067779u, 133199834619513431u },
  { 10058076329834874218u,  83249896637195894u }, {  3349223375438816964u, 104062370796494868u },
  {  4186529219298521205u, 130077963495618585u }, { 14145795808130045513u,  81298727184761615u },
  { 13070558741735168987u, 101623408980952019u }, { 11726512408741573330u, 127029261226190024u },
  {  7329070255463483331u,  79393288266368765u }, { 13773023837756742068u,  99241610332960956u },
  { 17216279797195927585u, 124052012916201195u }, {  8454331864033760789u,  77532508072625747u },
  {  5956228811614813082u,  96915635090782184u }, {  7445286014518516353u, 121144543863477730u },
  {  9264989777501460624u,  75715339914673581u }, { 16192923240304213684u,  94644174893341976u },
  {  1794409976670715490u, 118305218616677471u }, {  8039035263060279037u,  73940761635423419u },
  {  5437108060397960892u,  92425952044279274u }, { 16019757112352226923u, 115532440055349092u },
  {   788976158365366019u,  72207775034593183u }, { 14821278253238871236u,  90259718793241478u },
  {  9303225779693813237u, 112824648491551848u }, { 11629032224617266546u, 141030810614439810u },
  { 11879831158813179495u,  88144256634024881u }, {  1014730893234310657u, 110180320792531102u },
  { 10491785653397664129u, 137725400990663877u }, {  8863209042587234033u,  86078375619164923u },
  {  6467325284806654637u, 107597969523956154u }, { 17307528642863094104u, 134497461904945192u },
  { 10817205401789433815u,  84060913690590745u }, { 18133192770664180173u, 105076142113238431u },
  { 18054804944902837312u, 131345177641548039u }, { 18201782118205355176u,  82090736025967524u },
  {  4305483574047142354u, 102613420032459406u }, { 14605226504413703751u, 128266775040574257u },
  {  2210737537617482988u,  80166734400358911u }, { 16598479977304017447u, 100208418000448638u },
  { 11524727934775246001u, 125260522500560798u }, {  2591268940807140847u,  78287826562850499u },
  { 17074144231291089770u,  97859783203563123u }, { 16730994270686474309u, 122324729004453904u },
  { 10456871419179046443u,  76452955627783690u }, {  3847717237119032246u,  95566194534729613u },
  {  9421332564826178211u, 119457743168412016u }, {  5888332853016361382u,  74661089480257510u },
  { 16583788103125227536u,  93326361850321887u }, { 16118049110479146516u, 116657952312902359u },
  { 16991309721690548428u,  72911220195563974u }, { 12015765115258409727u,  91139025244454968u },
  { 15019706394073012159u, 113923781555568710u }, {  9551260955736489391u, 142404726944460888u },
  {  5969538097335305869u,  89002954340288055u }, {  2850236603241744433u, 111253692925360069u }
};


inline constexpr int __TABLE_SIZE = 64;

inline constexpr uint16_t __POW10_OFFSET[__TABLE_SIZE] = {
  0, 2, 5, 8, 12, 16, 21, 26, 32, 39,
  46, 54, 62, 71, 80, 90, 100, 111, 122, 134,
  146, 159, 173, 187, 202, 217, 233, 249, 266, 283,
  301, 319, 338, 357, 377, 397, 418, 440, 462, 485,
  508, 532, 556, 581, 606, 632, 658, 685, 712, 740,
  769, 798, 828, 858, 889, 920, 952, 984, 1017, 1050,
  1084, 1118, 1153, 1188
};

inline constexpr uint64_t __POW10_SPLIT[1224][3] = {
  {                    1u,    72057594037927936u,                    0u },
  {   699646928636035157u,             72057594u,                    0u },
  {                    1u,                    0u,                  256u },
  { 11902091922964236229u,        4722366482869u,                    0u },
  {  6760415703743915872u,                 4722u,                    0u },
  {                    1u,                    0u,             16777216u },
  { 13369850649504950658u,   309485009821345068u,                    0u },
  { 15151142278969419334u,            309485009u,                    0u },
  {                    1u,                    0u,          75511627776u },
  {  4635408826454083567u,  9437866644873197963u,                 1099u },
  { 12367138975830625353u,       20282409603651u,                    0u },
  {  7555853734021184432u,                20282u,                    0u },
  {                    1u,                    0u,         250037927936u },
  {  5171444645924616995u,   699646928636035156u,             72057594u },
  { 16672297533003297786u,  1329227995784915872u,                    0u },
  { 14479142226848862515u,           1329227995u,                    0u },
  {                    1u,                    0u,         181645213696u },
  { 12214193123817091081u, 11902091922964236228u,         114366482869u },
  { 16592893013671929435u,  6760415703743915871u,                 4722u },
  {  4549827147718617003u,       87112285931760u,                    0u },
  {  5274510003815168971u,                87112u,                    0u },
  {                    1u,                    0u,          44724781056u },
  {  9794971998307800535u, 13369850649504950657u,         209821345068u },
  { 14720142899209240169u, 15151142278969419333u,            309485009u },
  {  4300745446091561535u,  5708990770823839524u,                    0u },
  { 15197156861335443364u,           5708990770u,                    0u },
  {                    1u,                    0u,         139251286016u },
  { 13484604155038683037u,  4635408826454083566u,          67670423947u },
  {  8356963862052375699u, 12367138975830625352u,          58409603651u },
  {  5850852848337610021u,  7555853734021184431u,                20282u },
  {  2712780827214982050u,      374144419156711u,                    0u },
  {  7732076577307618052u,               374144u,                    0u },
  {                    1u,                    0u,          84280344576u },
  { 17296309485351745867u,  5171444645924616994u,         160903807060u },
  { 16598859101615853088u, 16672297533003297785u,         219784915872u },
  {  7469952526870444257u, 14479142226848862514u,           1329227995u },
  { 13531654022114669524u,  6073184580144670117u,                    1u },
  { 15757609704383306943u,          24519928653u,                    0u },
  {  9590990814237149590u,                   24u,                    0u },
  {                    1u,                    0u,         196662132736u },
  { 15408590707489433890u, 12214193123817091080u,          95899502532u },
  { 18332056844289122710u, 16592893013671929434u,         240246646623u },
  { 11114572877353986193u,  4549827147718617002u,          72285931760u },
  {  1703393793997526525u,  5274510003815168970u,                87112u },
  {  5082852056285196265u,     1606938044258990u,                    0u },
  {   816434266573722365u,              1606938u,                    0u },
  {                    1u,                    0u,         129530986496u },
  {  5736523019264798742u,  9794971998307800534u,          69797980545u },
  { 10129314776268243339u, 14720142899209240168u,          36233143877u },
  { 16511595775483995364u,  4300745446091561534u,          50823839524u },
  { 12367293405401453325u, 15197156861335443363u,           5708990770u },
  { 16934621733248854291u, 13078571300009428617u,                    5u },
  { 10278280417769171336u,         105312291668u,                    0u },
  {  5760764486226151240u,                  105u,                    0u },
  {                    1u,                    0u,         238731001856u },
  {  4128368337188369761u, 13484604155038683036u,          72453031918u },
  { 10240941003671005056u,  8356963862052375698u,         175317175368u },
  { 17933378316822368251u,  5850852848337610020u,         231147060143u },
  {  8346249813075698616u,  2712780827214982049u,         128419156711u },
  { 15906203609160902695u,  7732076577307618051u,               374144u },
  { 14525607416135386328u,     6901746346790563u,                    0u },
  {  6397156777364256320u,              6901746u,                    0u },
  {                    1u,                    0u,          34937634816u },
  { 16798760952716600048u, 17296309485351745866u,         249899825954u },
  {  2419982808370854967u, 16598859101615853087u,          50404946937u },
  {  2922947087773078956u,  7469952526870444256u,         165733552434u },
  { 15419220167069510190u, 13531654022114669523u,          77854221733u },
  {  3452124642157173416u, 15757609704383306942u,          24519928653u },
  {  5979700067267186899u,  9590990814237149589u,                   24u },
  {  4913998146922579597u,         452312848583u,                    0u },
  {  5771037749337678924u,                  452u,                    0u },
  {                    1u,                    0u,           8835301376u },
  {  3464734175350698519u, 15408590707489433889u,          90993782792u },
  {  9334527711335850125u, 18332056844289122709u,         170602522202u },
  {  7269882896518450106u, 11114572877353986192u,         202092341162u },
  {  1372511258182263196u,  1703393793997526524u,         174275541962u },
  {  7571228438575951046u,  5082852056285196264u,          26044258990u },
  {  2992506536646070406u,   816434266573722364u,              1606938u },
  {   524517896824344606u,    29642774844752946u,                    0u },
  { 15582941400898702773u,             29642774u,                    0u },
  {                    1u,                    0u,         214310977536u },
  {  3846112492507251066u,  5736523019264798741u,         104549111254u },
  { 16681117750123089487u, 10129314776268243338u,          62895095400u },
  { 14986314536556547267u, 16511595775483995363u,         163670432318u },
  {  2573712825027107389u, 12367293405401453324u,         137918027683u },
  {  7504855874008324928u, 16934621733248854290u,          84557186697u },
  {  9572138030626879787u, 10278280417769171335u,         105312291668u },
  {  8520676959353394843u,  5760764486226151239u,                  105u },
  { 13448984662897903496u,        1942668892225u,                    0u },
  { 12338883700918130648u,                 1942u,                    0u },
  {                    1u,                    0u,         156223799296u },
  {  2517285787892561600u,  4128368337188369760u,         146555162524u },
  {  4338831817635138103u, 10240941003671005055u,          36972170386u },
  {  1561495325934523196u, 17933378316822368250u,         161452451108u },
  { 12262635050079398786u,  8346249813075698615u,           3862277025u },
  { 11144065765517284188u, 15906203609160902694u,         163787434755u },
  {  1212260522471875711u, 14525607416135386327u,         242346790563u },
  {  9695352922247418869u,  6397156777364256319u,              6901746u },
  {  7227025834627242948u,   127314748520905380u,                    0u },
  {  9609008238705447829u,            127314748u,                    0u },
  {                    1u,                    0u,          74910662656u },
  {  3609144142396852269u, 16798760952716600047u,          31131187530u },
  { 11568848377382068865u,  2419982808370854966u,         224158453279u },
  { 10068303578029323957u,  2922947087773078955u,         211835877600u },
  { 11645070846862630231u, 15419220167069510189u,         190187140051u },
  { 12449386705878485055u,  3452124642157173415u,         149324160190u },
  { 15025619323517318418u,  5979700067267186898u,         199266388373u },
  { 14996237555047131272u,  4913998146922579596u,         196312848583u },
  { 10211005638256058413u,  5771037749337678923u,                  452u },
  {  1014743503555840530u,        8343699359066u,                    0u },
  { 12900897707145290678u,                 8343u,                    0u },
  {                    1u,                    0u,          33187823616u },
  {  4718003016239473662u,  3464734175350698518u,         149506025761u },
  { 14865830648693666725u,  9334527711335850124u,         144394101141u },
  { 14754517212823091778u,  7269882896518450105u,         252074403984u },
  { 11113946551474911901u,  1372511258182263195u,         232410437116u },
  {  1963520352638130630u,  7571228438575951045u,         252162224104u },
  { 13342587341404964200u,  2992506536646070405u,          50028434172u },
  {  6240392545013573291u,   524517896824344605u,          22844752946u },
  { 14377490861349714758u, 15582941400898702772u,             29642774u },
  {  1717863312631397839u,   546812681195752981u,                    0u },
  {  3611005143890591770u,            546812681u,                    0u },
  {                    1u,                    0u,          21208498176u },
  { 13168252824351245504u,  3846112492507251065u,         138904285205u },
  {   735883891883379688u, 16681117750123089486u,         227812409738u },
  { 10609203866866106404u, 14986314536556547266u,          12139521251u },
  { 12358191111890306470u,  2573712825027107388u,          18406839052u },
  { 15229916368406413528u,  7504855874008324927u,         135518906642u },
  {  7241424335568075942u,  9572138030626879786u,          71461906823u },
  {  6049715868779871913u,  8520676959353394842u,          65729070919u },
  {  2000548404719336762u, 13448984662897903495u,         150668892225u },
  {  1410974761895205301u, 12338883700918130647u,                 1942u },
  { 16000132467694084868u,       35835915874844u,                    0u },
  { 16894908866816792556u,                35835u,                    0u },
  {                    1u,                    0u,          96136462336u },
  {   589096329272056762u,  2517285787892561599u,         127235208544u },
  {  7097729792403256904u,  4338831817635138102u,         250084648831u },
  {  8553736750439287020u,  1561495325934523195u,         183664758778u },
  {  2114152625261065696u, 12262635050079398785u,          38604121015u },
  {  9817523680007641224u, 11144065765517284187u,         215065716774u },
  { 13047215537500048015u,  1212260522471875710u,          63525586135u },
  { 16755544192002345880u,  9695352922247418868u,         164391777855u },
  {  6930119832670648356u,  7227025834627242947u,          60520905380u },
  { 14560698131901886167u,  9609008238705447828u,            127314748u },
  { 16408020927503338035u,  2348542582773833227u,                    0u },
  { 14274703510609809116u,           2348542582u,                    0u },
  {                    1u,                    0u,         239195652096u },
  { 16428432973129962470u,  3609144142396852268u,          54627148527u },
  {  3721112279790863774u, 11568848377382068864u,         171545803830u },
  { 18032764903259620753u, 10068303578029323956u,          45631280555u },
  { 18058455550468776079u, 11645070846862630230u,         167674882605u },
  { 15692090139033993190u, 12449386705878485054u,         210814540455u },
  {   389416944300619393u, 15025619323517318417u,         140812947666u },
  { 12009691357260487293u, 14996237555047131271u,          75553539724u },
  { 13494259174449809900u, 10211005638256058412u,          90055009355u },
  { 18288583400616279877u,  1014743503555840529u,         151699359066u },
  {     7216107869057472u, 12900897707145290677u,                 8343u },
  { 17237061291959073878u,      153914086704665u,                    0u },
  {  1599418782488783273u,               153914u,                    0u },
  {                    1u,                    0u,          22255763456u },
  {  9565464987240335777u,  4718003016239473661u,         140805878294u },
  {   857713933775880687u, 14865830648693666724u,         185799843980u },
  {  4621617820081363356u, 14754517212823091777u,         155602488249u },
  {  9630162611715632528u, 11113946551474911900u,         197106442651u },
  {  9283986497984645815u,  1963520352638130629u,         133723303109u },
  {  8981807745082630996u, 13342587341404964199u,          29338292357u },
  { 18350140531565934622u,  6240392545013573290u,         180779405341u },
  {  4411619033127524143u, 14377490861349714757u,          21093125556u },
  {  1852297584111266889u,  1717863312631397838u,           9195752981u },
  { 11746243463811666096u,  3611005143890591769u,            546812681u },
  {  6335244004343789147u, 10086913586276986678u,                    0u },
  {  5109502367228239844u,          10086913586u,                    0u },
  {  1603272682579847821u,                   10u,                    0u },
  {                    1u,                    0u,         121713852416u },
  {  6609546910952910052u, 13168252824351245503u,          78039892345u },
  {  3911171343112928288u,   735883891883379687u,         194575126094u },
  {  5254510615100863555u, 10609203866866106403u,          60669938882u },
  {  3881927570803887650u, 12358191111890306469u,          63825615420u },
  {  6379348759607163190u, 15229916368406413527u,          42392558399u },
  { 14595733737222406466u,  7241424335568075941u,         154327955754u },
  { 14670223432002373542u,  6049715868779871912u,         135108449946u },
  {  4045087795619708513u,  2000548404719336761u,         215076489095u },
  { 12598467307137142718u,  1410974761895205300u,          28867368919u },
  {   734704388050777108u, 16000132467694084867u,         251915874844u },
  {  5682201693687285822u, 16894908866816792555u,                35835u },
  { 11048712694145438788u,      661055968790248u,                    0u },
  { 17871025777010319485u,               661055u,                    0u },
  {                    1u,                    0u,         191031934976u },
  { 15268761435931663695u,   589096329272056761u,          54384768703u },
  {  5016238054648555438u,  7097729792403256903u,          59463698998u },
  { 14236047313993899750u,  8553736750439287019u,         129114608443u },
  {  6957759675154690848u,  2114152625261065695u,          91532209025u },
  { 18439367135478514473u,  9817523680007641223u,         126707290971u },
  {  8539004472540641041u, 13047215537500048014u,         244908319870u },
  {  1908462039431738399u, 16755544192002345879u,         195375682548u },
  {   714690453250792146u,  6930119832670648355u,         148789337027u },
  { 13782189447673929633u, 14560698131901886166u,          11889480596u },
  {  3584742913798803164u, 16408020927503338034u,         118773833227u },
  {  4347581515245125291u, 14274703510609809115u,           2348542582u },
  { 16836742268156371392u,  6429475823218628948u,                    2u },
  { 11764082328865615308u,          43322963970u,                    0u },
  {  5957633711383291746u,                   43u,                    0u },
  {                    1u,                    0u,          44890587136u },
  {  9917186842884466953u, 16428432973129962469u,         128201721900u },
  {  4751011869809829335u,  3721112279790863773u,         180977558144u },
  { 11068497969931435029u, 18032764903259620752u,          86978950836u },
  { 17118056985122509954u, 18058455550468776078u,          62850669910u },
  { 14607066080907684459u, 15692090139033993189u,          17021110334u },
  { 11768892370493391107u,   389416944300619392u,         135651046673u },
  {  4043396447647747170u, 12009691357260487292u,          44731525255u },
  {  1670341095362518057u, 13494259174449809899u,          17991426092u },
  {  3190817644167043165u, 18288583400616279876u,         181000391185u },
  { 10425820027224322486u,     7216107869057471u,          25934422965u },
  { 13139964660506311565u, 17237061291959073877u,          58086704665u },
  {  2297772885416059937u,  1599418782488783272u,               153914u },
  {  7677687919964523763u,     2839213766779714u,                    0u },
  { 14144589152747892828u,              2839213u,                    0u },
  {                    1u,                    0u,         253518544896u },
  { 17069730341503660290u,  9565464987240335776u,         164046496765u },
  { 18167423787163077107u,   857713933775880686u,          65250538404u },
  {  3765746945827805904u,  4621617820081363355u,         156522052161u },
  { 10241734342430761691u,  9630162611715632527u,         197503285916u },
  { 13345717282537140784u,  9283986497984645814u,         103486904773u },
  {  9313926784816939953u,  8981807745082630995u,         170994763111u },
  {   550974205049535019u, 18350140531565934621u,          69239154346u },
  {  4494692285504086222u,  4411619033127524142u,         206100413253u },
  {  1134308559863725587u,  1852297584111266888u,          25636765134u },
  { 17587558045116130233u, 11746243463811666095u,          54343434265u },
  {  9817142032346161594u,  6335244004343789146u,          50276986678u },
  {  6071944935834172568u,  5109502367228239843u,          10086913586u },
  { 11564168293299416955u,  1603272682579847820u,                   10u },
  { 12458266507226064437u,         186070713419u,                    0u },
  {  1304432355328256915u,                  186u,                    0u },
  {                    1u,                    0u,         191358304256u },
  { 15946798815542087355u,  6609546910952910051u,         231212025023u },
  { 12082566083831286138u,  3911171343112928287u,          35284847591u },
  { 11449623684706196411u,  5254510615100863554u,         165210439715u },
  { 17518743620362604446u,  3881927570803887649u,         215345825189u },
  {  9451061563087633805u,  6379348759607163189u,         165791236311u },
  { 13191114787623314926u, 14595733737222406465u,         168795274405u },
  {  8367349876734474799u, 14670223432002373541u,          57219284648u },
  {  6544253801674393507u,  4045087795619708512u,         180682964281u },
  { 16113906253336597498u, 12598467307137142717u,           3039828404u },
  { 10294087136797312392u,   734704388050777107u,         235308032771u },
  {  9127173070014462803u,  5682201693687285821u,         232598951915u },
  { 16266900839595484952u, 11048712694145438787u,          63968790248u },
  {  3299745387370952632u, 17871025777010319484u,               661055u },
  { 12061115182604399189u,    12194330274671844u,                    0u },
  {  5066801222582989646u,             12194330u,                    0u },
  {                    1u,                    0u,         185827721216u },
  {  7568423425299591513u, 15268761435931663694u,          71271930809u },
  { 16561505984665207377u,  5016238054648555437u,         235771737671u },
  {  4329114621856906245u, 14236047313993899749u,         223377180907u },
  {  1477500474861899139u,  6957759675154690847u,         135999600095u },
  { 16891579639263969684u, 18439367135478514472u,         142462900359u },
  {  4684451357140027420u,  8539004472540641040u,         151103457934u },
  { 14727186580409080709u,  1908462039431738398u,          35038743447u },
  { 15864176859687308834u,   714690453250792145u,         214747133987u },
  {  1755486942842684438u, 13782189447673929632u,          50194329302u },
  { 17417077516652710041u,  3584742913798803163u,         219235682866u },
  {  4290982361913532783u,  4347581515245125290u,          84912721627u },
  { 11826659981004351409u, 16836742268156371391u,           2637732180u },
  {   932930645678090820u, 11764082328865615307u,          43322963970u },
  { 12707792781328052617u,  5957633711383291745u,                   43u },
  { 16491596426880311906u,         799167628880u,                    0u },
  {  3092207065214166010u,                  799u,                    0u },
  {                    1u,                    0u,         229537611776u },
  {  8142946531605512550u,  9917186842884466952u,         157257552869u },
  {  5328402096432654515u,  4751011869809829334u,         144600024477u },
  {  1932004361303814512u, 11068497969931435028u,         142927971728u },
  {  2511477647985517771u, 17118056985122509953u,         229791850638u },
  { 17451375493324716694u, 14607066080907684458u,         128637992933u },
  {  9489266854478998489u, 11768892370493391106u,         124219192960u },
  {  8803053132063235169u,  4043396447647747169u,         235090549372u },
  { 16198682197142616773u,  1670341095362518056u,          68172974571u },
  { 13696242485403414202u,  3190817644167043164u,         191565184836u },
  { 16409082426079859931u, 10425820027224322485u,          85712318911u },
  { 11653410736879597610u, 13139964660506311564u,         168124562517u },
  { 13589514120653213261u,  2297772885416059936u,          66416208296u },
  {  8032934885905905774u,  7677687919964523762u,         173766779714u },
  {  2753021350129449273u, 14144589152747892827u,              2839213u },
  { 16974897459201404133u,    52374249726338269u,                    0u },
  { 13398576176159101589u,             52374249u,                    0u },
  {                    1u,                    0u,         160925351936u },
  { 10284586955251725351u, 17069730341503660289u,         238984858016u },
  {  5294476488634150891u, 18167423787163077106u,         155204141550u },
  { 15833244538135063323u,  3765746945827805903u,         143555205531u },
  { 10348512742273116664u, 10241734342430761690u,         182723472783u },
  { 13658504610142595663u, 13345717282537140783u,          83504908982u },
  { 11956362239240850266u,  9313926784816939952u,          29029868371u },
  { 13415901703662731781u,   550974205049535018u,          46243657757u },
  {  5161774027546852762u,  4494692285504086221u,          72061490990u },
  { 15274384838790587711u,  1134308559863725586u,         175953423432u },
  { 14233354597679374929u, 17587558045116130232u,          90532188335u },
  {  4274656492162486921u,  9817142032346161593u,         227329160794u },
  { 12040276505541795046u,  6071944935834172567u,         140626894819u },
  { 13238307206256765457u, 11564168293299416954u,          75675363980u },
  { 12850161204172713271u, 12458266507226064436u,         186070713419u },
  { 17531777095001445154u,  1304432355328256914u,                  186u },
  {  5623628114515245990u,        3432398830065u,                    0u },
  {  7357116143579573377u,                 3432u,                    0u },
  {                    1u,                    0u,         227864477696u },
  {  3555734177475596582u, 15946798815542087354u,          31654997219u },
  { 14001876724756424382u, 12082566083831286137u,          66620685343u },
  { 18159905057231476140u, 11449623684706196410u,          33949692994u },
  {  5585207679308509467u, 17518743620362604445u,          53512343073u },
  { 13948697622866724672u,  9451061563087633804u,          65715091765u },
  {  9807691927739036432u, 13191114787623314925u,         165453594945u },
  { 15818010096140820918u,  8367349876734474798u,          96354764709u },
  {  5629845624785010943u,  6544253801674393506u,         189873536608u },
  {  9517635131137734707u, 16113906253336597497u,          19558043581u },
  {   619338244618780585u, 10294087136797312391u,          61494785043u },
  { 11632367007491958899u,  9127173070014462802u,          67881830461u },
  { 12083314261009739916u, 16266900839595484951u,         124178879555u },
  { 16880538609458881650u,  3299745387370952631u,         228653834364u },
  { 17404223674486504228u, 12061115182604399188u,          26274671844u },
  {  7089067015287185433u,  5066801222582989645u,             12194330u },
  {  2592264228029443648u,   224945689727159819u,                    0u },
  { 13413731084370224440u,            224945689u,                    0u },
  {                    1u,                    0u,          78410285056u },
  {  9323915941641553425u,  7568423425299591512u,         173897801038u },
  { 12155831029092699564u, 16561505984665207376u,         229234681773u },
  { 17397171276588232676u,  4329114621856906244u,          31080095461u },
  { 11874560617553253769u,  1477500474861899138u,          40915694367u },
  { 13444839516837727954u, 16891579639263969683u,          16253944616u },
  { 16994416043584590671u,  4684451357140027419u,          30798362384u },
  { 15879694502877015730u, 14727186580409080708u,         209859998750u },
  {  4234647645735263359u, 15864176859687308833u,         160095165137u },
  {  7978589901512919496u,  1755486942842684437u,         219944181664u },
  {  6114237175390859894u, 17417077516652710040u,         170232614619u },
  {  8658612872088282708u,  4290982361913532782u,         191641124522u },
  { 10253813330683324853u, 11826659981004351408u,         203050574271u },
  { 13289465061747830991u,   932930645678090819u,          97688890827u },
  {  4123165538545565412u, 12707792781328052616u,          80894011233u },
  {  7846417485927038481u, 16491596426880311905u,          31167628880u },
  { 10562273346358018864u,  3092207065214166009u,                  799u },
  {  2691512658346619120u,       14742040721959u,                    0u },
  {   751187558544605998u,                14742u,                    0u },
  {                    1u,                    0u,           8441430016u },
  {  3757709791947931308u,  8142946531605512549u,         214288853256u },
  {  3452755398462519465u,  5328402096432654514u,          20104734166u },
  {  3105818720159874523u,  1932004361303814511u,         129136147476u },
  { 16859138458894499364u,  2511477647985517770u,         106946040961u },
  { 12271894740606233755u, 17451375493324716693u,           2514414186u },
  {  5429638071845793701u,  9489266854478998488u,          97477214466u },
  {   145278150038876889u,  8803053132063235168u,          40878132321u },
  {  9050266019724932450u, 16198682197142616772u,          92742474792u },
  { 11907016253451490866u, 13696242485403414201u,         181889538140u },
  {  2472757296513770735u, 16409082426079859930u,         140631732661u },
  { 10558733798178239360u, 11653410736879597609u,          32736689036u },
  { 15917322570831255850u, 13589514120653213260u,         242435466272u },
  { 12254334656791355238u,  8032934885905905773u,          91149241586u },
  {  7869542424662730262u,  2753021350129449272u,         221920211035u },
  {  1378558986933000253u, 16974897459201404132u,         233726338269u },
  { 13521405041909411105u, 13398576176159101588u,             52374249u },
  {  3206744593298092012u,   966134380754314586u,                    0u },
  { 13914648122214918505u,            966134380u,                    0u },
  {                    1u,                    0u,           1557528576u },
  {  1235541077112082496u, 10284586955251725350u,         242287014145u },
  { 12014985518315533846u,  5294476488634150890u,         207858321906u },
  {  1561535086344155741u, 15833244538135063322u,         218560993999u },
  { 12761747276316224577u, 10348512742273116663u,          47740429018u },
  {  9745594781103966137u, 13658504610142595662u,         176648155695u },
  { 17514238702394846785u, 11956362239240850265u,          42727277488u },
  {  2428898913707151713u, 13415901703662731780u,         205279820330u },
  {    71666709959904945u,  5161774027546852761u,          18828026061u },
  {  4049380135452919193u, 15274384838790587710u,         184771591698u },
  { 18422240861777453733u, 14233354597679374928u,         185231729592u },
  {  2914504416394425696u,  4274656492162486920u,         151652704697u },
  { 12721377795748989418u, 12040276505541795045u,         122717650071u },
  {  2626074459217717422u, 13238307206256765456u,          52696608634u },
  {  4261529925046307655u, 12850161204172713270u,         146950399540u },
  { 11536038685430305586u, 17531777095001445153u,         241304857490u },
  { 12555757789435162768u,  5623628114515245989u,         104398830065u },
  { 11905178684546080059u,  7357116143579573376u,                 3432u },
  { 14032797718924543051u,       63316582777114u,                    0u },
  { 10750340288005853484u,                63316u,                    0u },
  {                    1u,                    0u,         186192756736u },
  {  9660290106216358253u,  3555734177475596581u,         121759043258u },
  { 14820142034615351103u, 14001876724756424381u,         186984450425u },
  { 12674041783707777619u, 18159905057231476139u,         157302774714u },
  { 15386686816442679994u,  5585207679308509466u,         140756160413u },
  {  5679510383719146248u, 13948697622866724671u,         237531676044u },
  {  1391101719248678506u,  9807691927739036431u,          46857496045u },
  {  3364596672173710517u, 15818010096140820917u,         162305194542u },
  { 11276509210104319732u,  5629845624785010942u,         249515952034u },
  {  5316312656902630164u,  9517635131137734706u,         135033574393u },
  { 17470981304473644647u,   619338244618780584u,          82630591879u },
  {  7373293636384920591u, 11632367007491958898u,          23655037778u },
  {  7616810902585191937u, 12083314261009739915u,         183915095831u },
  { 12740295655921903924u, 16880538609458881649u,          84943484855u },
  { 18366635945916526940u, 17404223674486504227u,          77384299092u },
  {  4472171448243407067u,  7089067015287185432u,          11140526925u },
  {   229592460858185629u,  2592264228029443647u,          25727159819u },
  { 12749672866417114996u, 13413731084370224439u,            224945689u },
  {  9452256722867098693u,  4149515568880992958u,                    0u },
  { 16251451636418604634u,           4149515568u,                    0u },
  {                    1u,                    0u,          88505450496u },
  {  4515791283442995454u,  9323915941641553424u,          80658968920u },
  { 13306155670047701346u, 12155831029092699563u,           4943102544u },
  {  4456930152933417601u, 17397171276588232675u,         130643721220u },
  {  9089157128546489637u, 11874560617553253768u,         147728846210u },
  { 12437332180345515840u, 13444839516837727953u,          27921269139u },
  {  3433060408790452524u, 16994416043584590670u,         132860839963u },
  {  8275594526021936172u, 15879694502877015729u,          33229560708u },
  {  3846512444641107689u,  4234647645735263358u,          21432520225u },
  {  6210962618469046250u,  7978589901512919495u,         152331453461u },
  {  7272858906616296575u,  6114237175390859893u,         110469384344u },
  {  3710743300451225347u,  8658612872088282707u,         176555860334u },
  {  6424677242672030600u, 10253813330683324852u,          67720423344u },
  { 11485842256170301862u, 13289465061747830990u,         136223517251u },
  {  7355797963557024308u,  4123165538545565411u,          97425355144u },
  {  6358188982569427273u,  7846417485927038480u,         249572581985u },
  { 12475094728768767402u, 10562273346358018863u,          39145907193u },
  { 17288154837907896183u,  2691512658346619119u,         150040721959u },
  {  2983850577727105262u,   751187558544605997u,                14742u },
  { 13918604635001185935u,      271942652322184u,                    0u },
  { 12033220395769876327u,               271942u,                    0u },
  {                    1u,                    0u,         101203705856u },
  {  5782377197813462997u,  3757709791947931307u,         178187174245u },
  { 17732139848231399226u,  3452755398462519464u,         111168366770u },
  {  3628839527415562921u,  3105818720159874522u,         202913935727u },
  {  3188692267613601004u, 16859138458894499363u,         149665260746u },
  {  5168130193478377352u, 12271894740606233754u,         216294341269u },
  { 12556227529405091290u,  5429638071845793700u,          96007875544u },
  { 15087090312791441192u,   145278150038876888u,         196490615904u },
  { 10281804758610642494u,  9050266019724932449u,         185645480644u },
  { 14238177586158586580u, 11907016253451490865u,         218134048441u },
  {  7107927498217678128u,  2472757296513770734u,          41572390106u },
  {  3845814658485364450u, 10558733798178239359u,          76862879785u },
  {   714293333681725946u, 15917322570831255849u,         109664308812u },
  { 16766172658649116982u, 12254334656791355237u,          56426608749u },
  {   812461421432632215u,  7869542424662730261u,         228074731832u },
  { 15218024718633799196u,  1378558986933000252u,         148732996836u },
  {  8110797782612805146u, 13521405041909411104u,          90173837972u },
  { 15941193964933529227u,  3206744593298092011u,         108754314586u },
  { 14144280602323277933u, 13914648122214918504u,            966134380u },
  { 15072402647813125245u, 17822033662586700072u,                    0u },
  { 10822706091283369889u,          17822033662u,                    0u },
  { 15163844593710966731u,                   17u,                    0u },
  {                    1u,                    0u,          38066978816u },
  {  2408529687792073670u,  1235541077112082495u,         234651333670u },
  {  3980682212356510808u, 12014985518315533845u,          26084650986u },
  {  4202670442792148519u,  1561535086344155740u,         247691815706u },
  {  9419583343154651922u, 12761747276316224576u,          78528309751u },
  { 16359166491570434575u,  9745594781103966136u,          89949448782u },
  { 12567727056384237385u, 17514238702394846784u,           4131670873u },
  {  2068388267923286639u,  2428898913707151712u,         153003885060u },
  {  5689135844565021196u,    71666709959904944u,          62219517337u },
  {  3104061965171139313u,  4049380135452919192u,          80998671678u },
  {  7955173880156328016u, 18422240861777453732u,         136157995600u },
  {  1445179403240833754u,  2914504416394425695u,         229689627272u },
  { 12538201164459126715u, 12721377795748989417u,          16142359781u },
  {  7580606719088482667u,  2626074459217717421u,          54231018000u },
  {  8168318283218819755u,  4261529925046307654u,          33625369910u },
  {  5249615277755961676u, 11536038685430305585u,         165680648993u },
  {  6312997372068219831u, 12555757789435162767u,         128645381029u },
  {  9183815417025176703u, 11905178684546080058u,          26760719488u },
  { 10683849953373876937u, 14032797718924543050u,          84582777114u },
  { 17175012155615667568u, 10750340288005853483u,                63316u },
  { 18003508288378896912u,     1167984798111281u,                    0u },
  { 14722554560950996951u,              1167984u,                    0u },
  {                    1u,                    0u,          37523685376u },
  { 15059324482416394930u,  9660290106216358252u,         189803401509u },
  {  4134778595813308312u, 14820142034615351102u,         171687061181u },
  { 16321118342639660948u, 12674041783707777618u,          26834113963u },
  {  1523550293123468805u, 15386686816442679993u,          63307886874u },
  {  8016371634569878509u,  5679510383719146247u,          15075411775u },
  {  9884220139611134110u,  1391101719248678505u,         181182395151u },
  {  7218073002727840414u,  3364596672173710516u,         254611300789u },
  { 16062235669481359233u, 11276509210104319731u,          50288197886u },
  { 15558048660560338002u,  5316312656902630163u,         168947103794u },
  {  8394398745765058609u, 17470981304473644646u,         114399707048u },
  {  5693296366442904274u,  7373293636384920590u,         139412908146u },
  { 11783494675061161358u,  7616810902585191936u,         113690652811u },
  { 13377293110865447894u, 12740295655921903923u,          35995657329u },
  { 12840734051093062130u, 18366635945916526939u,          24242436899u },
  {  7009868331566697505u,  4472171448243407066u,          63012446232u },
  {  5019690705031194477u,   229592460858185628u,          55691161151u },
  {  8608277240439804984u, 12749672866417114995u,         190512407863u },
  { 12172482590657749222u,  9452256722867098692u,          48880992958u },
  { 16613484892678771990u, 16251451636418604633u,           4149515568u },
  {  5721488662757049244u,  2758075434182769113u,                    4u },
  {   386931106438877039u,          76545051729u,                    0u },
  { 10054429752182825659u,                   76u,                    0u },
  {                    1u,                    0u,          16244801536u },
  {  8634592106137071313u,  4515791283442995453u,         171721328144u },
  { 12626356501369830731u, 13306155670047701345u,         227241610667u },
  {  4803333258178976933u,  4456930152933417600u,         136492724195u },
  { 13613083223558209297u,  9089157128546489636u,         209674229128u },
  { 16106967997237446989u, 12437332180345515839u,          78186106577u },
  { 14832921244380020170u,  3433060408790452523u,         177448620878u },
  { 13774024637717231397u,  8275594526021936171u,         126208519857u },
  {  9673012968505228885u,  3846512444641107688u,         199336696958u },
  {  5391832334264815667u,  6210962618469046249u,         117394262471u },
  { 16514436292632703088u,  7272858906616296574u,          83201159797u },
  { 12025036352783454153u,  3710743300451225346u,         180348282451u },
  {  7059867105311401050u,  6424677242672030599u,         206622648756u },
  { 12769210631552594670u, 11485842256170301861u,         227398758606u },
  {  8328873878884556145u,  7355797963557024307u,          16344678115u },
  {  1016565892414238685u,  6358188982569427272u,          47676276240u },
  {  9662978461927250281u, 12475094728768767401u,         239937192751u },
  { 13729967277551868112u, 17288154837907896182u,          45161754863u },
  {  6371593776693359475u,  2983850577727105261u,         136754529069u },
  { 17617208110845643245u, 13918604635001185934u,          70652322184u },
  { 14960960225633086797u, 12033220395769876326u,               271942u },
  { 12090634301321662558u,     5016456510113118u,                    0u },
  {  9409926148478635503u,              5016456u,                    0u },
  {                    1u,                    0u,         171313463296u },
  {  4307062684900157136u,  5782377197813462996u,         168961261227u },
  { 15300759383869911853u, 17732139848231399225u,         218196719784u },
  { 16007534237643445447u,  3628839527415562920u,          35172859354u },
  {  7138502295759677634u,  3188692267613601003u,         154280164899u },
  {  8218537071653683708u,  5168130193478377351u,         164680674458u },
  {  2254219416760329296u, 12556227529405091289u,         216817872804u },
  {  3057410459568460683u, 15087090312791441191u,          97557377752u },
  {  8217810929938874370u, 10281804758610642493u,          49771853153u },
  { 11741126472498340929u, 14238177586158586579u,         238385321521u },
  {  1175325363726654805u,  7107927498217678127u,         127208482030u },
  {  9428843070696730900u,  3845814658485364449u,          41038721919u },
  { 12662500978715131896u,   714293333681725945u,         101908896041u },
  {  6443045597035184564u, 16766172658649116981u,          21044043621u },
  {  1921385512639171183u,   812461421432632214u,          60824970773u },
  { 10469475094355551399u, 15218024718633799195u,          32439687228u },
  { 14679174489076953574u,  8110797782612805145u,         235864173856u },
  { 11853074234719825644u, 15941193964933529226u,         104766762987u },
  {  8270896886596139124u, 14144280602323277932u,          40817076584u },
  { 16532667046659118126u, 15072402647813125244u,         254586700072u },
  {   148341279888833483u, 10822706091283369888u,          17822033662u },
  { 10364629296397276041u, 15163844593710966730u,                   17u },
  { 14265682585545771671u,         328758493846u,                    0u },
  { 13991741872911347878u,                  328u,                    0u },
  {                    1u,                    0u,          63130566656u },
  { 14029045786848724433u,  2408529687792073669u,          21215793215u },
  {  4005878521026842341u,  3980682212356510807u,          92227827221u },
  {  3428326338640386488u,  4202670442792148518u,          64510636636u },
  {  1010001558294829380u,  9419583343154651921u,         184886832192u },
  {  2012063724327403418u, 16359166491570434574u,          64681297848u },
  { 10997154538851372612u, 12567727056384237384u,          96112127552u },
  {  1917749645489607898u,  2068388267923286638u,         176308408672u },
  {  9763872523711218805u,  5689135844565021195u,         152168271536u },
  { 15875699078454059311u,  3104061965171139312u,         164431250840u },
  { 10966529452671276106u,  7955173880156328015u,          95078343332u },
  { 18073244132105736913u,  1445179403240833753u,         233679697247u },
  {  4435241176994913173u, 12538201164459126714u,         173410945513u },
  {  5464400086219074323u,  7580606719088482666u,          70442805421u },
  {  2445909179323258812u,  8168318283218819754u,          49284582214u },
  {   873962058644121211u,  5249615277755961675u,         143342228273u },
  { 16675872194112650857u,  6312997372068219830u,          58497855631u },
  { 10680102689274800355u,  9183815417025176702u,          74579172666u },
  {  2370498083108897524u, 10683849953373876936u,          43931059274u },
  { 15354400521451334666u, 17175012155615667567u,          49975972139u },
  {   259991949657381021u, 18003508288378896911u,         112798111281u },
  { 10335286558772966917u, 14722554560950996950u,              1167984u },
  { 16337526653906757263u,    21545516652742137u,                    0u },
  { 12040967163702784894u,             21545516u,                    0u },
  {                    1u,                    0u,         108816367616u },
  {  3373309160242342187u, 15059324482416394929u,          62224146796u },
  { 13639841054510584221u,  4134778595813308311u,          82884769598u },
  { 15898855427739708031u, 16321118342639660947u,         185082591826u },
  {  4544387940067005419u,  1523550293123468804u,           7434568377u },
  {  5281598644835398575u,  8016371634569878508u,         105535824647u },
  { 13675642405083408835u,  9884220139611134109u,         180391292521u },
  {  3973392623768015721u,  7218073002727840413u,         243870735540u },
  {  4491285101509114191u, 16062235669481359232u,          19843403507u },
  { 15002304272810270500u, 15558048660560338001u,         102455061267u },
  { 17325098540619893468u,  8394398745765058608u,          14308634214u },
  {  1137212864974584822u,  5693296366442904273u,            638784526u },
  {  2619406097224859078u, 11783494675061161357u,          51725184512u },
  {  8281347529729293732u, 13377293110865447893u,          91696097587u },
  { 11344719666795450104u, 12840734051093062129u,         218380005723u },
  { 17283870506679425783u,  7009868331566697504u,         156272117978u },
  { 11054210518010603775u,  5019690705031194476u,         115466655644u },
  {  6399455551799092885u,  8608277240439804983u,          68659871603u },
  { 12930529916573967170u, 12172482590657749221u,          89900618820u },
  { 14550097052337552404u, 16613484892678771989u,         217310162521u },
  { 12487632712206414748u,  5721488662757049243u,          81020975577u },
  {  5791017277843595715u,   386931106438877038u,          76545051729u },
  { 10227264183449036113u, 10054429752182825658u,                   76u },
  {  2006055278511721441u,        1412006979354u,                    0u },
  {   128746359043876333u,                 1412u,                    0u },
  {                    1u,                    0u,         253468082176u },
  {  7408146306870995754u,  8634592106137071312u,          97684476157u },
  {  8299024588195267962u, 12626356501369830730u,         128260389217u },
  {  1497052939192040881u,  4803333258178976932u,          36737966720u },
  { 16771714264265803747u, 13613083223558209296u,          63873160484u },
  {   142988846654429432u, 16106967997237446988u,          43804094271u },
  { 11839838367716104145u, 14832921244380020169u,          43746691371u },
  {  6019646776647679765u, 13774024637717231396u,         232524375083u },
  {  4611972391702034948u,  9673012968505228884u,         233292291816u },
  { 16447182322205429545u,  5391832334264815666u,         126895249385u },
  {  2113477168726764245u, 16514436292632703087u,           2651878526u },
  {  3536261187802311516u, 12025036352783454152u,         135382716162u },
  { 18444381860986709854u,  7059867105311401049u,         165692220295u },
  {  4734315730275909838u, 12769210631552594669u,          51451509157u },
  {  9974936316849658174u,  8328873878884556144u,          72055108147u },
  { 11864423681540657642u,  1016565892414238684u,         169523831112u },
  {  8207245621417902667u,  9662978461927250280u,         118744303017u },
  {  7992526918695295028u, 13729967277551868111u,         237345404790u },
  {  8679354522130259987u,  6371593776693359474u,         142955030765u },
  {  6065763799692166461u, 17617208110845643244u,         102811035278u },
  { 18143341109049024976u, 14960960225633086796u,          94655434598u },
  { 15242492331283350570u, 12090634301321662557u,         136510113118u },
  {  9986352353182266963u,  9409926148478635502u,              5016456u },
  { 17340463289911536077u,    92537289398950870u,                    0u },
  {  7359344614214233035u,             92537289u,                    0u },
  {                    1u,                    0u,         212233486336u },
  {   419091135888749535u,  4307062684900157135u,          57829455828u },
  {  1073142712661309790u, 15300759383869911852u,         168867770169u },
  { 11076438902195672286u, 16007534237643445446u,         235386978984u },
  {  1820390940081322073u,  7138502295759677633u,         135445527787u },
  { 18417808973944523597u,  8218537071653683707u,         217122201479u },
  { 10251294197731582957u,  2254219416760329295u,          39165742553u },
  {  1502394029870156428u,  3057410459568460682u,          61445488423u },
  {   321014853559106075u,  8217810929938874369u,         211636487741u },
  {  2390953058510591778u, 11741126472498340928u,          47063714515u },
  { 10685224265907994087u,  1175325363726654804u,         225511138607u },
  {  5967405799190505023u,  9428843070696730899u,         249686435553u },
  { 11210723659228214761u, 12662500978715131895u,          53349278201u },
  { 12327123641078462773u,  6443045597035184563u,         150104158517u },
  {  1709976940107894237u,  1921385512639171182u,          27567551382u },
  { 16607686590938553511u, 10469475094355551398u,          25795759643u },
  { 18332088094272679457u, 14679174489076953573u,         138642556441u },
  {  2946170632136780882u, 11853074234719825643u,         108448366218u },
  {  4824449494694383419u,  8270896886596139123u,         124896237676u },
  { 17008332258693407134u, 16532667046659118125u,         160008041596u },
  {  1773419466622750661u,   148341279888833482u,         202561867680u },
  {  3892343466023784379u, 10364629296397276040u,         150773344202u },
  { 12001571085575422796u, 14265682585545771670u,          72758493846u },
  { 12933506765500977582u, 13991741872911347877u,                  328u },
  { 11884830007749143734u,        6064523798049u,                    0u },
  {  9662368568096205337u,                 6064u,                    0u },
  {                    1u,                    0u,         197760516096u },
  { 16801499925276664442u, 14029045786848724432u,          87217159109u },
  { 10492407990787637084u,  4005878521026842340u,          38185849943u },
  {  7673849751013230269u,  3428326338640386487u,          17054752294u },
  {  6046724489853072367u,  1010001558294829379u,          14109074193u },
  {  3723941391207507903u,  2012063724327403417u,          72596156942u },
  { 16844122108860347659u, 10997154538851372611u,         110103961416u },
  { 10622020182694668027u,  1917749645489607897u,          11529300590u },
  {  8741198820686854862u,  9763872523711218804u,         240860623371u },
  {  6855480461211306807u, 15875699078454059310u,          79594496752u },
  { 10005708458011566304u, 10966529452671276105u,         217979752527u },
  {  8932093106442919061u, 18073244132105736912u,         186240434905u },
  {  9062763476260756743u,  4435241176994913172u,         106296225722u },
  { 13664977682032775521u,  5464400086219074322u,         170132593002u },
  {  1078499125430623453u,  2445909179323258811u,          75047377578u },
  {  6554586738078431161u,   873962058644121210u,         182904000843u },
  { 12177313698643242883u, 16675872194112650856u,         126578969526u },
  { 16615072271904633953u, 10680102689274800354u,         200128504958u },
  { 16375404983106569285u,  2370498083108897523u,         111832363720u },
  { 13552251831473522729u, 15354400521451334665u,          15014094191u },
  {  8330500218412111874u,   259991949657381020u,         214560277007u },
  {  7044338079053294004u, 10335286558772966916u,         249885659094u },
  {  2688849443046530184u, 16337526653906757262u,          44652742137u },
  {   855940991879596845u, 12040967163702784893u,             21545516u },
  {  7344363609485825662u,   397444631628981487u,                    0u },
  { 11602660525134634992u,            397444631u,                    0u },
  {                    1u,                    0u,         177182867456u },
  { 16945343208344873835u,  3373309160242342186u,         151739417265u },
  {  9617992661337889145u, 13639841054510584220u,         147861878679u },
  { 18280344933262742088u, 15898855427739708030u,           4246351763u },
  {  5179975582362777795u,  4544387940067005418u,         236286316036u },
  {  1798918997870037130u,  5281598644835398574u,         157741358060u },
  {  6327667344756325883u, 13675642405083408834u,         157215398045u },
  { 18380327574124007701u,  3973392623768015720u,         128243473053u },
  { 18015447557304295289u,  4491285101509114190u,          81813276544u },
  { 10315590748073249878u, 15002304272810270499u,          48939195473u },
  {  7697916092577993382u, 17325098540619893467u,         209061648432u },
  {  3124132817942110723u,  1137212864974584821u,         141141998289u },
  {  7448238998520507049u,  2619406097224859077u,         213448932749u },
  { 13892823322374205297u,  8281347529729293731u,         241614998485u },
  { 11042137840046332564u, 11344719666795450103u,          32936960497u },
  { 10513966307445593804u, 17283870506679425782u,         108599249952u },
  {  9388437460943526958u, 11054210518010603774u,          55346915180u },
  { 10967228614677896228u,  6399455551799092884u,         229700965431u },
  {  2310996671540235542u, 12930529916573967169u,          21788762341u },
  {  4989110555003898587u, 14550097052337552403u,         155676955925u },
  { 16271452421983657679u, 12487632712206414747u,         110313931675u },
  {  9523160181437090473u,  5791017277843595714u,         186554421102u },
  { 13137707423765072250u, 10227264183449036112u,          26108748474u },
  { 16846859744221860705u,  2006055278511721440u,         132006979354u },
  {  7767140033449795569u,   128746359043876332u,                 1412u },
  { 17169456915721160017u,       26046931378436u,                    0u },
  { 17180899661833327819u,                26046u,                    0u },
  {                    1u,                    0u,         208401596416u },
  { 17572520700934791416u,  7408146306870995753u,          74449891024u },
  { 17968798858233825417u,  8299024588195267961u,         164081155402u },
  { 15338423313945305609u,  1497052939192040880u,          16909196452u },
  { 17895321323836726301u, 16771714264265803746u,          76007751440u },
  {   814069333008965773u,   142988846654429431u,         201641838924u },
  {  7200328959852723947u, 11839838367716104144u,          36326325705u },
  {   759884557248133773u,  6019646776647679764u,          84250015524u },
  { 13410165861863974851u,  4611972391702034947u,          50891603540u },
  {  6278452420856351570u, 16447182322205429544u,         111114571826u },
  {  9072115382556676442u,  2113477168726764244u,         200191701103u },
  {  2755882551854926563u,  3536261187802311515u,          89999871944u },
  {  8496072611504649269u, 18444381860986709853u,         237256647769u },
  {  4122009033579215815u,  4734315730275909837u,         112540742381u },
  { 10222217724450527221u,  9974936316849658173u,         220643171696u },
  {  2064539481554006325u, 11864423681540657641u,         104444915676u },
  {  7935605886598063693u,  8207245621417902666u,         207433275752u },
  {  7805147585347548429u,  7992526918695295027u,         114470508751u },
  {  5709020905457661273u,  8679354522130259986u,         236328825714u },
  { 16257370307404906674u,  6065763799692166460u,          76983552492u },
  { 14971258192939373646u, 18143341109049024975u,          93826297164u },
  {  1133404845901376390u, 15242492331283350569u,         238541361245u },
  {  9460827548162822047u,  9986352353182266962u,         214940028398u },
  {  1273897659779791346u, 17340463289911536076u,         201398950870u },
  {  7833262224435092783u,  7359344614214233034u,             92537289u },
  {  3033420566713364587u,  1707011694817242694u,                    0u },
  { 15075466825360349103u,           1707011694u,                    0u },
  {                    1u,                    0u,         207022718976u },
  {  2484134775182816690u,   419091135888749534u,          44058175183u },
  { 18400539815335991277u,  1073142712661309789u,         198600454956u },
  {   485494064952118286u, 11076438902195672285u,         193098683590u },
  { 17577048805241314891u,  1820390940081322072u,         251998431425u },
  {  2863946907557583807u, 18417808973944523596u,          79555723771u },
  { 13045307417786230800u, 10251294197731582956u,         138081444943u },
  { 12032088871615097766u,  1502394029870156427u,           1017402250u },
  {  8848763446997690580u,   321014853559106074u,          64129613825u },
  { 10031289150307672684u,  2390953058510591777u,          84579247168u },
  { 11592215575498656563u, 10685224265907994086u,          19323493716u },
  { 15894436747956898388u,  5967405799190505022u,         247607734547u },
  {  2091546719588500923u, 11210723659228214760u,         179668254711u },
  {  5863809244813756109u, 12327123641078462772u,         110092698035u },
  { 11303008753675411245u,  1709976940107894236u,         166900304494u },
  { 13238426537506910532u, 16607686590938553510u,         229993784486u },
  { 17258458071023005565u, 18332088094272679456u,         235159712229u },
  {  8385733444777075179u,  2946170632136780881u,         115261533931u },
  {  9530757096163247300u,  4824449494694383418u,          45922023539u },
  { 14423000845391072217u, 17008332258693407133u,         202096137261u },
  { 10953140011159884311u,  1773419466622750660u,         136211004362u },
  { 12228340237948264127u,  3892343466023784378u,         150650606472u },
  { 11279134946966259189u, 12001571085575422795u,         165701126806u },
  { 14640097792684582651u, 12933506765500977581u,          33644277925u },
  {  6232313315128656728u, 11884830007749143733u,         176523798049u },
  { 16136121832933322088u,  9662368568096205336u,                 6064u },
  { 15074767079673358271u,      111870718431542u,                    0u },
  { 13252722804829281908u,               111870u,                    0u },
  {                    1u,                    0u,         208910811136u },
  {  7740175894281560509u, 16801499925276664441u,         228568794576u },
  { 15670495392425593226u, 10492407990787637083u,         183416000228u },
  { 15152257626756992778u,  7673849751013230268u,          67327793591u },
  {  4090073428152440422u,  6046724489853072366u,         153201875267u },
  { 14450327772834205584u,  3723941391207507902u,          67913121689u },
  {  4466091895542494216u, 16844122108860347658u,         217575820867u },
  { 10454115378553795377u, 10622020182694668026u,         116473861337u },
  {  2267817233475657788u,  8741198820686854861u,          46371636340u },
  {  5500455702636497521u,  6855480461211306806u,          73542410542u },
  { 15178768299492252549u, 10005708458011566303u,         208484209737u },
  {  7062359872332045590u,  8932093106442919060u,         148491293392u },
  { 12297347290027942576u,  9062763476260756742u,          18740779924u },
  {  8030124596941085588u, 13664977682032775520u,         187058465554u },
  {  6526656990996654843u,  1078499125430623452u,         122355324859u },
  {  6254287345256979850u,  6554586738078431160u,         104660133498u },
  {  6642007136244870032u, 12177313698643242882u,         226900704872u },
  {  2027592955437164718u, 16615072271904633952u,         243887712482u },
  {   942718349157325567u, 16375404983106569284u,           9734669043u },
  { 14617066671884002278u, 13552251831473522728u,         156451597321u },
  {  6831631114396133348u,  8330500218412111873u,           4381874332u },
  { 14603040013386939258u,  7044338079053294003u,         142145762820u },
  {  9906106765319401103u,  2688849443046530183u,         125046400654u },
  {  1396179595609933063u,   855940991879596844u,         239398138749u },
  { 11524884268464976417u,  7344363609485825661u,          23628981487u },
  {   382929570730827274u, 11602660525134634991u,            397444631u },
  {  6109721884461301381u,  7331559403129590068u,                    0u },
  {  2390514825000339691u,           7331559403u,                    0u },
  {  6116191454763441755u,                    7u,                    0u },
  {                    1u,                    0u,          42918608896u },
  { 11598868771099176310u, 16945343208344873834u,         156521392426u },
  { 14449966445520085105u,  9617992661337889144u,         126990979484u },
  { 11675595287405614726u, 18280344933262742087u,         234280807038u },
  { 15860796398550489897u,  5179975582362777794u,         174097519594u },
  { 16180408435245829662u,  1798918997870037129u,         194343023534u },
  { 13756992797154950706u,  6327667344756325882u,         104996399554u },
  {  8830551328786758466u, 18380327574124007700u,          78976619368u },
  { 16699955256560951264u, 18015447557304295288u,          35559209294u },
  { 10038983627153402074u, 10315590748073249877u,         219417304867u },
  { 15085100736692127346u,  7697916092577993381u,         245169359579u },
  { 10007783780289711125u,  3124132817942110722u,         197403769845u },
  { 17596907048353602192u,  7448238998520507048u,         163753131461u },
  { 13530650344896573509u, 13892823322374205296u,         247598595491u },
  {  6337724853398437005u, 11042137840046332563u,         246569963255u },
  { 12768885008904063297u, 10513966307445593803u,         254508948214u },
  {  2759773619512884114u,  9388437460943526957u,         148594534654u },
  {  8434364600126655292u, 10967228614677896227u,          65125279380u },
  {  3843827521199949338u,  2310996671540235541u,          19270460225u },
  {  4661660852957808994u,  4989110555003898586u,         155882077203u },
  { 15298044134177324417u, 16271452421983657678u,         194516251547u },
  {  7747773274913338217u,  9523160181437090472u,          80712196546u },
  { 10348785912020632966u, 13137707423765072249u,         224913270096u },
  {  4175372293197190170u, 16846859744221860704u,         236421057504u },
  { 11326064156813083145u,  7767140033449795568u,           4930758124u },
  {  8100407170505981763u, 17169456915721160016u,         190931378436u },
  {  1706556116319916846u, 17180899661833327818u,                26046u },
  { 15028897280749641942u,      480481077043500u,                    0u },
  {  1421201742071739121u,               480481u,                    0u },
  {                    1u,                    0u,          41952608256u },
  {  8480737406125178272u, 17572520700934791415u,         121974090537u },
  { 10947205650755620361u, 17968798858233825416u,         176831497593u },
  {   868577942165647781u, 15338423313945305608u,         226970107312u },
  { 16017710019091388479u, 17895321323836726300u,         247044130786u },
  {  6610879150827623375u,   814069333008965772u,         208390330615u },
  { 12110095866223762092u,  7200328959852723946u,          20041193424u },
  {  7756802952949470775u,   759884557248133772u,           3726966548u },
  {  2941800790804618759u, 13410165861863974850u,          40340355587u },
  { 11703600274199927522u,  6278452420856351569u,         212491800360u },
  {   806737539257940346u,  9072115382556676441u,          91149396692u },
  { 14579028397110132023u,  2755882551854926562u,          93460573019u },
  { 14247808875344366934u,  8496072611504649268u,         205223454557u },
  {  9713379923695279513u,  4122009033579215814u,          61554147533u },
  {  2246428675703313877u, 10222217724450527220u,         233111918909u },
  {  3549783776592680620u,  2064539481554006324u,          74430190057u },
  { 12645029747929213033u,  7935605886598063692u,          51423117898u },
  { 16279009267476580506u,  7805147585347548428u,          18309486643u },
  {   343358782242907186u,  5709020905457661272u,          60881313810u },
  { 10077054739085890321u, 16257370307404906673u,         207811593532u },
  { 10526715404712173586u, 14971258192939373645u,          41061441999u },
  { 11438715865125144243u,  1133404845901376389u,          82512872489u },
  {  5040916178827294801u,  9460827548162822046u,         204069058130u },
  { 16643761637275849508u,  1273897659779791345u,         202424641996u },
  {  4852542977279030386u,  7833262224435092782u,          70164442058u },
  {  7883373066544387129u,  3033420566713364586u,         110817242694u },
  { 16699064314768500978u, 15075466825360349102u,           1707011694u },
  {  6805863634444817214u, 13042063791413317777u,                    1u },
  {  2266540253968903500u,          31488807865u,                    0u },
  {  9016913589137908810u,                   31u,                    0u },
  {                    1u,                    0u,         222134665216u },
  { 11654451024602552034u,  2484134775182816689u,          93997495262u },
  {  5299013208454526793u, 18400539815335991276u,         221026318685u },
  { 14918550373926182540u,   485494064952118285u,          88952853725u },
  {  6225552657491071054u, 17577048805241314890u,          76155254872u },
  { 10344713496596235785u,  2863946907557583806u,         236707187532u },
  { 12972405634433280209u, 13045307417786230799u,         139652260844u },
  { 12911885282402784945u, 12032088871615097765u,          26479692427u },
  {  6934311832970995868u,  8848763446997690579u,          33543797274u },
  {  9975729197003430461u, 10031289150307672683u,         230628415265u },
  {  1982857556803548935u, 11592215575498656562u,          62861639142u },
  {  2095735223386298223u, 15894436747956898387u,         232113382974u },
  {  7110931538347639365u,  2091546719588500922u,          52317877736u },
  { 15822183724630969535u,  5863809244813756108u,         220612737332u },
  { 16931982690156327501u, 11303008753675411244u,         166717656540u },
  {  6740069226761666110u, 13238426537506910531u,          32935582886u },
  {  3138792961008474902u, 17258458071023005564u,          81454591520u },
  { 12154594426971851390u,  8385733444777075178u,          58516663377u },
  { 15780127219221910902u,  9530757096163247299u,         157781872442u },
  { 16421541930960194381u, 14423000845391072216u,         196593770909u },
  {  7485894627196740576u, 10953140011159884310u,         186662899652u },
  {  8897269432694476707u, 12228340237948264126u,          75611443130u },
  { 17189823634941678805u, 11279134946966259188u,         173793641291u },
  {  9585582064286255216u, 14640097792684582650u,         181337854381u },
  { 12835472279575022097u,  6232313315128656727u,          24874740917u },
  {  6776016669542754608u, 16136121832933322087u,          54817204760u },
  { 18340015775620871027u, 15074767079673358270u,         254718431542u },
  {  5254188752292365830u, 13252722804829281907u,               111870u },
  {  6798802596750151183u,     2063650512248692u,                    0u },
  {  9449320530215272000u,              2063650u,                    0u },
  {                    1u,                    0u,         121419595776u },
  { 17110720482574968811u,  7740175894281560508u,          91849499257u },
  { 16172441693558688213u, 15670495392425593225u,         188821405531u },
  {  6234654946353717320u, 15152257626756992777u,         238221723324u },
  { 11180283100679445438u,  4090073428152440421u,         190783353838u },
  { 14852260031176961272u, 14450327772834205583u,          10242107326u },
  {  4481533167346438750u,  4466091895542494215u,         250566718730u },
  {  4269718344362365664u, 10454115378553795376u,         205122938618u },
  { 11520029752381101466u,  2267817233475657787u,          54298180301u },
  { 16778682550309368417u,  5500455702636497520u,         223822842678u },
  {  9687587467301363608u, 15178768299492252548u,         148382851295u },
  { 10093971076828497318u,  7062359872332045589u,           6666640532u },
  {  1913763026490934696u, 12297347290027942575u,          96435313926u },
  { 12701450127613557000u,  8030124596941085587u,         220353810784u },
  {  8974572160711134644u,  6526656990996654842u,         184339045596u },
  {  9890000077336694124u,  6254287345256979849u,         130360063928u },
  {  4292326716201059148u,  6642007136244870031u,          96109916034u },
  { 14644519175104337420u,  2027592955437164717u,          68051104864u },
  {  5051178622270136798u,   942718349157325566u,          40792392772u },
  {   675983118348065839u, 14617066671884002277u,           1370343464u },
  {  4431647660065117244u,  6831631114396133347u,         179791632385u },
  {  8316115180008411962u, 14603040013386939257u,         135537011123u },
  {  9621158095544965602u,  9906106765319401102u,          44075687047u },
  { 15283478958951102072u,  1396179595609933062u,         125624765228u },
  { 13981553073094447813u, 11524884268464976416u,         239020758653u },
  {  4558368743929911607u,   382929570730827273u,          52331208687u },
  { 15217004469858477791u,  6109721884461301380u,         235129590068u },
  { 11589190369996515737u,  2390514825000339690u,           7331559403u },
  {  3670624237398152929u,  6116191454763441754u,                    7u },
  { 13471713758418039777u,         135243399970u,                    0u },
  {  4489936967610296411u,                  135u,                    0u },
  {                    1u,                    0u,         106628775936u },
  {  9052049303222747950u, 11598868771099176309u,         120783334250u },
  {  1011330006193020538u, 14449966445520085104u,          71632935288u },
  { 17412075644359478612u, 11675595287405614725u,         194859815495u },
  {  6358678384745980468u, 15860796398550489896u,         137877141698u },
  { 15262353928842850919u, 16180408435245829661u,         250745768073u },
  { 11145257686438581736u, 13756992797154950705u,          20478705146u },
  {  1600562031807691890u,  8830551328786758465u,         120905306388u },
  {  6775147337046626724u, 16699955256560951263u,          85544214392u },
  { 15772127322106297822u, 10038983627153402073u,         165817764949u },
  {  4141472200527441474u, 15085100736692127345u,           2542523045u },
  { 18246007807879281267u, 10007783780289711124u,         168953930242u },
  {   960746958654787123u, 17596907048353602191u,         112733498024u },
  { 11355981212264408477u, 13530650344896573508u,         147343568752u },
  {  1573078209576251481u,  6337724853398437004u,         203692202643u },
  {  6245294478780491367u, 12768885008904063296u,          45149607627u },
  {  7523292955659721510u,  2759773619512884113u,          35457227821u },
  { 14454736751015226505u,  8434364600126655291u,          21208374307u },
  {  7219786377781411316u,  3843827521199949337u,         218252709141u },
  { 10597123082209392431u,  4661660852957808993u,         206829308634u },
  {  6922353544343010714u, 15298044134177324416u,         168420007630u },
  { 14317523356293377430u,  7747773274913338216u,         121561008808u },
  {  4057766168681892717u, 10348785912020632965u,          96226347385u },
  { 15214083611901244045u,  4175372293197190169u,         240613987168u },
  {  8390569016883950721u, 11326064156813083144u,          80439123952u },
  { 10680472538208175055u,  8100407170505981762u,         202092512592u },
  { 12173567833130544927u,  1706556116319916845u,          44814718154u },
  {  1386341248286610026u, 15028897280749641941u,         225077043500u },
  { 12487300952797237352u,  1421201742071739120u,               480481u },
  {  2614759871804869720u,     8863311460481781u,                    0u },
  {  8494389567327729477u,              8863311u,                    0u },
  {                    1u,                    0u,         247459741696u },
  {  6260469580539185878u,  8480737406125178271u,         136593449207u },
  { 17818573101084525841u, 10947205650755620360u,           8047085704u },
  {  2201029069927307150u,   868577942165647780u,          28868321800u },
  { 10397997613804897039u, 16017710019091388478u,         140358376476u },
  { 14269915965770103741u,  6610879150827623374u,         234656489612u },
  { 16776139909196366727u, 12110095866223762091u,         140420497130u },
  {  6246513436385199720u,  7756802952949470774u,         194159475340u },
  {  2926026498821554288u,  2941800790804618758u,          81634453442u },
  { 15725499391028340982u, 11703600274199927521u,          89043733329u },
  {  8576577277771450827u,   806737539257940345u,         226790330713u },
  { 15523351176022259335u, 14579028397110132022u,          52772375266u },
  {  4775158829429176134u, 14247808875344366933u,         198526563380u },
  { 10141817222123532462u,  9713379923695279512u,         244121779142u },
  { 12847658900242624586u,  2246428675703313876u,          52192434164u },
  { 13708197964460514655u,  3549783776592680619u,          76685488436u },
  {  1951540006613246932u, 12645029747929213032u,          12882486860u },
  {  9979297327280092199u, 16279009267476580505u,          88018613516u },
  { 15381307706282553684u,   343358782242907185u,         177546278232u },
  { 10037428657543061177u, 10077054739085890320u,          77570654385u },
  {  2584877324547208668u, 10526715404712173585u,         133620094029u },
  {  1126624732730703576u, 11438715865125144242u,         158273268613u },
  {  1501064139624981020u,  5040916178827294800u,         241902260126u },
  {  5219661484955306109u, 16643761637275849507u,          46263056881u },
  {  5336997298570282212u,  4852542977279030385u,         106427358510u },
  { 12191131175733833362u,  7883373066544387128u,         174905258090u },
  {  3707068178994436536u, 16699064314768500977u,         145368946606u },
  {  5045484691732942022u,  6805863634444817213u,         185122869393u },
  { 14847900542908711232u,  2266540253968903499u,          31488807865u },
  {  9097257915916965135u,  9016913589137908809u,                   31u },
  {  2472027983230314217u,         580865979874u,                    0u },
  { 15974509111133272205u,                  580u,                    0u },
  {                    1u,                    0u,         177631789056u },
  { 12099486841948187399u, 11654451024602552033u,         236287260081u },
  {  5319910566029976328u,  5299013208454526792u,          13808736236u },
  { 11549214421017285864u, 14918550373926182539u,          74337487885u },
  {  1998791413186046700u,  6225552657491071053u,         190560788042u },
  { 17075171930090011210u, 10344713496596235784u,          15703235518u },
  { 15158296003813501474u, 12972405634433280208u,         165699954703u },
  {  1360083178079384115u, 12911885282402784944u,         211375909797u },
  {  6167980558592741158u,  6934311832970995867u,         107540785363u },
  {  3630180428124865653u,  9975729197003430460u,          50107490923u },
  {  2276550099763657677u,  1982857556803548934u,          83113610034u },
  {   407006713016100655u,  2095735223386298222u,         186385484371u },
  { 14242579061653496002u,  7110931538347639364u,         204857722298u },
  { 17944493332678643704u, 15822183724630969534u,          44917884620u },
  {   987185901870869452u, 16931982690156327500u,          67365379884u },
  {  5578665155415167745u,  6740069226761666109u,         124170154307u },
  {  4849210377429577536u,  3138792961008474901u,         234658901884u },
  { 10811995403388891862u, 12154594426971851389u,         195855442410u },
  {  7051931074990177294u, 15780127219221910901u,         216890213571u },
  {  2030832259446664275u, 16421541930960194380u,          22405811160u },
  {  6069512651054767896u,  7485894627196740575u,         190482321942u },
  { 10608701253763958799u,  8897269432694476706u,         244931862206u },
  { 15700053443426906717u, 17189823634941678804u,         250519635444u },
  { 17759719234725541222u,  9585582064286255215u,          87695812346u },
  { 15187321568916405210u, 12835472279575022096u,         103367328599u },
  { 11040156458113129594u,  6776016669542754607u,         190994214247u },
  {  2800727824598008497u, 18340015775620871026u,         115284830142u },
  {  2997236166375604479u,  5254188752292365829u,         116368563827u },
  {  6260091886451512841u,  6798802596750151182u,          34512248692u },
  { 17573059315228347474u,  9449320530215271999u,              2063650u },
  {  7519453664590169251u,    38067632857031246u,                    0u },
  { 15809436065653866529u,             38067632u,                    0u },
  {                    1u,                    0u,         188927574016u },
  {   228921437623588922u, 17110720482574968810u,         137876709820u },
  {  2195862230003073884u, 16172441693558688212u,           9337981321u },
  {   960207412233973688u,  6234654946353717319u,         101606084361u },
  {  2464387149230492479u, 11180283100679445437u,         143805142629u },
  {  3631866936444955213u, 14852260031176961271u,           7242944399u },
  {  1578304441149380227u,  4481533167346438749u,          48231461895u },
  { 18190538519673445181u,  4269718344362365663u,          59624502064u },
  {  1271000736479934749u, 11520029752381101465u,         112909574203u },
  { 18292963032817745634u, 16778682550309368416u,         132525165168u },
  { 17168014021925537455u,  9687587467301363607u,          21547195268u },
  { 18046757712870378949u, 10093971076828497317u,         175103745301u },
  { 14857998893911743220u,  1913763026490934695u,         147688546991u },
  { 11933607369968684575u, 12701450127613556999u,         250486512531u },
  {  3483798509902859162u,  8974572160711134643u,         137536137978u },
  {  7378828438829845831u,  9890000077336694123u,         143232687497u },
  { 15791137430347699565u,  4292326716201059147u,         173793880975u },
  { 17044141236829932641u, 14644519175104337419u,         254273824941u },
  {  9075651910862456484u,  5051178622270136797u,         229036645118u },
  { 17811207355884564095u,   675983118348065838u,         227240240101u },
  {  4438638126207305937u,  4431647660065117243u,         121450817507u },
  { 12507972635512950185u,  8316115180008411961u,         142521564025u },
  { 14658269128098109408u,  9621158095544965601u,           6828519054u },
  {  3642436268910286111u, 15283478958951102071u,          32757941510u },
  {  3783099432964819561u, 13981553073094447812u,           9247109664u },
  {  9497579866027539638u,  4558368743929911606u,         132824915465u },
  {  3395179445046271361u, 15217004469858477790u,         234628251268u },
  {  5938502732309497276u, 11589190369996515736u,          90198984938u },
  {  5793671185917606255u,  3670624237398152928u,          34730303066u },
  {   889272970253526588u, 13471713758418039776u,         135243399970u },
  {  8594177504370135501u,  4489936967610296410u,                  135u },
  {  7374354721120724712u,        2494800386918u,                    0u },
  { 14764532643665507567u,                 2494u,                    0u },
  {                    1u,                    0u,         117490712576u },
  {  5392404173658087695u,  9052049303222747949u,         112054824309u },
  {  4976586473237854316u,  1011330006193020537u,         133943910512u },
  {  6308932742419013569u, 17412075644359478611u,          40344704645u },
  {  4831846642430703059u,  6358678384745980467u,          29827373864u },
  { 18139507855949846901u, 15262353928842850918u,          49604185629u },
  {  4865833876326628410u, 11145257686438581735u,          65086766641u },
  { 14296661839130179261u,  1600562031807691889u,         223367281473u },
  {  9254773150378118248u,  6775147337046626723u,         217855008735u },
  { 12174712433727875143u, 15772127322106297821u,         113224509657u },
  {   705653145340915199u,  4141472200527441473u,          20989118065u },
  { 17763928858962481812u, 18246007807879281266u,         143052082196u },
  {  3982836567612046296u,   960746958654787122u,          68615608975u },
  { 12730849277561967739u, 11355981212264408476u,         140085276740u },
  { 17314488764367235908u,  1573078209576251480u,          64338558092u },
  { 15951418930590301119u,  6245294478780491366u,         145407838528u },
  {  7193356087283467261u,  7523292955659721509u,          59783592849u },
  { 17592945625696089446u, 14454736751015226504u,          25391385403u },
  {  3554461664875361428u,  7219786377781411315u,          97574471193u },
  {  2213779057785318208u, 10597123082209392430u,         128375261537u },
  {  3880940796082421148u,  6922353544343010713u,         104776154496u },
  {  4528237545358141043u, 14317523356293377429u,         133219971944u },
  { 11681196539088147363u,  4057766168681892716u,          25824757125u },
  {  9835005502912643017u, 15214083611901244044u,           8454853657u },
  {  4964088126040986696u,  8390569016883950720u,          66578989576u },
  {  3355564873147047622u, 10680472538208175054u,          45659930434u },
  {  1853093467828272927u, 12173567833130544926u,         213075153709u },
  { 14755341584803008677u,  1386341248286610025u,         240676937941u },
  {  4701571132542556621u, 12487300952797237351u,         245141746416u },
  {  6128849686644853851u,  2614759871804869719u,          79460481781u },
  { 12026867901170202094u,  8494389567327729476u,              8863311u },
  { 17909760324981426303u,   163499238157084246u,                    0u },
  {  2897692901883393664u,            163499238u,                    0u },
  {                    1u,                    0u,         159339380736u },
  { 12323704802554838154u,  6260469580539185877u,           8965946783u },
  {  7135886931147821732u, 17818573101084525840u,         164119318024u },
  { 15341283120292884947u,  2201029069927307149u,          62563676580u },
  {  3092789040392634166u, 10397997613804897038u,         206773573694u },
  {  8811761390822097865u, 14269915965770103740u,         171909436366u },
  { 16870860798610218169u, 16776139909196366726u,          54338624171u },
  { 17452041453591904833u,  6246513436385199719u,           6158620214u },
  { 10314783684009874908u,  2926026498821554287u,         225852481030u },
  {  4932636630789274903u, 15725499391028340981u,         121464937185u },
  { 18143884346082124480u,  8576577277771450826u,          54841522553u },
  {  2823209155405527322u, 15523351176022259334u,          85258861878u },
  { 16195396106620226251u,  4775158829429176133u,         152549789013u },
  {  1150544491807648944u, 10141817222123532461u,         212696472984u },
  {  7767455475523884824u, 12847658900242624585u,         171743122900u },
  { 15204378045683991808u, 13708197964460514654u,         104105793195u },
  { 17239732561718805622u,  1951540006613246931u,         153540978792u },
  { 12886430624522800062u,  9979297327280092198u,          49833822361u },
  { 18162250541178258136u, 15381307706282553683u,          16544130097u },
  { 17028935366700158084u, 10037428657543061176u,          17140126480u },
  { 16075467823964198637u,  2584877324547208667u,         178061074449u },
  {  9803858825574498304u,  1126624732730703575u,          80081372850u },
  { 17464070808143041817u,  1501064139624981019u,          35282958416u },
  { 17682703471239266776u,  5219661484955306108u,         113289319203u },
  { 18147688354161351336u,  5336997298570282211u,          56660882545u },
  {  6663423873348080051u, 12191131175733833361u,         241200960568u },
  {  9417270363716235133u,  3707068178994436535u,          61273516273u },
  {  9295013721571344179u,  5045484691732942021u,          75804906301u },
  {  6199479138350037783u, 14847900542908711231u,          73493163339u },
  {   887603005365085688u,  9097257915916965134u,         226134008905u },
  {   333989628642975696u,  2472027983230314216u,          68865979874u },
  {  4620735991403939439u, 15974509111133272204u,                  580u },
  { 12418523063962801201u,       10715086071862u,                    0u },
  {  1587745622680169419u,                10715u,                    0u },
  {                    1u,                    0u,         225655914496u },
  { 10968905082284365638u, 12099486841948187398u,          72288392929u },
  { 14076907092801977812u,  5319910566029976327u,         139626084168u },
  {  3438322122816124202u, 11549214421017285863u,          77108354699u },
  { 14645413324829073676u,  1998791413186046699u,           8925646925u },
  { 12271281439492289999u, 17075171930090011209u,         208821732872u },
  {  6233751789862708246u, 15158296003813501473u,         176073730256u },
  {  1962644459455827991u,  1360083178079384114u,         155334366896u },
  {  8726934184642952500u,  6167980558592741157u,          60196792475u },
  {  4531087719737475147u,  3630180428124865652u,           6123412028u },
  {   481513520412720775u,  2276550099763657676u,         110022063878u },
  {   992149349835802669u,   407006713016100654u,          68772091758u },
  { 11165474436676191361u, 14242579061653496001u,         190972772932u },
  { 10240785855143707184u, 17944493332678643703u,          76053515454u },
  { 10059329918238932466u,   987185901870869451u,          61302420044u },
  { 14791716450947031886u,  5578665155415167744u,          21262876221u },
  { 15378882314737417403u,  4849210377429577535u,         125586119445u },
  { 14726970229242271128u, 10811995403388891861u,         117382285949u },
  {  5090110549507128156u,  7051931074990177293u,          76110091637u },
  { 17185220781106503841u,  2030832259446664274u,         223329028940u },
  {  9858517691519529306u,  6069512651054767895u,         162575098847u },
  {  5595905546638020703u, 10608701253763958798u,         212851101602u },
  { 15555173226968030256u, 15700053443426906716u,         111962756308u },
  { 10745236628845355771u, 17759719234725541221u,          16823306351u },
  {  9973314042399760760u, 15187321568916405209u,          47598488080u },
  {  4374506813558796576u, 11040156458113129593u,         114151827759u },
  { 15960826480426749933u,  2800727824598008496u,           5162480498u },
  {  9636454862798615738u,  2997236166375604478u,          14339360261u },
  { 17973331528911319269u,  6260091886451512840u,          63952637454u },
  {  7366495200039369602u, 17573059315228347473u,          78407630399u },
  { 10505831326526933399u,  7519453664590169250u,         176857031246u },
  {  2803218632575724145u, 15809436065653866528u,             38067632u },
  {  8425731874431741636u,   702223880805592151u,                    0u },
  { 14860552245711912111u,            702223880u,                    0u },
  {                    1u,                    0u,         234012409856u },
  {  6993664200669526994u,   228921437623588921u,         212119037930u },
  {  4065363582031999356u,  2195862230003073883u,          71052052948u },
  {  6899780515342669867u,   960207412233973687u,         189133594695u },
  { 17713500890201844939u,  2464387149230492478u,         247196883901u },
  {  6445781125105107086u,  3631866936444955212u,          93085560055u },
  { 13563044070717478571u,  1578304441149380226u,         223986111069u },
  { 13167612994149348885u, 18190538519673445180u,         153068901087u },
  {  5505463469596727288u,  1271000736479934748u,          96991663513u },
  { 12125446212518819372u, 18292963032817745633u,         151930679904u },
  { 12537707724735421794u, 17168014021925537454u,         165978316695u },
  { 15173675086703777069u, 18046757712870378948u,         167805453733u },
  { 13535510174093048476u, 14857998893911743219u,           7646922151u },
  { 10698912997087096629u, 11933607369968684574u,         179188857095u },
  { 16952559548431933861u,  3483798509902859161u,         107400007091u },
  { 13528255827744249993u,  7378828438829845830u,          75856039275u },
  { 14122167436324771955u, 15791137430347699564u,          11923964747u },
  { 13071007137740038297u, 17044141236829932640u,         221491992075u },
  { 13011887609328904025u,  9075651910862456483u,          46965547485u },
  {  3116434332871336590u, 17811207355884564094u,          59240619054u },
  {  9050993820536772770u,  4438638126207305936u,          57678058555u },
  { 11993719123438634238u, 12507972635512950184u,         225794626361u },
  {  1414857165879849301u, 14658269128098109407u,         119197456865u },
  { 13819438220812375094u,  3642436268910286110u,         196205082231u },
  {  6073063033888264440u,  3783099432964819560u,          54514864836u },
  {  6828883869150720294u,  9497579866027539637u,         222184053046u },
  {  4548265621068768345u,  3395179445046271360u,         152321926878u },
  { 10422524923581371874u,  5938502732309497275u,         224314075544u },
  {  1858996082510682634u,  5793671185917606254u,         224048207584u },
  {   890276727450878316u,   889272970253526587u,          90465891296u },
  {  3886008133802710905u,  8594177504370135500u,         102399764570u },
  {   612074409233016757u,  7374354721120724711u,         190800386918u },
  {  3927020336901729264u, 14764532643665507566u,                 2494u },
  {  5298603480094474942u,       46020944252475u,                    0u },
  { 17418383752590430025u,                46020u,                    0u },
  {                    1u,                    0u,          45292322816u },
  {  8973799690601597929u,  5392404173658087694u,         121269781293u },
  {  1343055462055792431u,  4976586473237854315u,          83342007929u },
  { 17425118728683169659u,  6308932742419013568u,          51261934931u },
  { 18389781726026675967u,  4831846642430703058u,         102983344691u },
  {   272526939565961561u, 18139507855949846900u,         231263777382u },
  { 11293026845930963228u,  4865833876326628409u,         113775023591u },
  { 13997416438903902597u, 14296661839130179260u,         163501702257u },
  {  6186605805999441184u,  9254773150378118247u,         221659992483u },
  {  4401776373281836138u, 12174712433727875142u,          65038253533u },
  { 16338917089754547008u,   705653145340915198u,         114962984513u },
  { 13337700757935003056u, 17763928858962481811u,          50215910002u },
  { 14612496890816348693u,  3982836567612046295u,         156690140722u },
  {  3219935399907691719u, 12730849277561967738u,          88938620316u },
  { 10887238730052330387u, 17314488764367235907u,         102864728152u },
  {   360256418697768294u, 15951418930590301118u,          37389952614u },
  {   321440824631118565u,  7193356087283467260u,         136953715493u },
  { 10069228080701402580u, 17592945625696089445u,         243192687752u },
  {  9428069607611622975u,  3554461664875361427u,          46120009203u },
  { 14736799017468812344u,  2213779057785318207u,         153210386222u },
  { 10875332567307979280u,  3880940796082421147u,         149245476249u },
  {  4611492910339012807u,  4528237545358141042u,         108633238933u },
  { 10743508637597314786u, 11681196539088147362u,         140533156716u },
  {  9356196315668016028u,  9835005502912643016u,         128269103756u },
  { 15755598617722189347u,  4964088126040986695u,         206181905536u },
  {  1275276394173375542u,  3355564873147047621u,          30100456398u },
  { 12644999363867216251u,  1853093467828272926u,         105799888670u },
  {  4553830511509832021u, 14755341584803008676u,         103254872681u },
  {  8869400642218174412u,  4701571132542556620u,          87332245607u },
  { 16570849151159054040u,  6128849686644853850u,          68651977815u },
  { 16127119334101797673u, 12026867901170202093u,          86970890052u },
  {  9686867250420930550u, 17909760324981426302u,         230157084246u },
  { 10678226869774428035u,  2897692901883393663u,            163499238u },
  {  7767227962910162068u,  3016028602530220424u,                    0u },
  {  9780840471948993674u,           3016028602u,                    0u },
  {                    1u,                    0u,         213668069376u },
  {  6288709332106746357u, 12323704802554838153u,          16386837205u },
  {  9066785620141948673u,  7135886931147821731u,         141831652624u },
  {  8442375916704414909u, 15341283120292884946u,          14167660429u },
  { 11604629218100425803u,  3092789040392634165u,         188477686542u },
  {  3877248044010875762u,  8811761390822097864u,         134914571196u },
  { 16435137704395217283u, 16870860798610218168u,         103946077062u },
  { 14994442577577813271u, 17452041453591904832u,         111559165543u },
  {  4410105917142436089u, 10314783684009874907u,         245267398767u },
  {  4632574728444936970u,  4932636630789274902u,         202983581941u },
  {  9117147535650050359u, 18143884346082124479u,         134153046474u },
  {   588939301256904809u,  2823209155405527321u,          69877954182u },
  {   324393982565305683u, 16195396106620226250u,         173062371141u },
  {  9380909186923521175u,  1150544491807648943u,          73421074605u },
  {  4463385697777230217u,  7767455475523884823u,          94824230985u },
  { 16378985502426333808u, 15204378045683991807u,         211934567774u },
  { 18210894922387834354u, 17239732561718805621u,          38698574803u },
  {  1555748035329493205u, 12886430624522800061u,          83984577574u },
  {  4277055533891898507u, 18162250541178258135u,         184923140435u },
  { 11574429772510874408u, 17028935366700158083u,         219871452856u },
  { 17391099253493808815u, 16075467823964198636u,         215531468251u },
  {  5791212393959129882u,  9803858825574498303u,          27946729175u },
  { 11254268231455680880u, 17464070808143041816u,         124958581275u },
  { 16355477587312235322u, 17682703471239266775u,         227983788156u },
  {  2411485149249320633u, 18147688354161351335u,         145361224931u },
  { 12763114642070638360u,  6663423873348080050u,         183510511249u },
  {  1147543073987366419u,  9417270363716235132u,         197503883703u },
  {  8410777835225272692u,  9295013721571344178u,          63336074437u },
  {  8134725822306818018u,  6199479138350037782u,          14048117055u },
  {  8899607004752328377u,   887603005365085687u,         232018105614u },
  {   690976506652396830u,   333989628642975695u,         140250490600u },
  { 12281570945595192074u,  4620735991403939438u,          54673209484u },
  { 12592957291365552899u, 12418523063962801200u,         219086071862u },
  { 13595807339013970272u,  1587745622680169418u,                10715u },
  {  9698096389749839992u,      197658450495420u,                    0u },
  {  8310173728816391804u,               197658u,                    0u },
};

inline constexpr int __TABLE_SIZE_2 = 69;
inline constexpr int __ADDITIONAL_BITS_2 = 120;

inline constexpr uint16_t __POW10_OFFSET_2[__TABLE_SIZE_2] = {
     0,    2,    6,   12,   20,   29,   40,   52,   66,   80,
    95,  112,  130,  150,  170,  192,  215,  240,  265,  292,
   320,  350,  381,  413,  446,  480,  516,  552,  590,  629,
   670,  712,  755,  799,  845,  892,  940,  989, 1040, 1092,
  1145, 1199, 1254, 1311, 1369, 1428, 1488, 1550, 1613, 1678,
  1743, 1810, 1878, 1947, 2017, 2088, 2161, 2235, 2311, 2387,
  2465, 2544, 2625, 2706, 2789, 2873, 2959, 3046, 3133
};

inline constexpr uint8_t __MIN_BLOCK_2[__TABLE_SIZE_2] = {
     0,    0,    0,    0,    0,    0,    1,    1,    2,    3,
     3,    4,    4,    5,    5,    6,    6,    7,    7,    8,
     8,    9,    9,   10,   11,   11,   12,   12,   13,   13,
    14,   14,   15,   15,   16,   16,   17,   17,   18,   19,
    19,   20,   20,   21,   21,   22,   22,   23,   23,   24,
    24,   25,   26,   26,   27,   27,   28,   28,   29,   29,
    30,   30,   31,   31,   32,   32,   33,   34,    0
};

inline constexpr uint64_t __POW10_SPLIT_2[3133][3] = {
  {                    0u,                    0u,              3906250u },
  {                    0u,                    0u,         202000000000u },
  {                    0u, 11153727427136454656u,                   59u },
  {                    0u,  7205759403792793600u,          59604644775u },
  {                    0u,                    0u,         167390625000u },
  {                    0u,                    0u,         232000000000u },
  {                    0u,    16777216000000000u,                    0u },
  {                    0u, 12945425605062557696u,               909494u },
  {                    0u,  4388757836872548352u,         182701772928u },
  {                    0u,  1152921504606846976u,         128237915039u },
  {                    0u,                    0u,         159062500000u },
  {                    0u,                    0u,         160000000000u },
  {                    0u,         256000000000u,                    0u },
  {                    0u, 16192327041775828992u,                   13u },
  {                    0u, 15024075324038053888u,          13877787807u },
  {                    0u,  5449091666327633920u,         159814456755u },
  {                    0u,  2494994193563254784u,         179295395851u },
  {                    0u,  4611686018427387904u,          11135253906u },
  {                    0u,                    0u,         146250000000u },
  {                    0u,                    0u,         128000000000u },
  {                    0u,              3906250u,                    0u },
  {                    0u,     3906250000000000u,                    0u },
  {                    0u,  4368439412768899072u,               211758u },
  {                    0u,  1563676642168012800u,          46236813575u },
  {                    0u, 11532349341402398720u,           7084767080u },
  {                    0u,  9048364970084925440u,         104625169910u },
  {                    0u, 16609275425742389248u,         246490512847u },
  {                    0u,                    0u,         207900390625u },
  {                    0u,                    0u,         225000000000u },
  { 11153727427136454656u,                   59u,                    0u },
  {  7205759403792793600u,          59604644775u,                    0u },
  {                    0u,  4264412554261970152u,                    3u },
  {                    0u, 14485570586272534528u,           3231174267u },
  {                    0u, 17827675094632103936u,         123785264354u },
  {                    0u,  7347197909193981952u,         226966440203u },
  {                    0u, 13677404030777688064u,          11398292396u },
  {                    0u,  3810326759732150272u,         172741453558u },
  {                    0u,  9943947977234055168u,         246206558227u },
  {                    0u,                    0u,          19539062500u },
  {                    0u,                    0u,         228000000000u },
  { 12945425605062557696u,               909494u,                    0u },
  {  4388757836872548352u,      909494701772928u,                    0u },
  {  1152921504606846976u, 14878706826214591391u,                49303u },
  {                    0u,  4387341015746028192u,         151806576313u },
  {                    0u,   651726680428265472u,         185237838233u },
  {                    0u,  2570638187944738816u,         153035330174u },
  {                    0u,  7419175577111756800u,         126139354575u },
  {                    0u, 17299322326264840192u,         207402194313u },
  {                    0u,  7990511638862102528u,         137937798142u },
  {                    0u, 16717361816799281152u,         254433166503u },
  {                    0u,                    0u,         167906250000u },
  {                    0u,                    0u,          16000000000u },
  { 16192327041775828992u,                   13u,                    0u },
  { 15024075324038053888u,          13877787807u,                    0u },
  {  5449091666327633920u, 13877787807814456755u,                    0u },
  {  2494994193563254784u,  9707857417284919307u,            752316384u },
  {  4611686018427387904u,  1844515466944871826u,         224526264005u },
  {                    0u, 15167599819856275072u,         197099991383u },
  {                    0u, 14830185305589481472u,          87822237233u },
  {                    0u,  6163721531743535104u,          49803945956u },
  {                    0u, 14122847407012052992u,         228334136013u },
  {                    0u,   335491783960035328u,         205765601092u },
  {                    0u,   941252322120433664u,          68018187046u },
  {                    0u, 11529215046068469760u,          38051025390u },
  {                    0u,                    0u,         238625000000u },
  {                    0u,                    0u,          64000000000u },
  {  4368439412768899072u,               211758u,                    0u },
  {  1563676642168012800u,      211758236813575u,                    0u },
  { 11532349341402398720u,  8061591463141767016u,                11479u },
  {  9048364970084925440u, 16628725344207857142u,         215437019748u },
  { 16609275425742389248u,  3555541870038531535u,         100901445007u },
  {                    0u, 18316647450161853665u,         143192746310u },
  {                    0u, 16709574568378075648u,          70992947447u },
  {                    0u,  7696022835795591168u,         247905827852u },
  {                    0u, 16664449640376041472u,          12417202233u },
  {                    0u,  3109186955116544000u,          57903381625u },
  {                    0u, 10515518101817131008u,         121168549362u },
  {                    0u,  9961962375743537152u,         242570047378u },
  {                    0u,  9223372036854775808u,         146540039062u },
  {                    0u,                    0u,         150500000000u },
  { 14485570586272534528u,           3231174267u,                    0u },
  { 17827675094632103936u,  3231174267785264354u,                    0u },
  {  7347197909193981952u,   748977172262750475u,            175162308u },
  { 13677404030777688064u, 15965033457315095468u,         196040602133u },
  {  3810326759732150272u, 16809402149066729206u,          21865466197u },
  {  9943947977234055168u,  7563769067065700371u,          85911239516u },
  {                    0u, 13550322810840051428u,          92410032742u },
  {                    0u,  8663209637545764864u,         102734564471u },
  {                    0u,  8969247575312957440u,         119469633535u },
  {                    0u,  6193172891660451840u,         255486223885u },
  {                    0u,  3427954273864908800u,          13335732575u },
  {                    0u, 10058367555266936832u,          95185829773u },
  {                    0u, 13907115649320091648u,         141545265197u },
  {                    0u,                    0u,          45753906250u },
  {                    0u,                    0u,          74000000000u },
  { 14878706826214591391u,                49303u,                    0u },
  {  4387341015746028192u,       49303806576313u,                    0u },
  {   651726680428265472u, 14106411361315920281u,                 2672u },
  {  2570638187944738816u,  3609034283485221502u,         112764710092u },
  {  7419175577111756800u,  9896072247338192335u,         204195646140u },
  { 17299322326264840192u,  8889095178479228297u,         188536467151u },
  {  7990511638862102528u,  3631796911038383102u,         207481878815u },
  { 16717361816799281152u,   898318840772166823u,          31196880105u },
  {                    0u, 17293677953982795024u,         233048697961u },
  {                    0u,  7353628266884669440u,         105937492160u },
  {                    0u,  2404693032470315008u,         192398640987u },
  {                    0u,  9191155893041889280u,          91130358670u },
  {                    0u,  6353946855033798656u,         142498253559u },
  {                    0u,  3767824038248841216u,         247344448149u },
  {                    0u,  7205759403792793600u,         149204254150u },
  {                    0u,                    0u,         198390625000u },
  {                    0u,                    0u,         232000000000u },
  {  9707857417284919307u,            752316384u,                    0u },
  {  1844515466944871826u,   752316384526264005u,                    0u },
  { 15167599819856275072u, 17063068157692817751u,             40783152u },
  { 14830185305589481472u,  5385330256507239985u,          48924990778u },
  {  6163721531743535104u,  3373050282752075748u,          58291939338u },
  { 14122847407012052992u,  4116064001262906061u,          10182853422u },
  {   335491783960035328u, 11306582046748043076u,          46223132276u },
  {   941252322120433664u, 17035410946089626406u,         116612931040u },
  { 11529215046068469760u, 15618595715183448558u,         224923491477u },
  {                    0u,  5141740092277295680u,         149846685770u },
  {                    0u, 16973644291514990592u,          74278734288u },
  {                    0u, 14625255268443750400u,         208920143100u },
  {                    0u, 14021170507320131584u,         252792836676u },
  {                    0u,  4451355232865091584u,          68760089176u },
  {                    0u, 12891553933348044800u,          88241308450u },
  {                    0u,  1152921504606846976u,          34698852539u },
  {                    0u,                    0u,         187062500000u },
  {                    0u,                    0u,         160000000000u },
  {  8061591463141767016u,                11479u,                    0u },
  { 16628725344207857142u,       11479437019748u,                    0u },
  {  3555541870038531535u,  5562205901560339855u,                  622u },
  { 18316647450161853665u,  2106077949367544134u,         110301527786u },
  { 16709574568378075648u,  7496855998374373623u,         234114170714u },
  {  7696022835795591168u,   229183437194837004u,          90406405378u },
  { 16664449640376041472u,   465169186276472889u,           2012424059u },
  {  3109186955116544000u,  2152980561625316473u,         123025216872u },
  { 10515518101817131008u,  2059790725449340402u,         104116713310u },
  {  9961962375743537152u, 17891190926410198930u,          94111661478u },
  {  9223372036854775808u,  9930696175609809814u,         166969883403u },
  {                    0u,  7276914261609005312u,          11538344118u },
  {                    0u, 10539762974036983808u,         182394482312u },
  {                    0u, 12851089458992250880u,         136571361695u },
  {                    0u,  9449311677678878720u,         159696658955u },
  {                    0u,  8699564697382289408u,          11512248212u },
  {                    0u,  4224376450473525248u,         148471604347u },
  {                    0u,  4611686018427387904u,         123229003906u },
  {                    0u,                    0u,         130250000000u },
  {                    0u,                    0u,         128000000000u },
  {   748977172262750475u,            175162308u,                    0u },
  { 15965033457315095468u,   175162308040602133u,                    0u },
  { 16809402149066729206u, 13756840147955779925u,              9495567u },
  {  7563769067065700371u, 13788447602092505948u,          15745759798u },
  { 13550322810840051428u,  4972540435632173670u,          54747473242u },
  {  8663209637545764864u,  2844874687533091959u,          90269561957u },
  {  8969247575312957440u, 15377573779532804095u,         101154220965u },
  {  6193172891660451840u, 17824715805091194381u,         165833619944u },
  {  3427954273864908800u, 18277569135638159711u,         232966279779u },
  { 10058367555266936832u,  4254645803379752845u,          99990829008u },
  { 13907115649320091648u,  2933643244178200621u,         208230644811u },
  {                    0u, 17188148801879487562u,          75159033118u },
  {                    0u, 11069762501163246592u,          30931771413u },
  {                    0u, 11676570643941818368u,          21600093027u },
  {                    0u, 17840016768744030208u,          99632988162u },
  {                    0u, 16463817321652158464u,           2967109246u },
  {                    0u,  6954191143357644800u,         126892505325u },
  {                    0u,  5080060379673919488u,         237376987457u },
  {                    0u,                    0u,          65275390625u },
  {                    0u,                    0u,         161000000000u },
  { 14106411361315920281u,                 2672u,                    0u },
  {  3609034283485221502u,        2672764710092u,                    0u },
  {  9896072247338192335u, 16433563478020213436u,                  144u },
  {  8889095178479228297u,  4194750497955655375u,         144890865261u },
  {  3631796911038383102u,  2691539602252904735u,         109227397880u },
  {   898318840772166823u,  3775467271962795241u,         248145908654u },
  { 17293677953982795024u, 16980212613224918121u,         174204668490u },
  {  7353628266884669440u,  4172857038337333440u,          74920499170u },
  {  2404693032470315008u,  5936867627376461659u,         226226211033u },
  {  9191155893041889280u, 17856837443266866062u,         217321838238u },
  {  6353946855033798656u,  8956297047799810807u,         158968021097u },
  {  3767824038248841216u, 15356974049716912789u,         105485521835u },
  {  7205759403792793600u,  6923608913322982854u,         171832503231u },
  {                    0u,  4855902993563955944u,         191375329591u },
  {                    0u, 13835893222288330752u,          55263239028u },
  {                    0u,  9114973913760137216u,         116750045274u },
  {                    0u, 17937099003422310400u,          90494123725u },
  {                    0u,  7007960010734960640u,         205972372085u },
  {                    0u,  7683422439270776832u,         117379902273u },
  {                    0u,   720575940379279360u,          65416519165u },
  {                    0u,                    0u,         253039062500u },
  {                    0u,                    0u,         228000000000u },
  { 17063068157692817751u,             40783152u,                    0u },
  {  5385330256507239985u,    40783152924990778u,                    0u },
  {  3373050282752075748u,  2768933352715741194u,              2210859u },
  {  4116064001262906061u, 15201941611824153390u,          43150104177u },
  { 11306582046748043076u,  1418128541727000180u,         113824098906u },
  { 17035410946089626406u,  5353350204565757408u,          90076876902u },
  { 15618595715183448558u,  1721001680354286741u,         102290205696u },
  {  5141740092277295680u,   637631411660453962u,             93295688u },
  { 16973644291514990592u,  1630012588870568400u,          72034566068u },
  { 14625255268443750400u,  9253063571656828156u,         180088363159u },
  { 14021170507320131584u,  6029146854993203780u,         151501609581u },
  {  4451355232865091584u, 16987401965352759896u,         109326840705u },
  { 12891553933348044800u, 14499131620542087970u,         129920888905u },
  {  1152921504606846976u,  1978417255298660539u,          73785999500u },
  {                    0u,  5790079354402454176u,         140107250214u },
  {                    0u, 13748918935842078720u,          38313880830u },
  {                    0u, 18047438014740692992u,         254745330388u },
  {                    0u,  3116889656839372800u,         212978353575u },
  {                    0u, 15995952446606147584u,         167168966926u },
  {                    0u, 12530140063251562496u,          14867142319u },
  {                    0u, 16717361816799281152u,         175679260253u },
  {                    0u,                    0u,          93906250000u },
  {                    0u,                    0u,          16000000000u },
  {  5562205901560339855u,                  622u,                    0u },
  {  2106077949367544134u,         622301527786u,                    0u },
  {  7496855998374373623u, 13558973353698967386u,                   33u },
  {   229183437194837004u,  6228991722850501890u,          33735033418u },
  {   465169186276472889u, 16886831391703377787u,          74337674317u },
  {  2152980561625316473u,  1181713637872883048u,          77915436964u },
  {  2059790725449340402u, 12393932434925221726u,         164064060824u },
  { 17891190926410198930u, 10684799845419711910u,         152671876423u },
  {  9930696175609809814u,  4590318792215640843u,          71579224160u },
  {  7276914261609005312u,  6383712187366189238u,          96248841680u },
  { 10539762974036983808u,  1904270214927675016u,         208346061731u },
  { 12851089458992250880u,  3711506775113308575u,         163103230695u },
  {  9449311677678878720u,  8091219444738793995u,         231201201185u },
  {  8699564697382289408u,    39436684991068052u,          33438625885u },
  {  4224376450473525248u, 18025182908196512891u,          93002137866u },
  {  4611686018427387904u,  7853924592034603138u,          10977147123u },
  {                    0u,  4815749283615688320u,         243425762105u },
  {                    0u, 14242399906544287744u,          57261062291u },
  {                    0u,    76242322576113664u,         147772082046u },
  {                    0u, 10858088421377703936u,         126004133104u },
  {                    0u, 14293835879041466368u,         240588618152u },
  {                    0u, 12182236992037191680u,         168774870395u },
  {                    0u, 11529215046068469760u,         123660400390u },
  {                    0u,                    0u,           6625000000u },
  {                    0u,                    0u,          64000000000u },
  { 13756840147955779925u,              9495567u,                    0u },
  { 13788447602092505948u,     9495567745759798u,                    0u },
  {  4972540435632173670u, 14000097438505379162u,               514755u },
  {  2844874687533091959u, 16451062686452429925u,         195758946802u },
  { 15377573779532804095u,  4009347599785716645u,         242891813895u },
  { 17824715805091194381u, 16544162347546196456u,           7217347168u },
  { 18277569135638159711u, 17674258299745817187u,          96896860837u },
  {  4254645803379752845u,  5215238411201214416u,         165958123462u },
  {  2933643244178200621u, 14253990228345322571u,         198282718640u },
  { 17188148801879487562u, 11214836553940194590u,         176772710358u },
  { 11069762501163246592u, 14620711348380590101u,         214607957507u },
  { 11676570643941818368u,  6638710787931587427u,           3792590350u },
  { 17840016768744030208u, 17320000343692853250u,          14359885232u },
  { 16463817321652158464u,    75147386268843646u,         176938919100u },
  {  6954191143357644800u, 17938801582125480173u,         188004073747u },
  {  5080060379673919488u,  6573358613626446145u,          19972464382u },
  {                    0u,  8688505427903736481u,         254356342484u },
  {                    0u,   539870168696556032u,         212471004823u },
  {                    0u,  9002861336394465280u,         151029266420u },
  {                    0u, 17989846818158018560u,         244488046090u },
  {                    0u,  2700938287723315200u,          10975231550u },
  {                    0u, 17800090499088908288u,          62146418157u },
  {                    0u,  8809040871136690176u,         237964944839u },
  {                    0u,  9223372036854775808u,         199477539062u },
  {                    0u,                    0u,         246500000000u },
  { 16433563478020213436u,                  144u,                    0u },
  {  4194750497955655375u,         144890865261u,                    0u },
  {  2691539602252904735u, 15763656745260536568u,                    7u },
  {  3775467271962795241u,  8787336846248645550u,           7854549544u },
  { 16980212613224918121u, 17584084447880694346u,          40476362484u },
  {  4172857038337333440u, 18041672551129683938u,         244953235127u },
  {  5936867627376461659u, 14025886302294509785u,         183978041028u },
  { 17856837443266866062u, 18430498103283160734u,         196760344819u },
  {  8956297047799810807u,  3292348826238025833u,         243999119304u },
  { 15356974049716912789u,  9211721212658275243u,         200178478587u },
  {  6923608913322982854u, 10233245872666307519u,         251499368407u },
  {  4855902993563955944u,  6200995035623311671u,         215554745370u },
  { 13835893222288330752u,  8480542380570450804u,          26336156614u },
  {  9114973913760137216u, 11870363864499900506u,         198459731123u },
  { 17937099003422310400u,  9301051379839581901u,         179643493714u },
  {  7007960010734960640u, 11456694803569638005u,          82504211005u },
  {  7683422439270776832u, 14327208890643983169u,          61621068669u },
  {   720575940379279360u,  4510081789599866365u,         125776679550u },
  {                    0u, 13255356976020303332u,         126244492023u },
  {                    0u,  9658806854127314944u,         247718574341u },
  {                    0u, 13708435528809971712u,           5523604968u },
  {                    0u,  1580190652103131136u,         232743135779u },
  {                    0u, 16557336970347413504u,          35085662306u },
  {                    0u, 12751520132434493440u,          98897575035u },
  {                    0u,  9295429630892703744u,         123691261291u },
  {                    0u,                    0u,         107503906250u },
  {                    0u,                    0u,         202000000000u },
  {  2768933352715741194u,              2210859u,                    0u },
  { 15201941611824153390u,     2210859150104177u,                    0u },
  {  1418128541727000180u, 16872870088062921306u,               119850u },
  {  5353350204565757408u,  5112979788807802982u,          42914680120u },
  {  1721001680354286741u, 13742728082020150272u,          56277175189u },
  {   637631411660453962u,  2217110934613627976u,         149744994782u },
  {  1630012588870568400u, 11021433940188610484u,         222120189824u },
  {  9253063571656828156u,  1713669895470733463u,         128597473131u },
  {  6029146854993203780u,  3313382510572018285u,         107092898231u },
  { 16987401965352759896u, 14976595232784069505u,         183179618825u },
  { 14499131620542087970u,  7213172372862496841u,           9811882854u },
  {  1978417255298660539u, 15836474542502248588u,         102391026857u },
  {  5790079354402454176u,  3221099285878340134u,         169858497005u },
  { 13748918935842078720u,  3265814602578095358u,         237174616142u },
  { 18047438014740692992u,  6502528252282225364u,          78177040164u },
  {  3116889656839372800u, 16392476834556790183u,          36352502762u },
  { 15995952446606147584u, 15167629413417091342u,         234888637949u },
  { 12530140063251562496u,  1366763272626280111u,         253822238838u },
  { 16717361816799281152u,  8720523635169216093u,         118074092385u },
  {                    0u,  9649171375767398672u,          97472740533u },
  {                    0u,  7647980704001073152u,         181523082628u },
  {                    0u, 13286434495608651776u,         132414597864u },
  {                    0u,  4358271637167013888u,         232720259057u },
  {                    0u, 15954987941890097152u,         241236262378u },
  {                    0u,  7911135695429697536u,         234864921629u },
  {                    0u,  7205759403792793600u,          29428863525u },
  {                    0u,                    0u,          37390625000u },
  {                    0u,                    0u,         232000000000u },
  { 13558973353698967386u,                   33u,                    0u },
  {  6228991722850501890u,          33735033418u,                    0u },
  { 16886831391703377787u, 15288289344628122701u,                    1u },
  {  1181713637872883048u,   952589339068938148u,           1828779826u },
  { 12393932434925221726u, 10058155040190817688u,          50051639971u },
  { 10684799845419711910u,  5322725640026584391u,         163545253677u },
  {  4590318792215640843u,  2269982385930389600u,          45288545535u },
  {  6383712187366189238u, 13216683679976310224u,         255123055991u },
  {  1904270214927675016u, 17417440642083494819u,         119716477857u },
  {  3711506775113308575u,  3029180749090900711u,         161944201349u },
  {  8091219444738793995u,  8315443826261908513u,         133164212217u },
  {    39436684991068052u,  1488962797247197277u,         249450781113u },
  { 18025182908196512891u, 18009099634999034122u,         185080716834u },
  {  7853924592034603138u,  8092455412807497971u,          34976275247u },
  {  4815749283615688320u, 17808458047236758329u,          47438692886u },
  { 14242399906544287744u,  3164591817527425171u,          22965398445u },
  {    76242322576113664u,  3314036340472350590u,         173171552866u },
  { 10858088421377703936u,    33234902404332784u,          98179654270u },
  { 14293835879041466368u, 12349284717857274280u,         126001801667u },
  { 12182236992037191680u, 18209607903013119355u,         195669456065u },
  { 11529215046068469760u,  7891549145984268038u,         193987144822u },
  {                    0u,  7703609897518594624u,         118427801736u },
  {                    0u,  6336912652634587136u,         136417613529u },
  {                    0u,  4461621834659397632u,         217343524723u },
  {                    0u,  5484660635557953536u,         115241865004u },
  {                    0u, 15142619273265938432u,          44297324048u },
  {                    0u, 12170977992968765440u,          16820883035u },
  {                    0u,  1152921504606846976u,          91659790039u },
  {                    0u,                    0u,         215062500000u },
  {                    0u,                    0u,         160000000000u },
  { 14000097438505379162u,               514755u,                    0u },
  { 16451062686452429925u,      514755758946802u,                    0u },
  {  4009347599785716645u, 17812314011563521031u,                27904u },
  { 16544162347546196456u,  7684138864490314336u,            965607477u },
  { 17674258299745817187u,  9740522787420029605u,          53416558002u },
  {  5215238411201214416u,  6701109407732989894u,         178528034798u },
  { 14253990228345322571u, 16534886227502443952u,         238363267868u },
  { 11214836553940194590u,  8908667306968317910u,          28896357978u },
  { 14620711348380590101u,  7531472173477105155u,          90482939822u },
  {  6638710787931587427u, 11527371604834801166u,         174408281924u },
  { 17320000343692853250u, 15688593496691078576u,          68624900066u },
  {    75147386268843646u, 11394944804253312188u,         226850480357u },
  { 17938801582125480173u, 11182279880854372627u,         229617721195u },
  {  6573358613626446145u,   150579373068361470u,         107606192607u },
  {  8688505427903736481u,  3147220002440857300u,         223008162924u },
  {   539870168696556032u,  3630514817795505815u,         108170611138u },
  {  9002861336394465280u, 11708796588334233588u,         194196810602u },
  { 17989846818158018560u, 16844495466426369546u,         106634735134u },
  {  2700938287723315200u, 17636655472325475902u,          30913141928u },
  { 17800090499088908288u, 17038926655686645229u,         168956085008u },
  {  8809040871136690176u, 15602838456783529415u,          16923682064u },
  {  9223372036854775808u, 10869815869248876790u,          16845831567u },
  {                    0u, 18407124180939800832u,         143589253898u },
  {                    0u,  5705018517251293184u,          10997852201u },
  {                    0u,  9660452258743058432u,          41309269673u },
  {                    0u,  5646292272224927744u,         169523694166u },
  {                    0u,  7410409304047484928u,          86306086117u },
  {                    0u,  5953758707383795712u,         229401719093u },
  {                    0u,  4611686018427387904u,          53322753906u },
  {                    0u,                    0u,         114250000000u },
  {                    0u,                    0u,         128000000000u },
  { 15763656745260536568u,                    7u,                    0u },
  {  8787336846248645550u,           7854549544u,                    0u },
  { 17584084447880694346u,  7854549544476362484u,                    0u },
  { 18041672551129683938u,    15035424419724983u,            425795984u },
  { 14025886302294509785u, 18280822466032836292u,         144000815071u },
  { 18430498103283160734u, 11524250747302615283u,         223991005371u },
  {  3292348826238025833u, 15212285943691810760u,         187624730884u },
  {  9211721212658275243u,  7951804027551297019u,           4824659673u },
  { 10233245872666307519u,  1706416229965221847u,         217431068160u },
  {  6200995035623311671u,  3406023111930700826u,             92505009u },
  {  8480542380570450804u, 16132696204133391302u,         177184640882u },
  { 11870363864499900506u, 11593846688794356915u,         114874555213u },
  {  9301051379839581901u,  6875759884161133906u,          77628503688u },
  { 11456694803569638005u,  3593593325323835965u,         136372735690u },
  { 14327208890643983169u,  9542049733257388925u,         202194809084u },
  {  4510081789599866365u,  9926551925937787518u,         252517275552u },
  { 13255356976020303332u,  3128491553219547895u,         160538119458u },
  {  9658806854127314944u, 17158408656931354885u,          34169595866u },
  { 13708435528809971712u,  2065169543154992616u,         218930159197u },
  {  1580190652103131136u,  4832622393556232739u,          93111953065u },
  { 16557336970347413504u, 16505930714733656162u,         169261976984u },
  { 12751520132434493440u, 18270988073492888699u,         152894788296u },
  {  9295429630892703744u,  2525111411519708523u,         200990472248u },
  {                    0u, 16728989342518570442u,          56136886563u },
  {                    0u,  7974052022039438336u,          35906880329u },
  {                    0u,  5356554962386550784u,          73432274226u },
  {                    0u,  6693869495028547584u,          50290379426u },
  {                    0u,  8157517147199766528u,         162362875392u },
  {                    0u, 12065776720423157760u,            442219890u },
  {                    0u, 11997589407315001344u,         114654087066u },
  {                    0u,                    0u,         154650390625u },
  {                    0u,                    0u,          97000000000u },
  { 16872870088062921306u,               119850u,                    0u },
  {  5112979788807802982u,      119850914680120u,                    0u },
  { 13742728082020150272u,  2418433229320326037u,                 6497u },
  {  2217110934613627976u,  1143911773589293534u,          97131103528u },
  { 11021433940188610484u,  9276183703610924928u,          40062011581u },
  {  1713669895470733463u,  3532180128827684715u,         189502862926u },
  {  3313382510572018285u,  8563997501322031543u,          78191479868u },
  { 14976595232784069505u, 14843890409658460681u,          60464255234u },
  {  7213172372862496841u,  9489417861634552678u,           2804688911u },
  { 15836474542502248588u,  1113198223322322089u,          15514422373u },
  {  3221099285878340134u, 11190777557146597869u,         101060346596u },
  {  3265814602578095358u, 17764553645932638286u,         228606653266u },
  {  6502528252282225364u, 14900777150991234852u,          82963018382u },
  { 16392476834556790183u, 17364899863357893610u,         142807772747u },
  { 15167629413417091342u, 15537570181590167037u,          75941353107u },
  {  1366763272626280111u,  5558052627121307766u,         147842293367u },
  {  8720523635169216093u, 12095241565795232609u,         119301302636u },
  {  9649171375767398672u,  2187936505958366389u,         108655684359u },
  {  7647980704001073152u, 12009203621325860228u,           7118608275u },
  { 13286434495608651776u, 14814842834750302952u,         147651020232u },
  {  4358271637167013888u,  5965296499605198833u,         200803114239u },
  { 15954987941890097152u,  4051026394962148842u,         255323379371u },
  {  7911135695429697536u, 16799526299141688349u,         171219606580u },
  {  7205759403792793600u,  9460214166646215205u,          52910704145u },
  {                    0u, 10750736995029068008u,          17512839237u },
  {                    0u,  5377963045376430080u,          69582798620u },
  {                    0u, 15996910350253424640u,          28291539960u },
  {                    0u, 13651157529655246848u,         248867194247u },
  {                    0u,  9771305410219737088u,         135740030732u },
  {                    0u, 12709439623416250368u,          12529703527u },
  {                    0u,  9943947977234055168u,         103688980102u },
  {                    0u,                    0u,         134539062500u },
  {                    0u,                    0u,         228000000000u },
  {   952589339068938148u,           1828779826u,                    0u },
  { 10058155040190817688u,  1828779826051639971u,                    0u },
  {  5322725640026584391u,   371564423966525229u,             99138353u },
  {  2269982385930389600u, 14464859121514339583u,          49020142547u },
  { 13216683679976310224u,  3913119023023056247u,         211784141584u },
  { 17417440642083494819u,  5493396321716566945u,          16212130607u },
  {  3029180749090900711u,  5837454566818211973u,          47297797611u },
  {  8315443826261908513u,  2886670683193253881u,         235316449046u },
  {  1488962797247197277u,  5504823105587173817u,          22156486731u },
  { 18009099634999034122u,  9431834277334851106u,          75298417058u },
  {  8092455412807497971u, 12921661346456247087u,         162511300760u },
  { 17808458047236758329u,  3643076516404724246u,         152700484665u },
  {  3164591817527425171u, 12559396953196866477u,          57197491573u },
  {  3314036340472350590u,  1626880974916825698u,         117680846273u },
  {    33234902404332784u,  6806994170946429566u,         193088193394u },
  { 12349284717857274280u,  7596631230206896579u,         114369007893u },
  { 18209607903013119355u,  3100480253729502401u,          21411814204u },
  {  7891549145984268038u,  6310570748781063286u,          60168077371u },
  {  7703609897518594624u, 14251867077375744136u,          59342096725u },
  {  6336912652634587136u,  6701165793751570137u,          85772595262u },
  {  4461621834659397632u, 10856833140463959923u,          62363270925u },
  {  5484660635557953536u, 15867563727561248556u,          13588550103u },
  { 15142619273265938432u,  5048961008671491600u,         215860182353u },
  { 12170977992968765440u, 13278183119599849051u,          81273704724u },
  {  1152921504606846976u,  4547591784941053655u,          20719811749u },
  {                    0u, 11815437715887182496u,         165246525444u },
  {                    0u,   398495392178782208u,           4640516162u },
  {                    0u,  9154841240825495552u,          66021602478u },
  {                    0u,  1902683298245640192u,         174496284938u },
  {                    0u,  5081900962138816512u,          10103144668u },
  {                    0u,  3234710432358858752u,         220275490403u },
  {                    0u, 16717361816799281152u,          99175354003u },
  {                    0u,                    0u,         147906250000u },
  {                    0u,                    0u,          16000000000u },
  { 17812314011563521031u,                27904u,                    0u },
  {  7684138864490314336u,       27904965607477u,                    0u },
  {  9740522787420029605u, 13488568028574514610u,                 1512u },
  {  6701109407732989894u,   275784718433886190u,         232731216738u },
  { 16534886227502443952u, 10020568880357102364u,          98014950319u },
  {  8908667306968317910u,  8876397213146246746u,         175543216127u },
  {  7531472173477105155u,  2155905919114811310u,         255481190457u },
  { 11527371604834801166u,  1087100407155601220u,          57116871894u },
  { 15688593496691078576u,  2903498381705011170u,         214058931831u },
  { 11394944804253312188u, 12223476257006657765u,         119157398962u },
  { 11182279880854372627u, 12148657163736735595u,         178662635975u },
  {   150579373068361470u,  8951241323311673823u,         199658580024u },
  {  3147220002440857300u,  8463862715901576300u,          56485247764u },
  {  3630514817795505815u,  3873401978748963266u,          20458826917u },
  { 11708796588334233588u,   248364795947002730u,         165209977542u },
  { 16844495466426369546u, 10454378025404001822u,         198013463882u },
  { 17636655472325475902u,  6574176865628265640u,          74566732968u },
  { 17038926655686645229u,    16703315293848336u,         168356386842u },
  { 15602838456783529415u,  9896033222450013456u,          26000905488u },
  { 10869815869248876790u, 17311376269334085007u,          16536465035u },
  { 18407124180939800832u, 18378511316495639306u,         139938451587u },
  {  5705018517251293184u, 15120796393727584297u,         131996301094u },
  {  9660452258743058432u, 18253447805740347049u,          38819700014u },
  {  5646292272224927744u,  5842497225601731158u,          46989521388u },
  {  7410409304047484928u,  4369968404176723173u,         236316722409u },
  {  5953758707383795712u, 16142207253674488117u,         233236896461u },
  {  4611686018427387904u, 12124259227391928178u,         205875070808u },
  {                    0u, 13019483264566077056u,          88657257409u },
  {                    0u,    74901376448135168u,         193705787602u },
  {                    0u, 13897060093813325824u,         210004060411u },
  {                    0u,  4495486210810052608u,         251753361137u },
  {                    0u, 14885496280087265280u,         241243700795u },
  {                    0u,  4976477588244398080u,          59806944370u },
  {                    0u, 11529215046068469760u,         114269775390u },
  {                    0u,                    0u,          30625000000u },
  {                    0u,                    0u,          64000000000u },
  {    15035424419724983u,            425795984u,                    0u },
  { 18280822466032836292u,   425795984000815071u,                    0u },
  { 11524250747302615283u, 10043594327130472635u,             23082446u },
  { 15212285943691810760u,  8336034337032909060u,         206544464339u },
  {  7951804027551297019u, 16717215784895280857u,         211451897326u },
  {  1706416229965221847u, 10968831263951212032u,         238906242083u },
  {  3406023111930700826u,  5536629379734406065u,          35594621534u },
  { 16132696204133391302u,  1618806894932332402u,          94300141280u },
  { 11593846688794356915u, 11363331325254998861u,         224087755697u },
  {  6875759884161133906u,  8775167772751754888u,         177616007425u },
  {  3593593325323835965u,  2898202945316114122u,           1475702798u },
  {  9542049733257388925u,  8868842714495185148u,          14157111896u },
  {  9926551925937787518u, 17052094667531999136u,          88480780926u },
  {  3128491553219547895u,  3658615537031138594u,         126924395904u },
  { 17158408656931354885u, 12486952437987190746u,         128198333945u },
  {  2065169543154992616u,   912079238520577629u,         249676919048u },
  {  4832622393556232739u, 10960072898031888041u,           8049443914u },
  { 16505930714733656162u,  6129550094334741912u,          74594146742u },
  { 18270988073492888699u,  7965724516573729480u,         182332283576u },
  {  2525111411519708523u,  5801761178810791992u,         184431822791u },
  { 16728989342518570442u, 13197466483098446115u,         199314514103u },
  {  7974052022039438336u, 11326268638393107273u,         183715436091u },
  {  5356554962386550784u,  3597339351794947378u,          59613998253u },
  {  6693869495028547584u,   353880726151383714u,         173195012157u },
  {  8157517147199766528u, 11154818162602073600u,          61019183912u },
  { 12065776720423157760u,  5141043976157511026u,          40604703904u },
  { 11997589407315001344u,  7188225141808859034u,         160278696552u },
  {                    0u, 13894168943295705185u,         104389674465u },
  {                    0u, 12176538069834828288u,         225753204407u },
  {                    0u,  7994239409235165184u,         183660091451u },
  {                    0u, 13707777025480065024u,          59433368586u },
  {                    0u, 10120227247676719104u,          10743100081u },
  {                    0u,  7358494763030413312u,         177548618618u },
  {                    0u,  7656119366529843200u,         122398904800u },
  {                    0u,  9223372036854775808u,         224415039062u },
  {                    0u,                    0u,          86500000000u },
  {  2418433229320326037u,                 6497u,                    0u },
  {  1143911773589293534u,        6497131103528u,                    0u },
  {  9276183703610924928u,  3877189582299842749u,                  352u },
  {  3532180128827684715u,  7625565791857948238u,          96210182868u },
  {  8563997501322031543u, 16568435163612007484u,         212413382749u },
  { 14843890409658460681u, 17592071940521808130u,          93898176669u },
  {  9489417861634552678u, 15158637878035490831u,         157953668130u },
  {  1113198223322322089u, 17789243229146401893u,          34821751405u },
  { 11190777557146597869u, 14677686051252896484u,         109964356807u },
  { 17764553645932638286u,  3531237481269211986u,         199795678955u },
  { 14900777150991234852u,  8074435404989280910u,         235191428767u },
  { 17364899863357893610u,  7086549341467684427u,         159437716020u },
  { 15537570181590167037u, 10556134770918626963u,          52384162609u },
  {  5558052627121307766u, 10772666134712966775u,          49572249212u },
  { 12095241565795232609u,  6195173298198112620u,         124583987401u },
  {  2187936505958366389u,  8144773843324250887u,         201335841017u },
  { 12009203621325860228u, 14144284817150924691u,         249441529074u },
  { 14814842834750302952u,  6464447844648863176u,         242766763216u },
  {  5965296499605198833u, 15760468443293179135u,         208350438419u },
  {  4051026394962148842u,  5172191224908322475u,          19854376706u },
  { 16799526299141688349u,  2357554307308969012u,           2280385048u },
  {  9460214166646215205u,  1602046917604361745u,          24127803275u },
  { 10750736995029068008u,  7830970218109515845u,         139086847137u },
  {  5377963045376430080u,  2899479134887821084u,         161424517746u },
  { 15996910350253424640u, 15792042302392017912u,         114157181078u },
  { 13651157529655246848u, 11286099112296056199u,         150856088328u },
  {  9771305410219737088u, 15161477829153947404u,           8611820658u },
  { 12709439623416250368u,   423831848142641767u,         114821905360u },
  {  9943947977234055168u,  9707413321046312582u,         208022975970u },
  {                    0u, 10969483299803835620u,         226526239930u },
  {                    0u,  4326479556120930304u,         186594656881u },
  {                    0u, 12876227232041795584u,         113234538926u },
  {                    0u, 16967986827791171584u,         174698021676u },
  {                    0u,  1288146316538413056u,          44919836409u },
  {                    0u, 13715290452691779584u,         249069830551u },
  {                    0u,  4683743612465315840u,         151743507385u },
  {                    0u,                    0u,         185253906250u },
  {                    0u,                    0u,          74000000000u },
  {   371564423966525229u,             99138353u,                    0u },
  { 14464859121514339583u,    99138353020142547u,                    0u },
  {  3913119023023056247u, 16344805304534272784u,              5374300u },
  {  5493396321716566945u,    26429987091348271u,          92886053671u },
  {  5837454566818211973u,  8691371289609838059u,          39001432772u },
  {  2886670683193253881u, 12980168378493046550u,         196471160181u },
  {  5504823105587173817u, 14010125458129496139u,         117703656337u },
  {  9431834277334851106u, 17061829677031795106u,         145759490422u },
  { 12921661346456247087u,  2227928323072698520u,         118924923640u },
  {  3643076516404724246u,  7394752319272287289u,         248120776236u },
  { 12559396953196866477u,  8805771303577744757u,          44400870326u },
  {  1626880974916825698u, 16371027194302248385u,         182477361818u },
  {  6806994170946429566u,  9114324123731231602u,         154887475162u },
  {  7596631230206896579u, 14468189808746991893u,         218494088500u },
  {  3100480253729502401u,  2376054557800684348u,          52784322141u },
  {  6310570748781063286u, 12462238943546048571u,          93128806175u },
  { 14251867077375744136u, 15334855370842605909u,          31675579326u },
  {  6701165793751570137u,  7211347914013798462u,         190831304175u },
  { 10856833140463959923u, 13763642332572548877u,         239390927953u },
  { 15867563727561248556u, 16868268377740071383u,          81746128545u },
  {  5048961008671491600u,  1120013377627684177u,         161914430661u },
  { 13278183119599849051u, 15898107650717274388u,         197060716046u },
  {  4547591784941053655u, 12281923376333274277u,          14861838142u },
  { 11815437715887182496u,  6383530489286615044u,          62665804400u },
  {   398495392178782208u,  4253822060257126466u,         112346051881u },
  {  9154841240825495552u, 17614372438391501998u,          41230600155u },
  {  1902683298245640192u,  4309951310554333450u,         219954877043u },
  {  5081900962138816512u, 13106185988973773020u,         115233642928u },
  {  3234710432358858752u,  2070134359761960547u,         176710487766u },
  { 16717361816799281152u,  9399359914137865875u,         214112222208u },
  {                    0u, 17415053284723541264u,            509540321u },
  {                    0u,  4840502610448261120u,         225944071930u },
  {                    0u,  5690599259712258048u,         250262404172u },
  {                    0u,   114769594245185536u,          76308488004u },
  {                    0u,  3150620882578178048u,          68006221672u },
  {                    0u,  5136918324969472000u,         104170795500u },
  {                    0u,  7205759403792793600u,         236278472900u },
  {                    0u,                    0u,         196390625000u },
  {                    0u,                    0u,         232000000000u },
  { 13488568028574514610u,                 1512u,                    0u },
  {   275784718433886190u,        1512731216738u,                    0u },
  { 10020568880357102364u,    98202693831717807u,                   82u },
  {  8876397213146246746u, 12909287260170414079u,          82005323578u },
  {  2155905919114811310u, 11728631949380786233u,          58699813864u },
  {  1087100407155601220u, 18263701925522197718u,         232635810411u },
  {  2903498381705011170u,  4868886449713321591u,         107990077265u },
  { 12223476257006657765u,  5870139507184082354u,          81263942863u },
  { 12148657163736735595u,  5978562500822661575u,         207318220900u },
  {  8951241323311673823u, 10821136839630268472u,         100324098522u },
  {  8463862715901576300u,  9490907630136752916u,         218586615003u },
  {  3873401978748963266u, 10564005678001613989u,         219514503133u },
  {   248364795947002730u,  5754050547468481222u,         221572675895u },
  { 10454378025404001822u,  3833909949855542602u,          55311927705u },
  {  6574176865628265640u, 15446538552665967784u,         153207836674u },
  {    16703315293848336u, 14924837848804399130u,           2837358532u },
  {  9896033222450013456u, 18140170340418344208u,         196809077080u },
  { 17311376269334085007u, 11380424819825208971u,          88983380604u },
  { 18378511316495639306u, 12416915664152252547u,         124616934065u },
  { 15120796393727584297u, 17195282241626289958u,         177673122346u },
  { 18253447805740347049u,  2649541045825281326u,          42932158118u },
  {  5842497225601731158u, 16577429864268509676u,         166143631907u },
  {  4369968404176723173u, 12051257060168107241u,          35898664273u },
  { 16142207253674488117u,  5363884561143470797u,          81653299954u },
  { 12124259227391928178u, 13054029903083620184u,         242290776764u },
  { 13019483264566077056u,   566314952158634945u,         188707660379u },
  {    74901376448135168u,  1329472079642345682u,          91030699995u },
  { 13897060093813325824u, 15686237486658857211u,         219072070825u },
  {  4495486210810052608u,  1069073549290598129u,         169850352638u },
  { 14885496280087265280u,  4323599065125928507u,         254057954593u },
  {  4976477588244398080u, 17861823329752681586u,          33234382774u },
  { 11529215046068469760u, 17220149985412802078u,         182968291382u },
  {                    0u,  4344934572159429184u,          54933506201u },
  {                    0u,  2252927464837120000u,         153235539375u },
  {                    0u, 10910018171964489728u,         175122131442u },
  {                    0u,  3597328585515335680u,         242591433270u },
  {                    0u,  6972808074239148032u,          54195011573u },
  {                    0u,  2227030015734710272u,         245377996683u },
  {                    0u,  1152921504606846976u,         139120727539u },
  {                    0u,                    0u,         243062500000u },
  {                    0u,                    0u,         160000000000u },
  { 10043594327130472635u,             23082446u,                    0u },
  {  8336034337032909060u,    23082446544464339u,                    0u },
  { 16717215784895280857u, 17238287503805244910u,              1251301u },
  { 10968831263951212032u,  1434575446038410275u,         229934489438u },
  {  5536629379734406065u, 14009569747841241694u,          94077768490u },
  {  1618806894932332402u, 14938795732275951328u,          42759460297u },
  { 11363331325254998861u,  6687653542888983473u,         201809833739u },
  {  8775167772751754888u,    28238723295162625u,          11362538425u },
  {  2898202945316114122u,  4745270274832691214u,         185001530824u },
  {  8868842714495185148u,   926478968112308824u,         200257241617u },
  { 17052094667531999136u,  9213681606604198526u,          17050224525u },
  {  3658615537031138594u, 13346223820579313024u,         141499474680u },
  { 12486952437987190746u,   691642518601291257u,         248723500243u },
  {   912079238520577629u,  1153720150033789192u,         211037494016u },
  { 10960072898031888041u, 12089015034721780810u,             62543294u },
  {  6129550094334741912u,  3555868702841788854u,         190655346818u },
  {  7965724516573729480u, 11708406782758214328u,         130192764028u },
  {  5801761178810791992u,  9417497762905343943u,         124634714003u },
  { 13197466483098446115u, 12838336066957615287u,         147510523576u },
  { 11326268638393107273u, 13737708142128207419u,         184695967592u },
  {  3597339351794947378u, 11683434809834695853u,         104744722650u },
  {   353880726151383714u,  2689114340106315837u,         218633360270u },
  { 11154818162602073600u,  8859225263374261032u,         142145777180u },
  {  5141043976157511026u, 15761671984578600096u,          28480259563u },
  {  7188225141808859034u,  7087267079878005352u,         235854441950u },
  { 13894168943295705185u,  4601291730423121377u,         222384201518u },
  { 12176538069834828288u,  9559411037059581623u,          46249436524u },
  {  7994239409235165184u, 12969820289641388091u,         108518216710u },
  { 13707777025480065024u, 13628239920285957130u,           6703095366u },
  { 10120227247676719104u,  8049893933765800625u,          70738788366u },
  {  7358494763030413312u, 10391755948840250234u,          14436385624u },
  {  7656119366529843200u, 14454650777462444512u,          88563338218u },
  {  9223372036854775808u, 14244638523341127254u,         234783588188u },
  {                    0u, 12246016810439753984u,          92772203401u },
  {                    0u,  9382741764551081984u,         137663857901u },
  {                    0u,  4608696190291148800u,         237508639450u },
  {                    0u,  1696483666416369664u,         218249837921u },
  {                    0u, 15416683541605384192u,          97091966563u },
  {                    0u,  7683140964294066176u,          99835740089u },
  {                    0u,  4611686018427387904u,         185416503906u },
  {                    0u,                    0u,          98250000000u },
  {                    0u,                    0u,         128000000000u },
  {  3877189582299842749u,                  352u,                    0u },
  {  7625565791857948238u,         352210182868u,                    0u },
  { 16568435163612007484u,  1722045467931902045u,                   19u },
  { 17592071940521808130u, 16095324008152856733u,          19093352271u },
  { 15158637878035490831u, 15216188060094280738u,          79872529262u },
  { 17789243229146401893u, 10793385929903030893u,         110824871207u },
  { 14677686051252896484u, 12613277226875940039u,          39585110623u },
  {  3531237481269211986u, 10644539625155600107u,          95683767128u },
  {  8074435404989280910u,  6181262895644173983u,          88577041649u },
  {  7086549341467684427u,   148914399627082292u,         241335086933u },
  { 10556134770918626963u, 14379289774887985969u,          85008072665u },
  { 10772666134712966775u, 11743339675582627452u,         217779502860u },
  {  6195173298198112620u,  7841621929809463497u,          12636607719u },
  {  8144773843324250887u, 11168944680251236601u,         231425095176u },
  { 14144284817150924691u,  6178560202529287410u,           8605469704u },
  {  6464447844648863176u, 13295243308201596112u,           8334940419u },
  { 15760468443293179135u, 17040673746172470291u,           3720736583u },
  {  5172191224908322475u, 14957442487039409922u,          71923776774u },
  {  2357554307308969012u, 17778155426506992152u,           6810844581u },
  {  1602046917604361745u, 14945404984219733899u,         165963755736u },
  {  7830970218109515845u, 11590754866058681505u,         216810192027u },
  {  2899479134887821084u,  6020790784469412466u,         155628336080u },
  { 15792042302392017912u,  7934351824569522326u,         208326387722u },
  { 11286099112296056199u,  5038361112172116744u,          10430122074u },
  { 15161477829153947404u,  3305187319649924210u,          90273130103u },
  {   423831848142641767u, 11470175511099161552u,         119179174563u },
  {  9707413321046312582u,  7308362160352048610u,         163621799460u },
  { 10969483299803835620u, 10666410671225576634u,          36396187106u },
  {  4326479556120930304u,  2181639019945820785u,         226578227281u },
  { 12876227232041795584u,  4615749499734847918u,          81118266888u },
  { 16967986827791171584u, 14076159200958497580u,           8250220281u },
  {  1288146316538413056u,  5470405257862074105u,         249763070119u },
  { 13715290452691779584u,  4565741478181339543u,         167296551263u },
  {  4683743612465315840u,  8901832997861862329u,          95247509341u },
  {                    0u, 14190141170191714122u,          93482569333u },
  {                    0u,  4240772322245764096u,         117769249094u },
  {                    0u,  4422842195340951552u,          70229892728u },
  {                    0u, 15448426386733137920u,         120239762755u },
  {                    0u,  9203504548935630848u,          67837460872u },
  {                    0u,  5936377627571912704u,         136498922981u },
  {                    0u,   468374361246531584u,         229321811676u },
  {                    0u,                    0u,         220025390625u },
  {                    0u,                    0u,          33000000000u },
  { 16344805304534272784u,              5374300u,                    0u },
  {    26429987091348271u,     5374300886053671u,                    0u },
  {  8691371289609838059u,  8020875056524075716u,               291341u },
  { 12980168378493046550u,  1400288714762747253u,          13434812508u },
  { 14010125458129496139u,  6136037711314764689u,          92075909803u },
  { 17061829677031795106u, 15735488086392394102u,         171332635270u },
  {  2227928323072698520u,  7735094782793634552u,         134853022518u },
  {  7394752319272287289u,  7273689191766726188u,          54419320328u },
  {  8805771303577744757u,  3410634565056431030u,           8394307481u },
  { 16371027194302248385u,  4600927904885215898u,         153184890870u },
  {  9114324123731231602u,  9154871331680374746u,         246249416801u },
  { 14468189808746991893u,  6117978272461042996u,          97496286569u },
  {  2376054557800684348u, 13116904339287496285u,         105331656266u },
  { 12462238943546048571u,   867037205615660831u,          74711068809u },
  { 15334855370842605909u,  1802487145191504830u,         137047002181u },
  {  7211347914013798462u, 17242009718457409007u,          69097713023u },
  { 13763642332572548877u, 13620802355488468049u,         127934691219u },
  { 16868268377740071383u,  4442227880594435745u,         147738385175u },
  {  1120013377627684177u, 17354849212854314181u,          23240813655u },
  { 15898107650717274388u, 18202319179831567886u,          87940808260u },
  { 12281923376333274277u, 17568634016348874558u,          68986749699u },
  {  6383530489286615044u,  7496925598312450672u,           3952397558u },
  {  4253822060257126466u,   601870379496813865u,         246406409151u },
  { 17614372438391501998u, 11995106565680728027u,         191032627458u },
  {  4309951310554333450u, 16331071694764184179u,           2650256029u },
  { 13106185988973773020u,  9665962217000524208u,         157885309170u },
  {  2070134359761960547u, 13682661374415474390u,         242523992861u },
  {  9399359914137865875u,  6940361789924260864u,          29741738559u },
  { 17415053284723541264u,  9658039831644010465u,          63376237766u },
  {  4840502610448261120u,  6843715893910236922u,         198523563388u },
  {  5690599259712258048u,    47089792870595660u,         124370998582u },
  {   114769594245185536u, 14510386192097156932u,          54002552742u },
  {  3150620882578178048u, 12059931208360040296u,         166786609611u },
  {  5136918324969472000u, 14877013468459184620u,         203653770180u },
  {  7205759403792793600u,  2397668560671695044u,         196806484516u },
  {                    0u,  2195572305559232232u,          36129977873u },
  {                    0u,  3261686279425953792u,          17119022213u },
  {                    0u,  9333850662059900928u,         133176816367u },
  {                    0u,  5036522340217782272u,         239505989058u },
  {                    0u,  2800120215143186432u,         194273030423u },
  {                    0u,   441634238459019264u,          23151794821u },
  {                    0u,   720575940379279360u,         133023941040u },
  {                    0u,                    0u,         176039062500u },
  {                    0u,                    0u,         228000000000u },
  {    98202693831717807u,                   82u,                    0u },
  { 12909287260170414079u,          82005323578u,                    0u },
  { 11728631949380786233u,  8218347283861607400u,                    4u },
  { 18263701925522197718u, 17896200385973633643u,           4445517498u },
  {  4868886449713321591u, 16333242102094352209u,         186970154966u },
  {  5870139507184082354u,  9981905728606788815u,         214885426828u },
  {  5978562500822661575u, 15219470018924839012u,         140541120193u },
  { 10821136839630268472u, 17152070168529617370u,         193825049122u },
  {  9490907630136752916u, 17841343440958328027u,          34929815586u },
  { 10564005678001613989u, 17291078023923990493u,          34967181165u },
  {  5754050547468481222u, 16744804581790759223u,         109937351217u },
  {  3833909949855542602u,  5001622214111594905u,          49907737675u },
  { 15446538552665967784u,  9676746897435398146u,          75271138483u },
  { 14924837848804399130u,  8109025833995118532u,         179524577500u },
  { 18140170340418344208u,  5495826424046694744u,         220439591171u },
  { 11380424819825208971u,  7890288164365705852u,           3297929347u },
  { 12416915664152252547u,  8616438349039895217u,         131427733378u },
  { 17195282241626289958u, 15787154801788760618u,         130467098058u },
  {  2649541045825281326u, 12418659311480782502u,         202855823376u },
  { 16577429864268509676u,  4486988874116669987u,          16673216870u },
  { 12051257060168107241u,  4828971301551875409u,         102243240154u },
  {  5363884561143470797u, 14769106422014442226u,         218261779058u },
  { 13054029903083620184u,  7763933466423188156u,         114800634863u },
  {   566314952158634945u, 10449097116253839963u,         239420883676u },
  {  1329472079642345682u, 12870692502472900571u,         220566446689u },
  { 15686237486658857211u, 11597479481311003817u,          97697721638u },
  {  1069073549290598129u,  8294994869530047486u,          38628700622u },
  {  4323599065125928507u, 16879315829924478241u,         206449672572u },
  { 17861823329752681586u, 11873324837601439670u,         124915029544u },
  { 17220149985412802078u,  3277599055636107318u,          40643654229u },
  {  4344934572159429184u, 15363467897354242201u,          85177679000u },
  {  2252927464837120000u, 10351182204479784367u,         152832855263u },
  { 10910018171964489728u, 12811517584931924466u,         223561138711u },
  {  3597328585515335680u, 16988930699558748726u,          23694513759u },
  {  6972808074239148032u, 11683499918824718325u,          95920971778u },
  {  2227030015734710272u, 13119300691281647499u,           2633363799u },
  {  1152921504606846976u, 10125549106595354099u,          87711198715u },
  {                    0u, 17505352699870800544u,         251548907116u },
  {                    0u,  6756039242241163264u,         108948967071u },
  {                    0u,  3537338758766526464u,         159366245621u },
  {                    0u,  6522626374119718912u,         245191759518u },
  {                    0u,  4733294203482669056u,         158353592284u },
  {                    0u, 16997710893603094528u,         220256592392u },
  {                    0u, 16717361816799281152u,           8921447753u },
  {                    0u,                    0u,          73906250000u },
  {                    0u,                    0u,          16000000000u },
  { 17238287503805244910u,              1251301u,                    0u },
  {  1434575446038410275u,     1251301934489438u,                    0u },
  { 14009569747841241694u,  3943737498063000362u,                67833u },
  { 14938795732275951328u,  2870731037991212489u,         249213790438u },
  {  6687653542888983473u,  7389433400402095883u,         230155622641u },
  {    28238723295162625u,  5675049236146197433u,         241400581987u },
  {  4745270274832691214u,  9953779846262904264u,          99307645035u },
  {   926478968112308824u, 12691978937179636241u,         107539595486u },
  {  9213681606604198526u, 15523327331528198029u,         222688033556u },
  { 13346223820579313024u, 15722603279568118520u,          20841521260u },
  {   691642518601291257u, 11838632364171816147u,         108852324031u },
  {  1153720150033789192u,  7832751832367143680u,         191641773546u },
  { 12089015034721780810u, 12167724027162940862u,         234424614327u },
  {  3555868702841788854u,  4108211144748152962u,         183659613641u },
  { 11708406782758214328u,  7530983398136343676u,         201222706572u },
  {  9417497762905343943u,  1117587133956542355u,         140408255428u },
  { 12838336066957615287u, 17134748625149490872u,         196060584519u },
  { 13737708142128207419u,  4039918359454207848u,          71928876584u },
  { 11683434809834695853u,  1830218764589441242u,          40219004413u },
  {  2689114340106315837u,   637895981480825742u,         253099216358u },
  {  8859225263374261032u,  8246879226348334620u,         230034580410u },
  { 15761671984578600096u, 12389239568142583275u,         186447064218u },
  {  7087267079878005352u, 14041257178803154398u,         154671622022u },
  {  4601291730423121377u, 16312515716494630702u,         134761178076u },
  {  9559411037059581623u, 17088522799596987756u,         220884303248u },
  { 12969820289641388091u,  3588932524637852678u,         144926370677u },
  { 13628239920285957130u,   107218049069817414u,         117194556422u },
  {  8049893933765800625u,  1596707240462008334u,           6005812302u },
  { 10391755948840250234u, 17461913142391587672u,          78086557672u },
  { 14454650777462444512u,  4366474266651610090u,         232946612208u },
  { 14244638523341127254u,  5539304013194805084u,         240236707044u },
  { 12246016810439753984u,  4762470619211987849u,         228300286272u },
  {  9382741764551081984u, 10835638458986644717u,          64258174049u },
  {  4608696190291148800u, 16141642290510052058u,          97587401137u },
  {  1696483666416369664u, 17390568670756355425u,         177875040181u },
  { 15416683541605384192u, 12536768491333867107u,         181942744616u },
  {  7683140964294066176u, 13145148522871947193u,          40679619581u },
  {  4611686018427387904u,  5665349945233068642u,         253712599929u },
  {                    0u, 17074607537751066240u,         121307119235u },
  {                    0u,  6241525660962062336u,         131925616329u },
  {                    0u,  1142860629783085056u,         201338353784u },
  {                    0u, 16287527416870469632u,         120061954598u },
  {                    0u,  9028002014738513920u,          38882948630u },
  {                    0u, 16217462258161156096u,          22489408969u },
  {                    0u, 11529215046068469760u,         201879150390u },
  {                    0u,                    0u,          54625000000u },
  {                    0u,                    0u,          64000000000u },
  {  1722045467931902045u,                   19u,                    0u },
  { 16095324008152856733u,          19093352271u,                    0u },
  { 15216188060094280738u,   646608198162977646u,                    1u },
  { 10793385929903030893u, 12170458846894708007u,           1035052700u },
  { 12613277226875940039u,  1797330480103086687u,         156659761896u },
  { 10644539625155600107u, 10332188564497263448u,         232097433480u },
  {  6181262895644173983u,  7524259485079594225u,         136560109064u },
  {   148914399627082292u,    62681109059153749u,           8407890924u },
  { 14379289774887985969u, 13480636451804037081u,         236003397949u },
  { 11743339675582627452u,  6948168233012789004u,          61730786766u },
  {  7841621929809463497u, 12015502974041806055u,         206376660954u },
  { 11168944680251236601u,  7343801660689004040u,         218651361721u },
  {  6178560202529287410u, 13670580858640731144u,         185398108285u },
  { 13295243308201596112u,  5605073897566574851u,         125741083673u },
  { 17040673746172470291u, 15387788940505247559u,          25303851664u },
  { 14957442487039409922u, 17565181499678113030u,         144834173709u },
  { 17778155426506992152u,  1893743623847493029u,          13952210397u },
  { 14945404984219733899u, 10243498996716269784u,         221102660047u },
  { 11590754866058681505u,  5619675836950314139u,         207555301193u },
  {  6020790784469412466u, 10224869737511515088u,          73304643237u },
  {  7934351824569522326u,  2574495974386198538u,         165554291299u },
  {  5038361112172116744u,  7825756347302873178u,          99139563706u },
  {  3305187319649924210u, 12071550103794656887u,         186424235101u },
  { 11470175511099161552u,  7195875213867606691u,          93654400042u },
  {  7308362160352048610u, 18271364438406891044u,          42390089176u },
  { 10666410671225576634u, 16966521933952564706u,         216990492650u },
  {  2181639019945820785u,   289920862029570129u,         234919756997u },
  {  4615749499734847918u,  7804199568098625032u,         197015716641u },
  { 14076159200958497580u,  5758118571242446585u,          33423066506u },
  {  5470405257862074105u,  4030788293606375591u,         138312148233u },
  {  4565741478181339543u,  4387716460037196127u,           9218509471u },
  {  8901832997861862329u, 16807506478881285981u,         159237858585u },
  { 14190141170191714122u, 17033060604413529717u,          25911136751u },
  {  4240772322245764096u, 10498418508292170054u,         239923364065u },
  {  4422842195340951552u, 13237752038744465016u,         225569120407u },
  { 15448426386733137920u, 17737618428304633155u,         151717619975u },
  {  9203504548935630848u, 13546183833248825736u,           7961558221u },
  {  5936377627571912704u,   826778452978976229u,         205734340097u },
  {   468374361246531584u, 13728076626990147292u,           1044819749u },
  {                    0u,  2794860281883592225u,          37744200525u },
  {                    0u,  8680705720425908736u,          77151509679u },
  {                    0u,   731520517439488000u,         175470582000u },
  {                    0u, 13120812320768917504u,         240039655806u },
  {                    0u,  2722954908557901824u,         126711280661u },
  {                    0u,  6860847004205973504u,          21147611681u },
  {                    0u,  6503197861922996224u,          33371927261u },
  {                    0u,  9223372036854775808u,         221352539062u },
  {                    0u,                    0u,         182500000000u },
  {  8020875056524075716u,               291341u,                    0u },
  {  1400288714762747253u,      291341434812508u,                    0u },
  {  6136037711314764689u, 12005656413127238315u,                15793u },
  { 15735488086392394102u,  4821130826186787462u,         177650827938u },
  {  7735094782793634552u, 14377899467066168118u,         162261354025u },
  {  7273689191766726188u, 16575613239625444872u,          41779427491u },
  {  3410634565056431030u,  4317827099179284377u,         163898565794u },
  {  4600927904885215898u,  1242354770412171254u,         162234069876u },
  {  9154871331680374746u,   994838588328896609u,         116067348187u },
  {  6117978272461042996u, 17283309862013060457u,         219053930307u },
  { 13116904339287496285u,   124242522249856586u,          67936930105u },
  {   867037205615660831u, 11564608014666985609u,          57006735200u },
  {  1802487145191504830u, 12401028575581654085u,          96626918656u },
  { 17242009718457409007u,  2490725392961465727u,            672261106u },
  { 13620802355488468049u,  1949482237120640915u,         242135022494u },
  {  4442227880594435745u, 15410502396166200087u,         158105681643u },
  { 17354849212854314181u, 15694919529799920727u,         235835405008u },
  { 18202319179831567886u, 10324869370171768388u,         208850823292u },
  { 17568634016348874558u,  1631866459122189059u,         124559712290u },
  {  7496925598312450672u,   172020494461226230u,          34088463658u },
  {   601870379496813865u, 12734610307908856767u,          42009325249u },
  { 11995106565680728027u,  1467513250829340930u,         193690344608u },
  { 16331071694764184179u, 13558759428494307997u,         160079554052u },
  {  9665962217000524208u,  7915355143999496434u,           4735021821u },
  { 13682661374415474390u,  2876370200608797469u,         253429092262u },
  {  6940361789924260864u,   343685370404989503u,         166155928341u },
  {  9658039831644010465u,  4837266557407634630u,          21018631221u },
  {  6843715893910236922u,  9622591415747161468u,          53262228745u },
  {    47089792870595660u, 16503783814424220982u,           9521641725u },
  { 14510386192097156932u,  5377083431343591334u,         253894671913u },
  { 12059931208360040296u, 16508482371299291595u,          41291492276u },
  { 14877013468459184620u, 10515883558812249028u,         180894926622u },
  {  2397668560671695044u,    63492062913405476u,          30570067190u },
  {  2195572305559232232u, 11571919759617799697u,         246003441911u },
  {  3261686279425953792u,  2956602334970088581u,         247627315027u },
  {  9333850662059900928u, 13604736747717849839u,          83160277733u },
  {  5036522340217782272u, 16573540719338151362u,         229737514256u },
  {  2800120215143186432u, 12620703004601168151u,          16898453442u },
  {   441634238459019264u, 14649407809089591941u,         194684169680u },
  {   720575940379279360u, 11290375247898624432u,         208794145988u },
  {                    0u, 11020319450292874212u,         196612052468u },
  {                    0u,  8754634933362354176u,         244597412714u },
  {                    0u, 12976319450332528640u,         106474589710u },
  {                    0u, 17447331119627239424u,          14703447686u },
  {                    0u,  3665184902673858560u,         134945821715u },
  {                    0u, 12949678516038795264u,          19198690071u },
  {                    0u,    72057594037927936u,          23702003479u },
  {                    0u,                    0u,          23003906250u },
  {                    0u,                    0u,         202000000000u },
  {  8218347283861607400u,                    4u,                    0u },
  { 17896200385973633643u,           4445517498u,                    0u },
  { 16333242102094352209u,  4445517498970154966u,                    0u },
  {  9981905728606788815u,  9413159735776077452u,            240991986u },
  { 15219470018924839012u, 14279163482889998017u,         242510288411u },
  { 17152070168529617370u,  8693044629541194274u,          27774075003u },
  { 17841343440958328027u, 11863110253260222498u,         123471250893u },
  { 17291078023923990493u,  8319293368489531245u,         205643100495u },
  { 16744804581790759223u,  3376307525676489265u,          79450989797u },
  {  5001622214111594905u, 13205662254759912523u,         229183029997u },
  {  9676746897435398146u,  5276250334231686323u,         237715880385u },
  {  8109025833995118532u, 13790198520922745052u,         193286026103u },
  {  5495826424046694744u, 14195535250150996227u,         119747568159u },
  {  7890288164365705852u, 16425228796427004035u,          31769541507u },
  {  8616438349039895217u,  4295900841296269186u,         131890413437u },
  { 15787154801788760618u,  4533952595483946442u,         125232881251u },
  { 12418659311480782502u, 12885038019373447184u,          99245786062u },
  {  4486988874116669987u, 12140736240487831910u,         206698499310u },
  {  4828971301551875409u,  6927124077155322074u,         238658150630u },
  { 14769106422014442226u, 12477788342407819890u,         230375520148u },
  {  7763933466423188156u,  7980854329409711087u,         148676422261u },
  { 10449097116253839963u,  2062671021810827996u,         117432642980u },
  { 12870692502472900571u,  2739521363598172769u,         164111817620u },
  { 11597479481311003817u, 12897585686593465638u,         148148509750u },
  {  8294994869530047486u,  1127632646629044686u,          54699179521u },
  { 16879315829924478241u,  4833775019274666364u,           1061129088u },
  { 11873324837601439670u, 15867662672939849256u,         128262039468u },
  {  3277599055636107318u,  2092350330982953557u,         172860187717u },
  { 15363467897354242201u, 13330062299842493592u,          69113426538u },
  { 10351182204479784367u,  4479193352178519263u,         106722624125u },
  { 12811517584931924466u,  3149393938889064983u,         125242817558u },
  { 16988930699558748726u,  9736379904070620767u,          22170728987u },
  { 11683499918824718325u,  3816238703055069186u,          27527810212u },
  { 13119300691281647499u, 11598915938798661975u,         164206878714u },
  { 10125549106595354099u, 17821633264606555643u,         250628778492u },
  { 17505352699870800544u,  2514623558764574316u,         252966112675u },
  {  6756039242241163264u,  4976730480406253215u,         163136318016u },
  {  3537338758766526464u, 17276563697191611637u,          64269789099u },
  {  6522626374119718912u, 12524734095940998814u,         171936564394u },
  {  4733294203482669056u, 15331551308930355164u,         170678967195u },
  { 16997710893603094528u, 15417115581125943816u,         155831125061u },
  { 16717361816799281152u,  6010750237807115593u,          69835763510u },
  {                    0u,  5624630987553628432u,          54325843423u },
  {                    0u, 14881848243837640704u,         223304911856u },
  {                    0u, 15281613886881529856u,         240806746609u },
  {                    0u, 14057902358273196032u,         241828417948u },
  {                    0u, 16075318494433902592u,         156762080413u },
  {                    0u, 13891916000577716224u,         157871444761u },
  {                    0u,  7205759403792793600u,          25753082275u },
  {                    0u,                    0u,         163390625000u },
  {                    0u,                    0u,         232000000000u },
  {  3943737498063000362u,                67833u,                    0u },
  {  2870731037991212489u,       67833213790438u,                    0u },
  {  7389433400402095883u,  4535831408134330609u,                 3677u },
  {  5675049236146197433u,  6204770794376564579u,          93245887913u },
  {  9953779846262904264u, 13869812122751887467u,         169336361298u },
  { 12691978937179636241u, 14253229412394467550u,          82751884021u },
  { 15523327331528198029u, 12776557610216045332u,         245772669114u },
  { 15722603279568118520u, 16493640728678654060u,         186692618575u },
  { 11838632364171816147u,  9434398296825833151u,          79894122055u },
  {  7832751832367143680u,  8773374058285327850u,          71511439756u },
  { 12167724027162940862u, 12932015276748029367u,         140475605560u },
  {  4108211144748152962u, 16293958583527755209u,          56701045952u },
  {  7530983398136343676u, 13511893936143127948u,         192883297264u },
  {  1117587133956542355u, 18409936402005226436u,         240732481237u },
  { 17134748625149490872u,  2189663026458466887u,         213998004652u },
  {  4039918359454207848u,  9497725274248154664u,         172118701870u },
  {  1830218764589441242u, 14766925481127792125u,          46514872718u },
  {   637895981480825742u,  6982373971809635814u,         142800516634u },
  {  8246879226348334620u,  8616702383006884794u,          26378515251u },
  { 12389239568142583275u,  3059473300040871066u,          51467112372u },
  { 14041257178803154398u, 17123843157031495558u,         180165854379u },
  { 16312515716494630702u, 11210627174210626524u,         171928285397u },
  { 17088522799596987756u, 15868067138625928592u,         213607729316u },
  {  3588932524637852678u,  4467869511636937589u,         164860209643u },
  {   107218049069817414u, 10052108125844341766u,         235242203691u },
  {  1596707240462008334u,  7470588003218451534u,          43544925873u },
  { 17461913142391587672u,  2613527085490786280u,         177404981387u },
  {  4366474266651610090u,  3632919450036549616u,         139141679587u },
  {  5539304013194805084u,   179367907231218916u,         227196940958u },
  {  4762470619211987849u, 13553068184555874624u,         158009723553u },
  { 10835638458986644717u,  8798774862365584481u,         161734713298u },
  { 16141642290510052058u,   910911255817064881u,         210476982541u },
  { 17390568670756355425u,  2304331144765093813u,          13049380598u },
  { 12536768491333867107u, 12248937023083640360u,         246124918041u },
  { 13145148522871947193u, 10206039550662130685u,          25664016206u },
  {  5665349945233068642u, 12267881323837852537u,          78553270512u },
  { 17074607537751066240u,  2858642007937891971u,         240665043179u },
  {  6241525660962062336u, 14171330289750320841u,         235154967293u },
  {  1142860629783085056u,  6601103619749017720u,         253768229354u },
  { 16287527416870469632u,  4919573414486739494u,         234357846544u },
  {  9028002014738513920u,  3401998285294974486u,          16266690609u },
  { 16217462258161156096u, 10799436256515532233u,          49184422696u },
  { 11529215046068469760u, 10083786644665753398u,          40585438612u },
  {                    0u,  6481194517685688896u,         148546643169u },
  {                    0u, 15104161756860547072u,         225351346258u },
  {                    0u,  9556039274244079616u,          82818798249u },
  {                    0u,  1376343134954323968u,         169518033927u },
  {                    0u, 15682488278596976640u,           7074611710u },
  {                    0u,  1506454075355430912u,         254850149393u },
  {                    0u,  1152921504606846976u,          17081665039u },
  {                    0u,                    0u,          15062500000u },
  {                    0u,                    0u,         160000000000u },
  { 12170458846894708007u,           1035052700u,                    0u },
  {  1797330480103086687u,  1035052700659761896u,                    0u },
  { 10332188564497263448u,  6172559441576707976u,             56110319u },
  {  7524259485079594225u, 15083329738554729992u,         239334615117u },
  {    62681109059153749u, 10013126833549229036u,          77817668943u },
  { 13480636451804037081u,  5817156823499936061u,          79542812693u },
  {  6948168233012789004u,  5282692560913632718u,          21315348703u },
  { 12015502974041806055u, 10252307034225766362u,         223286375337u },
  {  7343801660689004040u, 17981881283247669689u,         169555778677u },
  { 13670580858640731144u, 11689290159733383293u,         117974799737u },
  {  5605073897566574851u,  5530668968487988249u,         121633677689u },
  { 15387788940505247559u, 10083765740821947024u,         121299818165u },
  { 17565181499678113030u,  2798423656816843533u,         181546642036u },
  {  1893743623847493029u,  7614494481582904797u,         116151702850u },
  { 10243498996716269784u, 17811318500083423695u,          66412782572u },
  {  5619675836950314139u, 11641467412200329033u,         236965553510u },
  { 10224869737511515088u, 17733593025296340645u,         102631085212u },
  {  2574495974386198538u,  3689424000190644835u,         156961340004u },
  {  7825756347302873178u, 14966634145516728506u,         100200004075u },
  { 12071550103794656887u, 14171681941562070109u,         235811342862u },
  {  7195875213867606691u,  8130575762882608170u,          14768248417u },
  { 18271364438406891044u,  5234550794400656856u,          97440759395u },
  { 16966521933952564706u,  3020576149360486378u,          99283765567u },
  {   289920862029570129u,  3038675756589057221u,          63163745761u },
  {  7804199568098625032u, 15470260187120878369u,         225164726942u },
  {  5758118571242446585u,  3497929414841828746u,         158838644485u },
  {  4030788293606375591u,  9935840636861015305u,           5189623133u },
  {  4387716460037196127u,  3647355485153741471u,          93538623000u },
  { 16807506478881285981u,   766100215038272793u,          24197723537u },
  { 17033060604413529717u, 16128087474216800751u,         145041530375u },
  { 10498418508292170054u, 16216631732633731297u,           7874305373u },
  { 13237752038744465016u, 13760220872779997335u,          93879105367u },
  { 17737618428304633155u,  3826276262374222087u,          87745943068u },
  { 13546183833248825736u, 14938032745839181005u,          28207422851u },
  {   826778452978976229u, 14479259995009508865u,         131809792377u },
  { 13728076626990147292u,  2372033248156102437u,         121784922257u },
  {  2794860281883592225u,   792005346826701645u,         145128588180u },
  {  8680705720425908736u, 16278924527931792559u,         148042934695u },
  {   731520517439488000u, 17442516423538940144u,         167882482266u },
  { 13120812320768917504u,    13844184233048446u,          90945560710u },
  {  2722954908557901824u, 13486193870480782357u,         134000750494u },
  {  6860847004205973504u, 11931315179184648737u,         158731088034u },
  {  6503197861922996224u, 16492562205587485405u,         162646797891u },
  {  9223372036854775808u, 12128987217680380854u,          67894063588u },
  {                    0u, 10568123814189138176u,         228657513714u },
  {                    0u, 17007583519117541376u,         242572899139u },
  {                    0u,   143791533903052800u,          67921982950u },
  {                    0u, 12398714235792654336u,         230007794954u },
  {                    0u,  9659957317919047680u,          10672135645u },
  {                    0u,  9412523221204336640u,         221523667335u },
  {                    0u,  4611686018427387904u,         135510253906u },
  {                    0u,                    0u,          82250000000u },
  {                    0u,                    0u,         128000000000u },
  { 12005656413127238315u,                15793u,                    0u },
  {  4821130826186787462u,       15793650827938u,                    0u },
  { 14377899467066168118u,  3237900842885170729u,                  856u },
  { 16575613239625444872u,  7515893506498066595u,          88175526956u },
  {  4317827099179284377u,  7300206309181072546u,          44407437403u },
  {  1242354770412171254u,     5999737279837044u,          91395744977u },
  {   994838588328896609u,  7556839307242450651u,         209000325246u },
  { 17283309862013060457u, 12946035041643640643u,         126409657079u },
  {   124242522249856586u, 15885877642352740665u,         247701805965u },
  { 11564608014666985609u, 10770818348246089568u,         141861175152u },
  { 12401028575581654085u, 11635415503599551744u,         112583887232u },
  {  2490725392961465727u,  6248053924100826098u,         128630757138u },
  {  1949482237120640915u, 16894170802729859998u,          18338707681u },
  { 15410502396166200087u,  6143589029651889899u,         225915834834u },
  { 15694919529799920727u, 11812087701837886160u,         210333044628u },
  { 10324869370171768388u,  7306705080150829180u,         148640334557u },
  {  1631866459122189059u,  1485332570280714274u,         221396097276u },
  {   172020494461226230u, 18042602303295630634u,         252080520039u },
  { 12734610307908856767u, 13397029889257074369u,         103978091430u },
  {  1467513250829340930u,  9948104869613411488u,         166726254445u },
  { 13558759428494307997u, 10836066241170646532u,         109539287845u },
  {  7915355143999496434u, 18330574781234459389u,          37587424327u },
  {  2876370200608797469u,   666297360208433062u,          71993702450u },
  {   343685370404989503u,  5035352224889324309u,          50036120052u },
  {  4837266557407634630u,  1341745796439923765u,         244272966991u },
  {  9622591415747161468u,  6846932182653803785u,          79072736185u },
  { 16503783814424220982u,  6727685027257825533u,         185371172937u },
  {  5377083431343591334u,  2168538874806877737u,          73364708536u },
  { 16508482371299291595u, 17694936100676971444u,         184117556727u },
  { 10515883558812249028u,  2163944241059563294u,         247959244408u },
  {    63492062913405476u,  6727780864524301558u,         120117307652u },
  { 11571919759617799697u,  8599551977795002615u,           4364713731u },
  {  2956602334970088581u, 15428264807806859091u,           3466182646u },
  { 13604736747717849839u,  2126771385339683557u,         246836367911u },
  { 16573540719338151362u, 15094316562082972944u,          39115292507u },
  { 12620703004601168151u,  8111300598225956802u,          91818264540u },
  { 14649407809089591941u,  9481215200564260304u,         220439714486u },
  { 11290375247898624432u, 16836674128623424708u,         182513977705u },
  { 11020319450292874212u,  7087243115299722740u,         105912717933u },
  {  8754634933362354176u,  2343560867338408810u,         109384200219u },
  { 12976319450332528640u,  3431385749090422286u,          27127044689u },
  { 17447331119627239424u,  3504545517469224582u,          81186015794u },
  {  3665184902673858560u,  3333759805712094227u,          50189981793u },
  { 12949678516038795264u,  3595183476205994775u,          97180723481u },
  {    72057594037927936u, 14191566632569921303u,          25194895286u },
  {                    0u, 12917427671358095562u,         182769326368u },
  {                    0u,  3883793922738316288u,          32700255157u },
  {                    0u,  7857281689266421760u,         181210540890u },
  {                    0u, 15987081651486195712u,          90425944093u },
  {                    0u, 16827562156399525888u,          29866661432u },
  {                    0u,  7012737938513461248u,          56912223972u },
  {                    0u,  7385903388887613440u,         228380161285u },
  {                    0u,                    0u,           5400390625u },
  {                    0u,                    0u,         225000000000u },
  {  9413159735776077452u,            240991986u,                    0u },
  { 14279163482889998017u,   240991986510288411u,                    0u },
  {  8693044629541194274u, 14135788013842776187u,             13064201u },
  { 11863110253260222498u, 13284322918167594445u,           9766302603u },
  {  8319293368489531245u,  7264587765474046287u,         139720144588u },
  {  3376307525676489265u, 16176482219778368741u,         204393814091u },
  { 13205662254759912523u,  5401983818872095469u,          75876928858u },
  {  5276250334231686323u, 11208857446851049921u,          90292842129u },
  { 13790198520922745052u, 13794690008281035639u,         145607633379u },
  { 14195535250150996227u, 14519782740993303071u,         227747811643u },
  { 16425228796427004035u, 10885858587044789123u,          59787118999u },
  {  4295900841296269186u,  8710500938899914621u,         151590123576u },
  {  4533952595483946442u,  1284182587483102819u,          56472197202u },
  { 12885038019373447184u, 10346074482131502030u,          82069615677u },
  { 12140736240487831910u,  9429804686255246574u,          61560861821u },
  {  6927124077155322074u,  6412022633845121254u,         125511190736u },
  { 12477788342407819890u,  8892351297529018260u,         208347596443u },
  {  7980854329409711087u, 14098160105983060597u,         155482055329u },
  {  2062671021810827996u, 13793833029739474340u,         161764262790u },
  {  2739521363598172769u, 16367653765996977044u,         134747765186u },
  { 12897585686593465638u, 10684788343333772342u,         194887292288u },
  {  1127632646629044686u, 13272681218705145345u,         128579223536u },
  {  4833775019274666364u, 11093568615497829248u,         240719513490u },
  { 15867662672939849256u, 12488220765137758124u,         146601383559u },
  {  2092350330982953557u,  3727114642519696453u,         135676987804u },
  { 13330062299842493592u, 11549865375695057514u,         156202047289u },
  {  4479193352178519263u, 11292809154908783229u,          57626119456u },
  {  3149393938889064983u, 17723904861837310998u,          32612184410u },
  {  9736379904070620767u, 14877674388187150875u,          90960814807u },
  {  3816238703055069186u, 12178961950105734308u,         215806520344u },
  { 11598915938798661975u,  4540604068069253114u,          24660222850u },
  { 17821633264606555643u, 13832478722153359868u,         130246146639u },
  {  2514623558764574316u,  1308046668730371491u,          79749860174u },
  {  4976730480406253215u, 18400531023544756800u,          78070909351u },
  { 17276563697191611637u,  9789823458621466539u,         167997494785u },
  { 12524734095940998814u,  1924870562610267306u,           1530707393u },
  { 15331551308930355164u,  5290016144582400923u,         193104347442u },
  { 15417115581125943816u, 15162883663174059077u,          50286772349u },
  {  6010750237807115593u,  8078086116520046390u,         125821981570u },
  {  5624630987553628432u, 15731407332173190623u,         130437913925u },
  { 14881848243837640704u,  5346389182763011056u,          69852801300u },
  { 15281613886881529856u,  6368422217216252401u,          20289828338u },
  { 14057902358273196032u,  2961453088119116188u,         242345232860u },
  { 16075318494433902592u, 10932141691610170525u,         220160540693u },
  { 13891916000577716224u, 11034016191361782553u,          21592632588u },
  {  7205759403792793600u,  5455325785621453219u,          12598155216u },
  {                    0u,  7735615202566149352u,         208295733803u },
  {                    0u,  7502396497775759360u,          43419348540u },
  {                    0u,  1601286435751591936u,          60406705729u },
  {                    0u, 11449383158571597824u,          65086805911u },
  {                    0u, 13043944595690356736u,         151620672304u },
  {                    0u,  7773494431818186752u,          48707113653u },
  {                    0u,  9943947977234055168u,         181421401977u },
  {                    0u,                    0u,         121539062500u },
  {                    0u,                    0u,         228000000000u },
  {  4535831408134330609u,                 3677u,                    0u },
  {  6204770794376564579u,        3677245887913u,                    0u },
  { 13869812122751887467u,  6343817245135589714u,                  199u },
  { 14253229412394467550u, 17549323075660516085u,         199343899021u },
  { 12776557610216045332u,  3948641822109421754u,         141951350710u },
  { 16493640728678654060u,  1750739713693534543u,         182214056302u },
  {  9434398296825833151u,   962163898128633415u,         110094907790u },
  {  8773374058285327850u,  7967320249386531212u,         142052159009u },
  { 12932015276748029367u,  3018466665533383224u,          33431909296u },
  { 16293958583527755209u, 15076865731854945472u,         176163631405u },
  { 13511893936143127948u,   691187172844604400u,          45817318529u },
  { 18409936402005226436u, 13274492813370992341u,         129037469331u },
  {  2189663026458466887u,  6364168818499152300u,         147719611697u },
  {  9497725274248154664u, 17599380787401914158u,          49345002282u },
  { 14766925481127792125u,  3782323149461692814u,          42954064344u },
  {  6982373971809635814u, 14470163442442237466u,         216205040148u },
  {  8616702383006884794u,   476109872130437939u,          20784429132u },
  {  3059473300040871066u, 16330548844673355700u,          76025809967u },
  { 17123843157031495558u, 14089158961463739563u,          47885280826u },
  { 11210627174210626524u, 13385510793074798805u,          58763774837u },
  { 15868067138625928592u,  1549401308746959012u,         117725629994u },
  {  4467869511636937589u,  4607384943843027435u,          42083993213u },
  { 10052108125844341766u,  5157353797716093483u,         125249766838u },
  {  7470588003218451534u, 10846828782671550129u,         182279580709u },
  {  2613527085490786280u,  9915857350819131531u,          37588007766u },
  {  3632919450036549616u,  1673544973504317923u,          86537539704u },
  {   179367907231218916u, 14780986291622785694u,         120090723054u },
  { 13553068184555874624u,  8168111319515466401u,         238801278872u },
  {  8798774862365584481u, 16345760387859734482u,         152442794201u },
  {   910911255817064881u,  3177475373321281805u,         217886105446u },
  {  2304331144765093813u,  2558676822419554038u,         102172251285u },
  { 12248937023083640360u,  8813474062662382873u,         149138706148u },
  { 10206039550662130685u,  5426294560236228430u,         228477779386u },
  { 12267881323837852537u,  9919177474128333040u,         186294160017u },
  {  2858642007937891971u,  6197383943089627371u,         145537719688u },
  { 14171330289750320841u, 13673239314867423997u,         136335960856u },
  {  6601103619749017720u,  9309584098968723946u,          24741227788u },
  {  4919573414486739494u,  4647101757759615504u,          12504673565u },
  {  3401998285294974486u,  1405809295505096753u,          29251919891u },
  { 10799436256515532233u, 11332704079573859112u,          19076209074u },
  { 10083786644665753398u,  2960072434514044308u,         178614347119u },
  {  6481194517685688896u,  3887266602785432801u,         111160465848u },
  { 15104161756860547072u, 14545546084687849554u,         184210729144u },
  {  9556039274244079616u,  4617763804182385321u,         184788515633u },
  {  1376343134954323968u,  7857823815580249095u,          49250329477u },
  { 15682488278596976640u, 10939326736548364798u,         133425973482u },
  {  1506454075355430912u, 12262012446566951953u,         234593022090u },
  {  1152921504606846976u, 12555024338687723023u,         138664725026u },
  {                    0u,  3332969632922829472u,          34680609233u },
  {                    0u, 15535060143360327680u,         209180680645u },
  {                    0u, 15794322927987458048u,         197842157297u },
  {                    0u, 10571474314433921024u,         241856211961u },
  {                    0u, 16679514427547975680u,         249573080770u },
  {                    0u, 16925653299565166592u,         194904198288u },
  {                    0u, 16717361816799281152u,         144917541503u },
  {                    0u,                    0u,         127906250000u },
  {                    0u,                    0u,          16000000000u },
  {  6172559441576707976u,             56110319u,                    0u },
  { 15083329738554729992u,    56110319334615117u,                    0u },
  { 10013126833549229036u,  9335385384027907407u,              3041746u },
  {  5817156823499936061u, 13237828406194798613u,         210506072255u },
  {  5282692560913632718u, 15667486867836528863u,         191717624115u },
  { 10252307034225766362u, 17982325043592934313u,          51849336164u },
  { 17981881283247669689u, 17159117626917379189u,         100974823793u },
  { 11689290159733383293u,  8336208968408929657u,         113930197630u },
  {  5530668968487988249u, 12767090573379150201u,         126451906793u },
  { 10083765740821947024u, 14736070002412246709u,         233692105366u },
  {  2798423656816843533u,  9697296975344560756u,         150798843955u },
  {  7614494481582904797u,  7291706381199103298u,          51525691522u },
  { 17811318500083423695u, 18098546597780825068u,         130395284194u },
  { 11641467412200329033u,   132913902678533478u,         226981124177u },
  { 17733593025296340645u,  1879347741692007580u,          81007205277u },
  {  3689424000190644835u,  4056624629214083684u,         157101879645u },
  { 14966634145516728506u, 14713227692042795499u,          93219910061u },
  { 14171681941562070109u,  7366415124022528526u,         173797605671u },
  {  8130575762882608170u,   825770353378039393u,          39399334164u },
  {  5234550794400656856u, 10244023944395357795u,          20044765100u },
  {  3020576149360486378u, 14302658294713551167u,         172555329650u },
  {  3038675756589057221u, 14246653166206862817u,         114775348659u },
  { 15470260187120878369u, 12404486258134291102u,         179772312615u },
  {  3497929414841828746u,  8887442218637942533u,          39672448547u },
  {  9935840636861015305u,  1186724038081863005u,          35481789208u },
  {  3647355485153741471u,   211331772484951576u,          24064332439u },
  {   766100215038272793u,  6311919513247413649u,         151011456318u },
  { 16128087474216800751u,  8131780018703965703u,          62342169842u },
  { 16216631732633731297u,  2262544347226725725u,         242440824678u },
  { 13760220872779997335u, 15318188749880522583u,         102122652774u },
  {  3826276262374222087u,  1073117094162650652u,         102830400676u },
  { 14938032745839181005u,  4447950380665871747u,         164058173794u },
  { 14479259995009508865u,  5373227185066463609u,          98241123873u },
  {  2372033248156102437u,  6739731406934274193u,          33291283229u },
  {   792005346826701645u, 12328812617001239444u,          29365361571u },
  { 16278924527931792559u,  3246111484407310759u,         163668346271u },
  { 17442516423538940144u,  3250825415176839770u,         159175972056u },
  {    13844184233048446u, 16146270540000862342u,         216176227598u },
  { 13486193870480782357u, 15686773375425916830u,          14875291079u },
  { 11931315179184648737u, 11920791905793880226u,         199850381688u },
  { 16492562205587485405u,  1853290561644080707u,         120646227424u },
  { 12128987217680380854u, 12157689141506159076u,         224100467082u },
  { 10568123814189138176u, 18100318838862562546u,         138659069648u },
  { 17007583519117541376u,  7171257882533475139u,         208981220250u },
  {   143791533903052800u, 14477550873015039462u,         154388754668u },
  { 12398714235792654336u,  8109481182495403274u,         236784829605u },
  {  9659957317919047680u, 14565395719337663965u,         165439615855u },
  {  9412523221204336640u,  1860318978161305991u,         111789591684u },
  {  4611686018427387904u, 16268646275151585618u,         132100848093u },
  {                    0u, 13759019338835519104u,         221881925081u },
  {                    0u, 17003783176010661888u,         217745877932u },
  {                    0u, 18357489540307877888u,         172921776932u },
  {                    0u,   905481790074912768u,          36995161502u },
  {                    0u,  3638882110636294144u,         158049086266u },
  {                    0u,  9011702854368362496u,          58197264194u },
  {                    0u, 11529215046068469760u,          66488525390u },
  {                    0u,                    0u,          78625000000u },
  {                    0u,                    0u,          64000000000u },
  {  3237900842885170729u,                  856u,                    0u },
  {  7515893506498066595u,         856175526956u,                    0u },
  {  7300206309181072546u,  7625299565768063067u,                   46u },
  {     5999737279837044u, 13889021769065194705u,          46413368317u },
  {  7556839307242450651u, 14498170692313014398u,         253752925378u },
  { 12946035041643640643u,  1541631360972245751u,         194785947408u },
  { 15885877642352740665u,  9903958882920799117u,          16083572003u },
  { 10770818348246089568u, 15744148547788062576u,          35536894686u },
  { 11635415503599551744u, 17936061801321712000u,         222853492002u },
  {  6248053924100826098u,  9986394078324430610u,          34972315858u },
  { 16894170802729859998u, 13849561248103430369u,         210541363507u },
  {  6143589029651889899u, 12142378807953854930u,          51750786219u },
  { 11812087701837886160u,  2513847703931031444u,         171658239674u },
  {  7306705080150829180u,  1752183758129038045u,         186136275957u },
  {  1485332570280714274u, 15824833342220556540u,         245094986071u },
  { 18042602303295630634u,  8168747198299470695u,          87857865934u },
  { 13397029889257074369u, 17414799840149357478u,         206442828672u },
  {  9948104869613411488u,    83147520704167789u,         128944058191u },
  { 10836066241170646532u,  2383542703041471269u,          79004507436u },
  { 18330574781234459389u, 15540952725549257799u,          44129212108u },
  {   666297360208433062u,  6949835416232048690u,         204842476735u },
  {  5035352224889324309u, 15398868937585367540u,         191376751332u },
  {  1341745796439923765u, 14710915985268256079u,         228834774357u },
  {  6846932182653803785u,  9665704836873335737u,          85797480353u },
  {  6727685027257825533u,  2528789298740305993u,         161523978909u },
  {  2168538874806877737u, 10562914675687726264u,         157137085942u },
  { 17694936100676971444u, 17671658300096837111u,         246572616751u },
  {  2163944241059563294u,   356471401631698552u,          47957982516u },
  {  6727780864524301558u,  7450677157218003204u,          52019324353u },
  {  8599551977795002615u,   317174560787152643u,         193403902018u },
  { 15428264807806859091u,  7251937674440720374u,          66017194067u },
  {  2126771385339683557u,  1252631516699038247u,          83393128329u },
  { 15094316562082972944u, 10818009768860843867u,         137067905290u },
  {  8111300598225956802u, 12330114194950162396u,          10586445484u },
  {  9481215200564260304u, 15826681638261168822u,         172668416829u },
  { 16836674128623424708u, 14240150078499211625u,          61857966130u },
  {  7087243115299722740u, 10725372116242125421u,          50771960082u },
  {  2343560867338408810u,  8434925524647833627u,          18581423587u },
  {  3431385749090422286u, 17133902668520348241u,         227457258228u },
  {  3504545517469224582u, 15093996047981365810u,         244928830724u },
  {  3333759805712094227u,  6187974166976813153u,           4818247165u },
  {  3595183476205994775u, 13946144707720259865u,         253335450751u },
  { 14191566632569921303u,  9138079832881862582u,         127756022019u },
  { 12917427671358095562u,  6600697628576225568u,           3495376300u },
  {  3883793922738316288u,  8137099536646556597u,         172357824535u },
  {  7857281689266421760u, 14169855543453903706u,          23441113049u },
  { 15987081651486195712u,  3706403268650100765u,         217768149408u },
  { 16827562156399525888u, 14736932266877982264u,         160200924523u },
  {  7012737938513461248u, 18004795125138956004u,         107798890698u },
  {  7385903388887613440u,  9068489270661002501u,         202976041899u },
  {                    0u,  7758835715193269217u,         171491603788u },
  {                    0u, 16943947811135261184u,          76420607326u },
  {                    0u,  6745843108403216384u,          94918533251u },
  {                    0u, 12338229654069444608u,         131365692887u },
  {                    0u, 14358176069683511296u,         215668856769u },
  {                    0u,  7083775185760813056u,         193778358284u },
  {                    0u,  5350276357316149248u,          12384012222u },
  {                    0u,  9223372036854775808u,         190290039062u },
  {                    0u,                    0u,          22500000000u },
  { 14135788013842776187u,             13064201u,                    0u },
  { 13284322918167594445u,    13064201766302603u,                    0u },
  {  7264587765474046287u, 14699116688460625612u,               708211u },
  { 16176482219778368741u,  6684126021499623499u,         115796840712u },
  {  5401983818872095469u, 12614606079692508506u,           8362347197u },
  { 11208857446851049921u, 15358270276683001489u,         189683839165u },
  { 13794690008281035639u, 18077126190953408995u,         189832573499u },
  { 14519782740993303071u,  7864121581925945659u,          59979962974u },
  { 10885858587044789123u,  3518026639210514839u,          94426314885u },
  {  8710500938899914621u,  4698310163811252280u,         133190712606u },
  {  1284182587483102819u,  6101155398200416338u,          30254695904u },
  { 10346074482131502030u, 16049178580360033341u,         224330744296u },
  {  9429804686255246574u,  3167464649127375997u,         232870027714u },
  {  6412022633845121254u, 12778923935480989904u,         194171708602u },
  {  8892351297529018260u, 11875553912612980379u,         186692746854u },
  { 14098160105983060597u, 10628760849351697057u,         102643775067u },
  { 13793833029739474340u,  3408944711673234310u,          91576186280u },
  { 16367653765996977044u,  2102091496050506178u,         168184799263u },
  { 10684788343333772342u,  6254611118630245760u,          31113954608u },
  { 13272681218705145345u,  2647941151989776368u,          48339063148u },
  { 11093568615497829248u,  8855437735410157458u,         108143545177u },
  { 12488220765137758124u, 10184270603132180103u,          89480054241u },
  {  3727114642519696453u, 12079083162535627164u,         225552090415u },
  { 11549865375695057514u,  5952952868716156729u,          47654808410u },
  { 11292809154908783229u, 11958907037815852320u,          90322710221u },
  { 17723904861837310998u, 10101562137321697626u,         205648293649u },
  { 14877674388187150875u, 13633527411279258327u,          17547606780u },
  { 12178961950105734308u, 16555627393501768728u,         252739075001u },
  {  4540604068069253114u,  6359650463500280706u,         185897482359u },
  { 13832478722153359868u,  8093923611102181967u,         119344757342u },
  {  1308046668730371491u,  2848827352928635726u,          94438772478u },
  { 18400531023544756800u,  4686723431961561511u,         254154435240u },
  {  9789823458621466539u,  6245554925867652609u,         168254067786u },
  {  1924870562610267306u, 17527406820792516033u,          74338572210u },
  {  5290016144582400923u, 12119966834653692210u,         178950162627u },
  { 15162883663174059077u, 11606502845877928061u,         195657024718u },
  {  8078086116520046390u,   424311496652297090u,         206629189780u },
  { 15731407332173190623u,  5977664048034127173u,         148023001972u },
  {  5346389182763011056u,  6702712461535947028u,         116324049817u },
  {  6368422217216252401u, 11384349854055020018u,         153363354770u },
  {  2961453088119116188u,  3782955013294836188u,         146617146842u },
  { 10932141691610170525u,  3531805968821207061u,         218205074402u },
  { 11034016191361782553u,  3867566898657193228u,         226191459585u },
  {  5455325785621453219u, 12688734637425072080u,           1209661221u },
  {  7735615202566149352u, 18435982764454619691u,          37687857682u },
  {  7502396497775759360u,  4728836163964677692u,          18999416628u },
  {  1601286435751591936u,  2120012917348838977u,          52256350722u },
  { 11449383158571597824u,  9856965465824679831u,           2114926130u },
  { 13043944595690356736u, 11217197671061248816u,          50534347168u },
  {  7773494431818186752u,  3840562972677739189u,         160608085504u },
  {  9943947977234055168u, 17104366978925258617u,            208197335u },
  {                    0u, 16177877219841993444u,         215927229591u },
  {                    0u,  7338522384267208704u,         151877004481u },
  {                    0u, 10935240458612244480u,         193397822095u },
  {                    0u,  1732868046462124032u,         143592800573u },
  {                    0u,   557965042578882560u,          61093938965u },
  {                    0u, 10454684322475540480u,          21030247345u },
  {                    0u, 13907115649320091648u,         177566749572u },
  {                    0u,                    0u,         132753906250u },
  {                    0u,                    0u,          74000000000u },
  {  6343817245135589714u,                  199u,                    0u },
  { 17549323075660516085u,         199343899021u,                    0u },
  {  3948641822109421754u, 14876458284855834550u,                   10u },
  {  1750739713693534543u, 10450704926982265198u,          10806454419u },
  {   962163898128633415u,  5385653213018257806u,         147566533849u },
  {  7967320249386531212u, 12735569669880147489u,         217291956845u },
  {  3018466665533383224u,  3619762560577729456u,         109690396615u },
  { 15076865731854945472u, 11123448126624084269u,         199196227721u },
  {   691187172844604400u,  4072715118852885633u,         137603003331u },
  { 13274492813370992341u, 18239087231420827283u,         195220782328u },
  {  6364168818499152300u,   423431461216085297u,         248988742900u },
  { 17599380787401914158u,  9360976716520160042u,         244022954265u },
  {  3782323149461692814u, 11655927117263208920u,          25507459564u },
  { 14470163442442237466u,  2646622721938364948u,         236631869075u },
  {   476109872130437939u,  4496462484548171852u,         147143473705u },
  { 16330548844673355700u, 13140258519803350063u,          41243753719u },
  { 14089158961463739563u, 13089764333320627770u,         247712334841u },
  { 13385510793074798805u,  6926286827289840501u,         249709597546u },
  {  1549401308746959012u,  4985580225290866218u,         106375474761u },
  {  4607384943843027435u, 10478790837359789693u,          73270268845u },
  {  5157353797716093483u, 10041191967455692214u,         173568056389u },
  { 10846828782671550129u,  5035461258013813797u,          69544334107u },
  {  9915857350819131531u, 14208759661559249750u,          27272972901u },
  {  1673544973504317923u, 12347272163241758840u,         101770258404u },
  { 14780986291622785694u,  3372534174410277614u,         228669346965u },
  {  8168111319515466401u, 17226704187274712984u,         149182825443u },
  { 16345760387859734482u,  4250480179449852121u,         227933861505u },
  {  3177475373321281805u,  4303723537755414374u,         129230418992u },
  {  2558676822419554038u,  8680503847344854165u,          48233305320u },
  {  8813474062662382873u,  8817608623911079652u,         232470571056u },
  {  5426294560236228430u,  5692030448698539450u,          48478003521u },
  {  9919177474128333040u, 16908836314686769809u,          65308565588u },
  {  6197383943089627371u,  6073762347067727240u,          84916629853u },
  { 13673239314867423997u, 10931066692585106200u,          93329259316u },
  {  9309584098968723946u, 14466591364061539596u,          52592574312u },
  {  4647101757759615504u,  4958077340960173341u,         104784235489u },
  {  1405809295505096753u,  4076890037156765715u,         225268777911u },
  { 11332704079573859112u, 14083973146609179058u,         183221008651u },
  {  2960072434514044308u,  2565183738039805295u,          11763493714u },
  {  3887266602785432801u,  1482420938751351224u,          82139058889u },
  { 14545546084687849554u,  2151089495335413944u,         201080362200u },
  {  4617763804182385321u,  3738604531753220913u,         216116610795u },
  {  7857823815580249095u, 14195686514836005765u,         235202670157u },
  { 10939326736548364798u, 17808833916231796970u,          77769549707u },
  { 12262012446566951953u,  1302384553035657354u,         139965418821u },
  { 12555024338687723023u,  1672033517974833698u,          69070602408u },
  {  3332969632922829472u, 11673925532927662545u,         168090641118u },
  { 15535060143360327680u,  3905334232240480709u,         222632844771u },
  { 15794322927987458048u, 17411087320267472625u,         227211708592u },
  { 10571474314433921024u, 16573305231063706617u,         176943856934u },
  { 16679514427547975680u, 15481103236037148354u,          38898440676u },
  { 16925653299565166592u,   907440704754420880u,         228839232288u },
  { 16717361816799281152u,  3224970785139077759u,          32049192459u },
  {                    0u, 10560826509734608144u,          11174826016u },
  {                    0u,  4700940027512659968u,          32572503552u },
  {                    0u,  9733694683502084096u,            254838469u },
  {                    0u,  1995535635724632064u,         197527664646u },
  {                    0u, 10629833226245373952u,           6108178203u },
  {                    0u, 15729384648544878592u,          27576244413u },
  {                    0u,  7205759403792793600u,         189852691650u },
  {                    0u,                    0u,         194390625000u },
  {                    0u,                    0u,         232000000000u },
  {  9335385384027907407u,              3041746u,                    0u },
  { 13237828406194798613u,     3041746506072255u,                    0u },
  { 15667486867836528863u,  7535526066623007027u,               164893u },
  { 17982325043592934313u, 11302146918409311588u,          29408501686u },
  { 17159117626917379189u,  2480833299122194801u,         182612690612u },
  {  8336208968408929657u, 11513226205589330558u,         180134486242u },
  { 12767090573379150201u,  4073957068281936105u,         226624133243u },
  { 14736070002412246709u,  3729887061093812886u,         123220849655u },
  {  9697296975344560756u, 13616911779739451443u,         247202197582u },
  {  7291706381199103298u, 13039053282195777666u,          78738174266u },
  { 18098546597780825068u, 14490756113210417890u,          58706848494u },
  {   132913902678533478u, 17432486112977557585u,         238785545462u },
  {  1879347741692007580u, 14308820825344039837u,         246945016965u },
  {  4056624629214083684u,  4190949538817536349u,         133775682731u },
  { 14713227692042795499u, 13616552502810964397u,         171227191829u },
  {  7366415124022528526u,  4898145803694965031u,          21738154790u },
  {   825770353378039393u,  1399036321001644308u,          38265529016u },
  { 10244023944395357795u, 17170331128243738540u,         184075841910u },
  { 14302658294713551167u, 10641321388205367410u,         118930805515u },
  { 14246653166206862817u,  6648873641312572851u,          11576867188u },
  { 12404486258134291102u,  5988456964560374823u,         116360436162u },
  {  8887442218637942533u,  9972593758348346915u,         194324634902u },
  {  1186724038081863005u, 16709668921872818968u,          22540615390u },
  {   211331772484951576u,  6094829131503407767u,         222905832967u },
  {  6311919513247413649u,  4892016478899926334u,           7330401349u },
  {  8131780018703965703u, 13150857244079031538u,          69265196744u },
  {  2262544347226725725u, 12983943395318785894u,         200712909399u },
  { 15318188749880522583u, 15341644584614757478u,          87703860981u },
  {  1073117094162650652u,  7507635124856644772u,         245831672219u },
  {  4447950380665871747u, 11619655367084544354u,         155406989715u },
  {  5373227185066463609u, 11553116952478783009u,         147629902779u },
  {  6739731406934274193u, 17392150014233193245u,         187626295724u },
  { 12328812617001239444u,  8877887560294980515u,         172942830341u },
  {  3246111484407310759u, 18404180619915609503u,           5481271248u },
  {  3250825415176839770u, 10079413095288181976u,         208997692630u },
  { 16146270540000862342u, 14102802966539105550u,         214546406078u },
  { 15686773375425916830u, 13333966026135891399u,         190764514480u },
  { 11920791905793880226u, 12344968670173516152u,         176722835746u },
  {  1853290561644080707u, 10577007819804726752u,          34669222092u },
  { 12157689141506159076u, 15337041354031088010u,         204573380742u },
  { 18100318838862562546u, 14333607285614673616u,         134831422677u },
  {  7171257882533475139u, 17171597563219696538u,         213777026407u },
  { 14477550873015039462u,  2849642930482147564u,         103930874169u },
  {  8109481182495403274u, 14791248423979435173u,          57154479452u },
  { 14565395719337663965u, 13882371364576310127u,          92801835183u },
  {  1860318978161305991u, 11735995808941329540u,         175752564859u },
  { 16268646275151585618u, 11376996674339273181u,         123636209607u },
  { 13759019338835519104u,  9849638057168043481u,         199616748225u },
  { 17003783176010661888u, 18241520229279361964u,         193533949948u },
  { 18357489540307877888u,  1865852368526961444u,         252988874793u },
  {   905481790074912768u, 10601487369276448158u,          41101148059u },
  {  3638882110636294144u, 15999931310312762170u,         155574707781u },
  {  9011702854368362496u,  5773775867713013570u,          69867358014u },
  { 11529215046068469760u, 17726239863982547534u,          62312997016u },
  {                    0u,  9711316695888316992u,         152960941388u },
  {                    0u, 17872002620723724288u,          76526451532u },
  {                    0u,  7429694208660733952u,          76968843203u },
  {                    0u,  1782821038871019520u,         195402764530u },
  {                    0u,  3225250234313474048u,         242096646922u },
  {                    0u, 10009250171830927360u,          10174841165u },
  {                    0u,  1152921504606846976u,          77542602539u },
  {                    0u,                    0u,          43062500000u },
  {                    0u,                    0u,         160000000000u },
  {  7625299565768063067u,                   46u,                    0u },
  { 13889021769065194705u,          46413368317u,                    0u },
  { 14498170692313014398u,  9519880170333822146u,                    2u },
  {  1541631360972245751u,  2285186318012886800u,           2516073738u },
  {  9903958882920799117u,  9706420951402272035u,          10123880198u },
  { 15744148547788062576u,  2369632031840402142u,           6526186134u },
  { 17936061801321712000u, 15599123897979399458u,         150128458009u },
  {  9986394078324430610u, 17579576584023912658u,          25845630200u },
  { 13849561248103430369u,  3480927339588501811u,         248952990756u },
  { 12142378807953854930u,  3547346616671294635u,          36188701449u },
  {  2513847703931031444u,  7705317123868384954u,           9192302045u },
  {  1752183758129038045u,  4969425237478353909u,         221417706078u },
  { 15824833342220556540u, 17043246700132217175u,          94269393081u },
  {  8168747198299470695u, 17053788362783499470u,         185923916254u },
  { 17414799840149357478u, 11102988228454224768u,         222924487719u },
  {    83147520704167789u, 16944305387801685839u,          39601894197u },
  {  2383542703041471269u, 11725142977459199276u,          53918552635u },
  { 15540952725549257799u,  8175984171998533324u,          59635621274u },
  {  6949835416232048690u,  1372352885142856895u,         154443220990u },
  { 15398868937585367540u, 17975093466502888164u,         254074395398u },
  { 14710915985268256079u,  6467823391459085653u,           6974431769u },
  {  9665704836873335737u, 11319386883146885025u,          25350621408u },
  {  2528789298740305993u,  9141999262922068637u,         224613625192u },
  { 10562914675687726264u,  1587330393383478774u,         104495588773u },
  { 17671658300096837111u,   884187548095712303u,         165086049353u },
  {   356471401631698552u,   488841225726377268u,          73047931903u },
  {  7450677157218003204u, 17462624199405856193u,         255026500135u },
  {   317174560787152643u, 13183677579115583554u,          39946650754u },
  {  7251937674440720374u, 11645015818917277779u,         130714688593u },
  {  1252631516699038247u,  8760523002035971977u,          81631277572u },
  { 10818009768860843867u, 10068817678491468042u,           4474908903u },
  { 12330114194950162396u,  1273658177787418284u,         231545831700u },
  { 15826681638261168822u,  3100019384328057661u,          20069045148u },
  { 14240150078499211625u, 10363063568089458738u,         156168052387u },
  { 10725372116242125421u, 13030756371481403666u,         163561782801u },
  {  8434925524647833627u,  6538878900684195299u,          17706398718u },
  { 17133902668520348241u,  8984884716779098868u,         254354473335u },
  { 15093996047981365810u,  8728727397070363908u,         119487071576u },
  {  6187974166976813153u,  6398650562917867005u,          88473185260u },
  { 13946144707720259865u,  1190873176164938879u,         236346871542u },
  {  9138079832881862582u,  4383628525805121795u,         246064557364u },
  {  6600697628576225568u, 10189374699734119852u,          52237636978u },
  {  8137099536646556597u,  5276291920541626391u,         114552367109u },
  { 14169855543453903706u,  2692252373800386521u,           5286028358u },
  {  3706403268650100765u, 11578684995169173920u,          70145947293u },
  { 14736932266877982264u,  5799408022254132587u,         157627681771u },
  { 18004795125138956004u, 15548569837712345290u,         235314386538u },
  {  9068489270661002501u, 15763030464322902955u,         106842889659u },
  {  7758835715193269217u, 13257749746581255500u,         187854515593u },
  { 16943947811135261184u, 16152470009188707678u,         137718704053u },
  {  6745843108403216384u, 13806790848493904003u,         181875627153u },
  { 12338229654069444608u, 11981226523265951191u,         145748467631u },
  { 14358176069683511296u,  5133628726077003713u,         175649503591u },
  {  7083775185760813056u, 16183955741910833164u,         103278294570u },
  {  5350276357316149248u, 13640425554331371454u,          42877333998u },
  {  9223372036854775808u, 18108120906868035862u,         238739448950u },
  {                    0u,  6324011669895037184u,         118981643201u },
  {                    0u, 10444437689515769856u,         193342825359u },
  {                    0u, 12324712543665782784u,         143566194101u },
  {                    0u, 13928941951563857920u,         181668124005u },
  {                    0u,  3975288688270639104u,         101755089456u },
  {                    0u, 11141905478114607104u,          48215500831u },
  {                    0u,  4611686018427387904u,          31604003906u },
  {                    0u,                    0u,          66250000000u },
  {                    0u,                    0u,         128000000000u },
  { 14699116688460625612u,               708211u,                    0u },
  {  6684126021499623499u,      708211796840712u,                    0u },
  { 12614606079692508506u,  4398362855256705725u,                38392u },
  { 15358270276683001489u,  2812083125569302717u,         248238435728u },
  { 18077126190953408995u, 12868509142973100603u,         144152443331u },
  {  7864121581925945659u,  8726243776748165726u,         195697603278u },
  {  3518026639210514839u,   358304413426858117u,         206473050623u },
  {  4698310163811252280u,  3180720351566429470u,         255019423721u },
  {  6101155398200416338u, 14053818240400098784u,         233172427195u },
  { 16049178580360033341u,  7340140541492429288u,         187761859013u },
  {  3167464649127375997u,  1323571167904965058u,         197397909816u },
  { 12778923935480989904u, 14463851737583396026u,          56071750936u },
  { 11875553912612980379u, 15122784818916048486u,          24784086973u },
  { 10628760849351697057u, 13557974621377508955u,         189819807807u },
  {  3408944711673234310u, 17525172074563876264u,          63734979276u },
  {  2102091496050506178u, 15148880683074215967u,         204950041481u },
  {  6254611118630245760u,  6744828147558597936u,         137821222467u },
  {  2647941151989776368u,  9799290779647971692u,          67365637866u },
  {  8855437735410157458u, 11170890203898678105u,         234531220617u },
  { 10184270603132180103u,  7068779781287527905u,         137605575171u },
  { 12079083162535627164u, 14474741922505540911u,           3383199319u },
  {  5952952868716156729u, 17107062680405191514u,          87784677331u },
  { 11958907037815852320u,  2712598571300237005u,         211927375726u },
  { 10101562137321697626u,  3767556054903418641u,         110147050263u },
  { 13633527411279258327u, 18158239681706277628u,          23204239622u },
  { 16555627393501768728u, 10531652712128330681u,           6984360145u },
  {  6359650463500280706u,  9548395326934120567u,         209570922037u },
  {  8093923611102181967u, 15875647850297719390u,          53517619547u },
  {  2848827352928635726u,  8215825295203192574u,          91860620594u },
  {  4686723431961561511u, 12747310908260543144u,          50445380781u },
  {  6245554925867652609u,    77706528053613642u,         173691033109u },
  { 17527406820792516033u,  6024737704056756146u,          21004212479u },
  { 12119966834653692210u,  6819452388570089667u,         255326601685u },
  { 11606502845877928061u, 13695926775373186254u,         213369683254u },
  {   424311496652297090u,  3746531715392682132u,          54742457678u },
  {  5977664048034127173u,  4717376233154528116u,          78203099891u },
  {  6702712461535947028u,   385190957950313369u,         243255729478u },
  { 11384349854055020018u, 12388374310648616082u,          70020881243u },
  {  3782955013294836188u,  1078067332084407770u,          91671575117u },
  {  3531805968821207061u,  3257295319358714850u,          77058442147u },
  {  3867566898657193228u,  1545453099660723457u,         163176578333u },
  { 12688734637425072080u,  7495477664653506341u,          29083779180u },
  { 18435982764454619691u,  7225503732673614354u,         108406330658u },
  {  4728836163964677692u,  3935478326103643956u,          34391695342u },
  {  2120012917348838977u, 10082240682742686210u,         238213342707u },
  {  9856965465824679831u, 10838712705567897138u,         243546559362u },
  { 11217197671061248816u,  2142546572501643680u,         130587567793u },
  {  3840562972677739189u,  7893042119150331392u,         177116147682u },
  { 17104366978925258617u, 12084811642251302615u,         226427882670u },
  { 16177877219841993444u, 15317234482572954775u,         174655118951u },
  {  7338522384267208704u,  2283226355108359361u,         103830348945u },
  { 10935240458612244480u, 13359725152575722127u,         145123773948u },
  {  1732868046462124032u, 13126551011491594557u,         252724232151u },
  {   557965042578882560u,  3598021288691861269u,         215711591756u },
  { 10454684322475540480u, 16462621795896662961u,          76195049124u },
  { 13907115649320091648u, 14682112756964627332u,         164892440515u },
  {                    0u,  7174112100896070218u,         195795918927u },
  {                    0u,  5023109019590616064u,          79388909396u },
  {                    0u, 10765223023086141440u,          84272303285u },
  {                    0u,  8228137177297453056u,         181583583909u },
  {                    0u,  2891199497780592640u,         165446048210u },
  {                    0u, 15294857653247803392u,         210156732238u },
  {                    0u, 14303432416528695296u,          78829135894u },
  {                    0u,                    0u,          22775390625u },
  {                    0u,                    0u,         161000000000u },
  { 14876458284855834550u,                   10u,                    0u },
  { 10450704926982265198u,          10806454419u,                    0u },
  {  5385653213018257806u, 10806454419566533849u,                    0u },
  { 12735569669880147489u, 17118225092618494573u,            585819067u },
  {  3619762560577729456u, 13385738875341807559u,         187927980841u },
  { 11123448126624084269u,  8272682717439277193u,          41725642358u },
  {  4072715118852885633u, 13402436483369350083u,         118448463028u },
  { 18239087231420827283u, 10946328903241612536u,         180726547537u },
  {   423431461216085297u, 16265808923426731252u,          81593401678u },
  {  9360976716520160042u, 11080374459871185177u,          78881771268u },
  { 11655927117263208920u,  1240761893433831916u,           4600668303u },
  {  2646622721938364948u,   367264070493390483u,         143067261837u },
  {  4496462484548171852u,  2863675693461092905u,         141019909425u },
  { 13140258519803350063u,  7511929581752138999u,          49155240170u },
  { 13089764333320627770u, 11154557789993845753u,         234407222518u },
  {  6926286827289840501u,  8325416539745948522u,         246604689789u },
  {  4985580225290866218u, 17745129874679852617u,         125451321734u },
  { 10478790837359789693u,  1074820986392253357u,         134961965418u },
  { 10041191967455692214u,  7820952682162838597u,         106058266162u },
  {  5035461258013813797u,  8215518006273528603u,          50423974694u },
  { 14208759661559249750u,  9680426791089900133u,          38445364123u },
  { 12347272163241758840u, 16128495723604797412u,         155524776987u },
  {  3372534174410277614u,  2264789053583348885u,          27874327505u },
  { 17226704187274712984u, 11175458488686298083u,         209122774460u },
  {  4250480179449852121u, 11026777810412287617u,         188605822818u },
  {  4303723537755414374u, 16199890034895598640u,          98597762822u },
  {  8680503847344854165u,  9094320719494763752u,           6878197798u },
  {  8817608623911079652u,  1250835564687222832u,          38493004114u },
  {  5692030448698539450u, 15362466642459337025u,          82067807931u },
  { 16908836314686769809u,  7831109835595423828u,         187832800985u },
  {  6073762347067727240u, 15426237284335022429u,         217424525314u },
  { 10931066692585106200u, 15636308361455434548u,           2836257998u },
  { 14466591364061539596u, 13967173875944980328u,         206847645974u },
  {  4958077340960173341u, 18245979923595824097u,          22757162012u },
  {  4076890037156765715u, 11335054479675278263u,          28989116553u },
  { 14083973146609179058u, 11165339882630461707u,         137614474534u },
  {  2565183738039805295u, 15944437408299395922u,          38605274287u },
  {  1482420938751351224u, 15806416348777321161u,         175864349683u },
  {  2151089495335413944u,  4201030477408556248u,         243856867547u },
  {  3738604531753220913u,  9485474942554588907u,         219227738318u },
  { 14195686514836005765u, 18238757647663230541u,         206514208626u },
  { 17808833916231796970u,  4642199687824746379u,         114988725033u },
  {  1302384553035657354u,  6134575894869364037u,          41251654149u },
  {  1672033517974833698u, 11524208547121316008u,           5332556025u },
  { 11673925532927662545u,  2734683241527878366u,         249624728597u },
  {  3905334232240480709u, 10629223456178675171u,          21148247475u },
  { 17411087320267472625u,  2788042336985254064u,         179576211358u },
  { 16573305231063706617u, 17285498758066142502u,         158151140077u },
  { 15481103236037148354u,  5525538192421886436u,         237937048765u },
  {   907440704754420880u, 11414325503043801888u,         189299540025u },
  {  3224970785139077759u,  7246608114685173259u,          57618771825u },
  { 10560826509734608144u,  1007884269852184608u,         113392839413u },
  {  4700940027512659968u, 13823717876510029312u,         245054637515u },
  {  9733694683502084096u, 12487410768239429317u,         203749385247u },
  {  1995535635724632064u,  3361062421598631942u,          31676943894u },
  { 10629833226245373952u, 17853337379088328475u,          22182203558u },
  { 15729384648544878592u, 11551561037491869885u,         166967831358u },
  {  7205759403792793600u, 11480877996635204802u,          62626211378u },
  {                    0u,  5527488381934471912u,          50622379643u },
  {                    0u, 11143438404407726080u,         123299645745u },
  {                    0u,  6472279730688098304u,          49604087006u },
  {                    0u,  4561816853579563008u,         222350862987u },
  {                    0u,  2888714464062865408u,         139247296587u },
  {                    0u, 16258276129784201216u,          75156597524u },
  {                    0u,   720575940379279360u,          20881362915u },
  {                    0u,                    0u,         227039062500u },
  {                    0u,                    0u,         228000000000u },
  {  7535526066623007027u,               164893u,                    0u },
  { 11302146918409311588u,      164893408501686u,                    0u },
  {  2480833299122194801u, 16409970870640346804u,                 8938u },
  { 11513226205589330558u,  7721907286269370594u,         234889586303u },
  {  4073957068281936105u, 14300743897882155131u,         127418605432u },
  {  3729887061093812886u,  2068482633821123575u,         120775244880u },
  { 13616911779739451443u,  4922882895416406094u,          80112132668u },
  { 13039053282195777666u,  9317632875623428410u,          60266870016u },
  { 14490756113210417890u,  5693844901999766254u,            505109890u },
  { 17432486112977557585u, 11569484900262102262u,         130308663950u },
  { 14308820825344039837u,  3138170119352085637u,         142627183033u },
  {  4190949538817536349u,   950584692575235243u,         185170120543u },
  { 13616552502810964397u,  8136430299747162645u,          95051531299u },
  {  4898145803694965031u,  6698711700804594470u,          35441076770u },
  {  1399036321001644308u, 17401191571004302008u,          34363137888u },
  { 17170331128243738540u,  4721732028538188150u,          96943320485u },
  { 10641321388205367410u,  2984214103553086219u,         165255965606u },
  {  6648873641312572851u, 13128675202005662068u,         166161774570u },
  {  5988456964560374823u, 14638512997670672834u,         234711706908u },
  {  9972593758348346915u, 12942085665769692438u,          28793555379u },
  { 16709668921872818968u, 14131134357119205086u,         179701591869u },
  {  6094829131503407767u,  8921946894736102919u,          61766050328u },
  {  4892016478899926334u,  5601522560505809989u,          24483659710u },
  { 13150857244079031538u,  8602606493507716808u,         190303659146u },
  { 12983943395318785894u,  8576789731078566487u,         138466348232u },
  { 15341644584614757478u, 17881118138842658549u,         200464948702u },
  {  7507635124856644772u, 11624372674432704923u,         222969337356u },
  { 11619655367084544354u,  6826284072848095635u,          12630158505u },
  { 11553116952478783009u,  1646466632033733563u,         169370053601u },
  { 17392150014233193245u, 17871081657060299180u,         225089255134u },
  {  8877887560294980515u, 15910893124677544709u,         222968793277u },
  { 18404180619915609503u, 11031217459450580944u,         189862531244u },
  { 10079413095288181976u, 13554987390037243094u,         172598003496u },
  { 14102802966539105550u, 15026714590903687870u,          40734817338u },
  { 13333966026135891399u,  4406379654994689200u,          58814599830u },
  { 12344968670173516152u, 13596329092861950242u,         150238870319u },
  { 10577007819804726752u,   284812388227373260u,          47737058477u },
  { 15337041354031088010u,  9285079159392309382u,         173015439710u },
  { 14333607285614673616u, 15046108141952711893u,          94503345149u },
  { 17171597563219696538u, 13795366909944958311u,         253815651156u },
  {  2849642930482147564u, 12909920641180059961u,          84747848338u },
  { 14791248423979435173u,  5333762939889788252u,         146699848200u },
  { 13882371364576310127u,  6411331390005944495u,           8289143868u },
  { 11735995808941329540u,  1447104583224217723u,          60347558971u },
  { 11376996674339273181u, 11940049226167932871u,          59078447696u },
  {  9849638057168043481u,  9772290783590472385u,          80647271365u },
  { 18241520229279361964u, 16351989577831528444u,         197529756944u },
  {  1865852368526961444u,  4376738725895725097u,          16886443131u },
  { 10601487369276448158u, 13851276297739812763u,         123237263481u },
  { 15999931310312762170u, 12641996203470333509u,         121750879192u },
  {  5773775867713013570u,  7707081716407945022u,         216685323987u },
  { 17726239863982547534u,   417638323657040024u,         211417801737u },
  {  9711316695888316992u, 16438047707692449100u,           9022640218u },
  { 17872002620723724288u, 14850108107043306316u,          90891108351u },
  {  7429694208660733952u, 10423290807904720835u,         255805025973u },
  {  1782821038871019520u, 16951162310302339314u,         181565047726u },
  {  3225250234313474048u,  2752437506572397322u,         174918924350u },
  { 10009250171830927360u,  3925815842962784589u,          62149209936u },
  {  1152921504606846976u,  5274166674003605291u,          80212818903u },
  {                    0u,  5538963350863452832u,         215285913148u },
  {                    0u, 16900671634439028736u,          60300267804u },
  {                    0u,  2326997710751662080u,          28916187245u },
  {                    0u, 12327726161625874432u,         109126146798u },
  {                    0u,  5756455743825903616u,         238668287374u },
  {                    0u,  3018537650245074944u,         142312058091u },
  {                    0u, 16717361816799281152u,         235163635253u },
  {                    0u,                    0u,          53906250000u },
  {                    0u,                    0u,          16000000000u },
  {  2285186318012886800u,           2516073738u,                    0u },
  {  9706420951402272035u,  2516073738123880198u,                    0u },
  {  2369632031840402142u, 11997425759292732054u,            136396630u },
  { 15599123897979399458u, 11491152661270395161u,          86650381753u },
  { 17579576584023912658u, 18181063258234881272u,         185622936633u },
  {  3480927339588501811u,  2466921813123869732u,          57985597414u },
  {  3547346616671294635u,  8430880678232179465u,         230133732099u },
  {  7705317123868384954u,  6738034873677997533u,           3457038957u },
  {  4969425237478353909u,  7678250951042929246u,         109365269602u },
  { 17043246700132217175u,  1853560606315563193u,          98416238818u },
  { 17053788362783499470u, 14942676593409905118u,         226100481721u },
  { 11102988228454224768u,  4909892170837638183u,         185810044121u },
  { 16944305387801685839u, 16871149368312132405u,         217266165787u },
  { 11725142977459199276u, 16096130589333770811u,          27914586839u },
  {  8175984171998533324u, 12512479187631824282u,         215872572987u },
  {  1372352885142856895u, 16980304980540557310u,          59678302855u },
  { 17975093466502888164u,  8640919162749295366u,         135920504177u },
  {  6467823391459085653u,  7862382415464063513u,         113468425166u },
  { 11319386883146885025u, 14534157903009925344u,         206426220604u },
  {  9141999262922068637u, 12627464554215107944u,          60787898278u },
  {  1587330393383478774u,  2456849734836299173u,         166684536225u },
  {   884187548095712303u, 18428252197697827913u,         161133186090u },
  {   488841225726377268u,  7244734215936736255u,          42998997553u },
  { 17462624199405856193u, 14756175050504770087u,          49392737828u },
  { 13183677579115583554u,  6764116534566945922u,          36799933852u },
  { 11645015818917277779u,  1588822142405565521u,         156366683492u },
  {  8760523002035971977u, 17053265624843842052u,         100086130220u },
  { 10068817678491468042u, 16996891591759999207u,          44924459381u },
  {  1273658177787418284u,  8565556232370585876u,         117921403339u },
  {  3100019384328057661u, 14464960359145886620u,         203464339733u },
  { 10363063568089458738u,  5813189542048784035u,          21784147072u },
  { 13030756371481403666u,  9739241026882027025u,         128315133636u },
  {  6538878900684195299u, 18175068535675302910u,         196527965313u },
  {  8984884716779098868u, 10562697212061761911u,         129985272439u },
  {  8728727397070363908u,  4264834835660801368u,         119572604963u },
  {  6398650562917867005u, 13019066443690126316u,          35231197159u },
  {  1190873176164938879u,  1828040177823321846u,         231705765006u },
  {  4383628525805121795u, 11240369830376975668u,         142099098256u },
  { 10189374699734119852u,  8886938465302549874u,         144609341669u },
  {  5276291920541626391u,  9985240313589688325u,         229481761899u },
  {  2692252373800386521u,   722909126956573766u,         107541300962u },
  { 11578684995169173920u,  5493363474638452381u,         226039188982u },
  {  5799408022254132587u, 12410535279213120491u,         246297795830u },
  { 15548569837712345290u, 10543108918366869098u,         246672776465u },
  { 15763030464322902955u, 12953909016524823995u,          17571543079u },
  { 13257749746581255500u, 16505942145872588169u,          39702232814u },
  { 16152470009188707678u, 12428594380392015797u,         238894788916u },
  { 13806790848493904003u,  7528259605829768337u,          52673755451u },
  { 11981226523265951191u, 18147447600042811311u,          59408107770u },
  {  5133628726077003713u, 12021069431116183911u,         250983775105u },
  { 16183955741910833164u, 11819985069665662506u,         129651663479u },
  { 13640425554331371454u, 10401877114068152814u,         119640762674u },
  { 18108120906868035862u,  4611631138117837942u,          50563886888u },
  {  6324011669895037184u, 17200813398607252417u,          40249997024u },
  { 10444437689515769856u, 14100466137553658767u,         224932457962u },
  { 12324712543665782784u, 17887776768825509301u,         234764387800u },
  { 13928941951563857920u, 12632656857970087269u,         216969698321u },
  {  3975288688270639104u,  8923681664054686256u,          17684817700u },
  { 11141905478114607104u,  6213926103737837599u,          36483753752u },
  {  4611686018427387904u,  1233118281776157762u,          24336857609u },
  {                    0u,    30716279628678784u,           9066847476u },
  {                    0u, 15775734650898546688u,         244001665132u },
  {                    0u,   976806005729918976u,         108855204289u },
  {                    0u, 12460098853279891456u,         193052952759u },
  {                    0u,  5635665595421687808u,         183675463312u },
  {                    0u,  1805943450575568896u,         144305510044u },
  {                    0u, 11529215046068469760u,         156097900390u },
  {                    0u,                    0u,         102625000000u },
  {                    0u,                    0u,          64000000000u },
  {  4398362855256705725u,                38392u,                    0u },
  {  2812083125569302717u,       38392238435728u,                    0u },
  { 12868509142973100603u,  4564018338575530435u,                 2081u },
  {  8726243776748165726u, 16553437246451512014u,          33247415929u },
  {   358304413426858117u,  4339777136957372927u,         121897363631u },
  {  3180720351566429470u, 18439463366554654697u,         175235259789u },
  { 14053818240400098784u,  1370067356680643003u,         141999605312u },
  {  7340140541492429288u,  4210124040914115013u,          64074271500u },
  {  1323571167904965058u, 10692225626142609720u,          12228231281u },
  { 14463851737583396026u, 11592856673895384344u,         113579626712u },
  { 15122784818916048486u, 10284479231227406269u,         216628450019u },
  { 13557974621377508955u,  4961071383534266431u,         227557522736u },
  { 17525172074563876264u, 10960611551445686988u,          48268940218u },
  { 15148880683074215967u, 14616396723115619209u,         186594175942u },
  {  6744828147558597936u,  1025604265437492803u,         198792356454u },
  {  9799290779647971692u, 11711588454892179178u,         102055598118u },
  { 11170890203898678105u,  5580373263251565705u,          38634886482u },
  {  7068779781287527905u, 14109334653033148931u,          82302512640u },
  { 14474741922505540911u,  2899414033769399895u,            764868564u },
  { 17107062680405191514u, 13233457234892808147u,         212157177549u },
  {  2712598571300237005u,  3287946691509034862u,         205717387154u },
  {  3767556054903418641u,  5488480288717445911u,         146178239947u },
  { 18158239681706277628u, 11687233053874362630u,         203297531112u },
  { 10531652712128330681u,  6783772100089274577u,         232633566173u },
  {  9548395326934120567u,  7898291058728402485u,         221367749022u },
  { 15875647850297719390u,  4423684977486598491u,         158428167216u },
  {  8215825295203192574u,  2750833684599526706u,          48239808443u },
  { 12747310908260543144u, 15669689830489025709u,         187149122992u },
  {    77706528053613642u, 15117307274214954517u,         176849455587u },
  {  6024737704056756146u,  8148639818575698175u,         227819510869u },
  {  6819452388570089667u, 13006484426078994901u,          85441738649u },
  { 13695926775373186254u, 10287496057845513526u,         153705082933u },
  {  3746531715392682132u, 14159876032966532430u,          53557686278u },
  {  4717376233154528116u, 15742212196465548019u,           6767608417u },
  {   385190957950313369u,  2892220461917134150u,          97853387033u },
  { 12388374310648616082u,  7487151560715393883u,          25156787585u },
  {  1078067332084407770u,  7245756744165177933u,         129405879299u },
  {  3257295319358714850u,  3067122860671533987u,           3392793260u },
  {  1545453099660723457u,  8135043905834122525u,         172166269063u },
  {  7495477664653506341u, 14730019368921022572u,         135441001613u },
  {  7225503732673614354u,   495969939682055458u,         141798515950u },
  {  3935478326103643956u,  5617761407265775598u,         238026886584u },
  { 10082240682742686210u,  2087044847072781811u,         184304539456u },
  { 10838712705567897138u, 15929674232061203330u,          64113138927u },
  {  2142546572501643680u,  8658086469608285873u,         239863549370u },
  {  7893042119150331392u, 18369871790780313570u,         186469355807u },
  { 12084811642251302615u,  3545648451947416750u,          31995832745u },
  { 15317234482572954775u, 13347376792767929959u,         169192209987u },
  {  2283226355108359361u, 14482164459838203025u,          67723562745u },
  { 13359725152575722127u,  8899577765623565820u,         249785079708u },
  { 13126551011491594557u,  7095320096604405719u,         156482447077u },
  {  3598021288691861269u,  2968593824439315788u,         229384638073u },
  { 16462621795896662961u, 12621408323612585636u,         121160927793u },
  { 14682112756964627332u,  3954422936414648259u,          49684207916u },
  {  7174112100896070218u, 17143730087577690191u,          44214369696u },
  {  5023109019590616064u,  5033045529399041876u,         160929363470u },
  { 10765223023086141440u, 15857648521994521781u,          14272841944u },
  {  8228137177297453056u, 16655573486499109541u,         216859644848u },
  {  2891199497780592640u, 16652154439190075858u,         176902900447u },
  { 15294857653247803392u, 18016950600164130638u,         223902715100u },
  { 14303432416528695296u,  2086292996072613910u,         220976700849u },
  {                    0u, 17324462585194799521u,         177113098169u },
  {                    0u, 11079151463184927232u,         185939160998u },
  {                    0u,  5239846817488961536u,         166600602004u },
  {                    0u,  2778806963520143360u,         148284052665u },
  {                    0u,  6240890740138835968u,         185150639427u },
  {                    0u, 17250651344549707776u,          67338319364u },
  {                    0u,  4197354852709302272u,           4935159683u },
  {                    0u,  9223372036854775808u,         131227539062u },
  {                    0u,                    0u,         118500000000u },
  { 17118225092618494573u,            585819067u,                    0u },
  { 13385738875341807559u,   585819067927980841u,                    0u },
  {  8272682717439277193u,  5654803392547571318u,             31757315u },
  { 13402436483369350083u,  2931628102185393332u,           3306547506u },
  { 10946328903241612536u, 15964697617980212305u,          50158923877u },
  { 16265808923426731252u,   450380868305846606u,         101865447992u },
  { 11080374459871185177u, 14631133530814566148u,          56024415195u },
  {  1240761893433831916u,    31969822783742095u,         219793155338u },
  {   367264070493390483u, 10437269029385743245u,          10001733087u },
  {  2863675693461092905u, 15196146496377392433u,         223565805487u },
  {  7511929581752138999u,  4409099735137480938u,         175823784752u },
  { 11154557789993845753u, 10644987914903248118u,          48239017775u },
  {  8325416539745948522u,  3154431617534062973u,          47577065951u },
  { 17745129874679852617u, 11702056331247960454u,         223171002080u },
  {  1074820986392253357u, 15575315065965259114u,         224634369744u },
  {  7820952682162838597u, 10759747609480050226u,         208844339521u },
  {  8215518006273528603u, 12538236653960743718u,          65583287086u },
  {  9680426791089900133u, 17857942663978005403u,          46679699170u },
  { 16128495723604797412u, 11443004154750813211u,         226968081011u },
  {  2264789053583348885u,  4004313188770806737u,         115620326498u },
  { 11175458488686298083u, 17134872954824183228u,          98217074252u },
  { 11026777810412287617u,  2659553912986171234u,          76928883324u },
  { 16199890034895598640u,  9501854300969137926u,         124144174706u },
  {  9094320719494763752u, 14528169966301018150u,         114515096553u },
  {  1250835564687222832u, 18172091996515901778u,         233787573671u },
  { 15362466642459337025u,  1133541705604751035u,         167985111081u },
  {  7831109835595423828u, 18280349987988641497u,          41061449418u },
  { 15426237284335022429u,  9936015874712336386u,         202990979758u },
  { 15636308361455434548u, 15876720399740689614u,         174538632499u },
  { 13967173875944980328u,  8618117825152456982u,          51860678737u },
  { 18245979923595824097u,  8085525680745921564u,          81467189103u },
  { 11335054479675278263u,  8072355444669730953u,         111438317225u },
  { 11165339882630461707u,  9395030504766848294u,         169437603265u },
  { 15944437408299395922u,  3537903114058185903u,         193509305624u },
  { 15806416348777321161u,  2126094743961928691u,          24191790112u },
  {  4201030477408556248u,   289185362555601115u,          32115255827u },
  {  9485474942554588907u, 16909937501450129614u,          19015676769u },
  { 18238757647663230541u, 14449642060360499058u,          97916689548u },
  {  4642199687824746379u, 12433818908498244393u,         140783316665u },
  {  6134575894869364037u, 11884444034578008581u,         185674038673u },
  { 11524208547121316008u,   988625838444140793u,         145644257002u },
  {  2734683241527878366u,  1675370907158909973u,         234053593514u },
  { 10629223456178675171u, 15920186275316934067u,         170090822038u },
  {  2788042336985254064u,  5600921198503757726u,         150863035027u },
  { 17285498758066142502u, 10457357161776341741u,         147303626546u },
  {  5525538192421886436u, 12225356765775740093u,          50566894467u },
  { 11414325503043801888u,  4486633318598164537u,         131662737918u },
  {  7246608114685173259u, 10302486602879381361u,         254243220879u },
  {  1007884269852184608u, 15536428611301239541u,         143558498917u },
  { 13823717876510029312u, 12026126645955462603u,         101842231482u },
  { 12487410768239429317u, 14877968141142123551u,         186651937631u },
  {  3361062421598631942u,   734560801645383190u,          95806536269u },
  { 17853337379088328475u, 15648943144911081638u,          77039820620u },
  { 11551561037491869885u, 13664182862003235646u,          76848330907u },
  { 11480877996635204802u,  3895127525902132786u,         155740736837u },
  {  5527488381934471912u,  5249187334214137467u,          69211155286u },
  { 11143438404407726080u, 10642260063359027505u,          86284559015u },
  {  6472279730688098304u,   783598951897779422u,         167576918074u },
  {  4561816853579563008u,  5538576558607624843u,          58042478984u },
  {  2888714464062865408u, 15974581187564609611u,         136300246836u },
  { 16258276129784201216u,  7474269406918257428u,          52865983781u },
  {   720575940379279360u,  8045286838779138019u,          37405180956u },
  {                    0u,  8184246376556341732u,          28436135873u },
  {                    0u,  1493267152679331840u,         193443668885u },
  {                    0u, 10179074811222818816u,         149080950174u },
  {                    0u,  3892499202005008384u,         158551808751u },
  {                    0u, 10341173215925108736u,         239211012804u },
  {                    0u,  6230307872002015232u,         196560596123u },
  {                    0u,  9295429630892703744u,         155337745666u },
  {                    0u,                    0u,           2503906250u },
  {                    0u,                    0u,         202000000000u },
  { 16409970870640346804u,                 8938u,                    0u },
  {  7721907286269370594u,        8938889586303u,                    0u },
  { 14300743897882155131u, 10665454627995623288u,                  484u },
  {  2068482633821123575u, 16803537892767562832u,         228578175453u },
  {  4922882895416406094u,  8099123106849104444u,         221910921614u },
  {  9317632875623428410u,  7077413686679401728u,         142439054343u },
  {  5693844901999766254u, 13536636358372449666u,           7383667364u },
  { 11569484900262102262u,  7280632235418610318u,         164733822527u },
  {  3138170119352085637u,  6187823673116858809u,          63394683864u },
  {   950584692575235243u,  8624343686231740255u,         216335442593u },
  {  8136430299747162645u,   806211610822132771u,         161467526608u },
  {  6698711700804594470u, 18388078233202190882u,         208043704818u },
  { 17401191571004302008u,  7628864426595573600u,         242996819718u },
  {  4721732028538188150u,  4530799784343874981u,           6413561569u },
  {  2984214103553086219u,  8561580552078486438u,         225245615148u },
  { 13128675202005662068u, 13349114951221999594u,          44464124211u },
  { 14638512997670672834u, 10029144738508991772u,          51723656971u },
  { 12942085665769692438u, 12601907197916268979u,          11543681025u },
  { 14131134357119205086u,  1329580921391066941u,           1683150758u },
  {  8921946894736102919u,  3198179786356761112u,         166072076726u },
  {  5601522560505809989u, 11406753413634654142u,         182173373673u },
  {  8602606493507716808u, 11131812960525182090u,         233618361341u },
  {  8576789731078566487u, 14299636753645227208u,         253603456789u },
  { 17881118138842658549u, 12964114684643663326u,          21775184861u },
  { 11624372674432704923u,  5019257593846306316u,         221702786065u },
  {  6826284072848095635u,  6929086798159998121u,          17272094499u },
  {  1646466632033733563u, 18359765766933703649u,          35375626547u },
  { 17871081657060299180u,  9993076234752063198u,          51995284896u },
  { 15910893124677544709u,  3257189215046584509u,         160541725748u },
  { 11031217459450580944u,  2905234736672690348u,          52176572581u },
  { 13554987390037243094u, 12064985302079670056u,         165157493090u },
  { 15026714590903687870u, 14315096064942799930u,          98654044163u },
  {  4406379654994689200u, 11943971043551974038u,           3776022912u },
  { 13596329092861950242u, 12472773152119929647u,         128647483967u },
  {   284812388227373260u,  7791259796982183085u,          63676150387u },
  {  9285079159392309382u, 16866829442051086686u,         115422365039u },
  { 15046108141952711893u,  3702498393844653053u,         111914352656u },
  { 13795366909944958311u,  2057239613841701716u,          16200712840u },
  { 12909920641180059961u, 17201969976738286226u,         136111523182u },
  {  5333762939889788252u, 18271566505443461640u,         110932520660u },
  {  6411331390005944495u, 18368509115417119804u,         212990503604u },
  {  1447104583224217723u,  7613923684154518587u,         180995758874u },
  { 11940049226167932871u, 17984805084714865232u,          26412751629u },
  {  9772290783590472385u,  4220802739051410373u,          13974958237u },
  { 16351989577831528444u, 17812459042810815760u,         157228810174u },
  {  4376738725895725097u, 10629526089664605307u,         190965615339u },
  { 13851276297739812763u, 17437443267816548473u,         235576227763u },
  { 12641996203470333509u, 12506371893701049304u,         179945285693u },
  {  7707081716407945022u, 15737221540003030739u,          61677971778u },
  {   417638323657040024u,  2358380859011605513u,          66853116489u },
  { 16438047707692449100u, 10042972713837039706u,          73127848082u },
  { 14850108107043306316u, 13424397272769642495u,         146544430641u },
  { 10423290807904720835u,  6867102315755663029u,          49727738034u },
  { 16951162310302339314u,  8690748404825506734u,         178372266362u },
  {  2752437506572397322u,   956229930815387710u,         122471126415u },
  {  3925815842962784589u,  7734449506297687888u,         143051837328u },
  {  5274166674003605291u, 16332184961683848151u,         144419285347u },
  {  5538963350863452832u, 15580777817612768828u,          99885369520u },
  { 16900671634439028736u, 17404245271944696092u,         176844635657u },
  {  2326997710751662080u, 13201420160494469229u,           9943486026u },
  { 12327726161625874432u, 16511717657124068078u,          74715650420u },
  {  5756455743825903616u, 14131292492116594062u,         116895102007u },
  {  3018537650245074944u, 18429136031865875691u,          55766058900u },
  { 16717361816799281152u,  2563978348305862197u,         148999045466u },
  {                    0u, 14239974392147482896u,          90138993544u },
  {                    0u, 11164201396098998272u,         136771950558u },
  {                    0u,  7116971104932986880u,         222605212570u },
  {                    0u, 12437629862867369984u,         154385811776u },
  {                    0u, 16501893821638901760u,          64674245265u },
  {                    0u, 10649324268870959104u,         145894569456u },
  {                    0u,  7205759403792793600u,         240577301025u },
  {                    0u,                    0u,          33390625000u },
  {                    0u,                    0u,         232000000000u },
  { 11997425759292732054u,            136396630u,                    0u },
  { 11491152661270395161u,   136396630650381753u,                    0u },
  { 18181063258234881272u,  3016823727048309817u,              7394076u },
  {  2466921813123869732u, 17405973192644624358u,          28163542341u },
  {  8430880678232179465u,  8937219978302591747u,          69943579697u },
  {  6738034873677997533u, 15178463196824222317u,          49484487665u },
  {  7678250951042929246u, 11979404627460330594u,         241822826138u },
  {  1853560606315563193u,  2006448052689740002u,         154649404826u },
  { 14942676593409905118u, 16330465320863239865u,         154108769766u },
  {  4909892170837638183u, 17136208883957646553u,         230885276298u },
  { 16871149368312132405u,   140455118208931867u,         138928955745u },
  { 16096130589333770811u,  3964972929179372247u,          97007614087u },
  { 12512479187631824282u,  3378050330022776379u,         135214941613u },
  { 16980304980540557310u,  6065353437512901255u,         173183124475u },
  {  8640919162749295366u, 12768753059854699889u,         251328803468u },
  {  7862382415464063513u,  6848720690951013326u,         140692195490u },
  { 14534157903009925344u, 10953228058585475132u,         162371269892u },
  { 12627464554215107944u, 15539127852083296166u,           4593775682u },
  {  2456849734836299173u, 14534853647735598497u,          66842377808u },
  { 18428252197697827913u,  1506909603576368170u,          80787935995u },
  {  7244734215936736255u,  5475702579938239025u,         251081689733u },
  { 14756175050504770087u, 12039747373985783332u,         133296838431u },
  {  6764116534566945922u, 17572399137760898460u,          31652676012u },
  {  1588822142405565521u,   869552790852091236u,         172952601666u },
  { 17053265624843842052u,  4549585778048181804u,          66047138551u },
  { 16996891591759999207u,  4121918231767210357u,         247246633539u },
  {  8565556232370585876u,  1558397953312543179u,          67223449635u },
  { 14464960359145886620u,  6067524298738069781u,          35084480922u },
  {  5813189542048784035u,  5811095224555517056u,         154328921151u },
  {  9739241026882027025u,  6440894514158997188u,          63315020103u },
  { 18175068535675302910u,  4612748874388784257u,          71349161591u },
  { 10562697212061761911u,  9908101430749813367u,         119250057617u },
  {  4264834835660801368u, 15150017990912190499u,         145537119254u },
  { 13019066443690126316u, 17470426264690059239u,          22821284120u },
  {  1828040177823321846u,  9615161096851907726u,          24947073705u },
  { 11240369830376975668u,  9227932132124142224u,         169521238927u },
  {  8886938465302549874u,  4794113194321211621u,         143500247203u },
  {  9985240313589688325u,   391512698859146347u,         163259889397u },
  {   722909126956573766u, 17209658878068655842u,         245021223945u },
  {  5493363474638452381u,  3077364726606876150u,           9932937477u },
  { 12410535279213120491u,  1952989567673965814u,           5166824276u },
  { 10543108918366869098u, 11172860676923186449u,          84105871776u },
  { 12953909016524823995u, 17338078544784947239u,         160605681990u },
  { 16505942145872588169u,  4593380466519703278u,          70939899121u },
  { 12428594380392015797u,   786884753602720052u,         241249007654u },
  {  7528259605829768337u, 17848875822468020539u,          38042657107u },
  { 18147447600042811311u,  2899664567187130618u,          83967589497u },
  { 12021069431116183911u,  2973178834961857409u,         121157191131u },
  { 11819985069665662506u, 11117453141176836727u,         219161176347u },
  { 10401877114068152814u,  7535238370146462002u,          27602678342u },
  {  4611631138117837942u, 10246175467290865448u,          70408486090u },
  { 17200813398607252417u,  1203128834127050464u,         202555446285u },
  { 14100466137553658767u, 14518048959078919658u,          13065221744u },
  { 17887776768825509301u,  1553474987376920024u,         112787025011u },
  { 12632656857970087269u, 14956572380830948369u,         115084214047u },
  {  8923681664054686256u,  7594162606042048292u,          31810797413u },
  {  6213926103737837599u, 14461296147288811288u,         101411680379u },
  {  1233118281776157762u, 18305427728131488265u,         123783948434u },
  {    30716279628678784u, 10253208939347909876u,         146992339225u },
  { 15775734650898546688u,  6446028915490812012u,          25555827570u },
  {   976806005729918976u, 12986063676957432257u,         114349439927u },
  { 12460098853279891456u,  9769714697972762807u,         183703975922u },
  {  5635665595421687808u,    97429465146664592u,         242529617295u },
  {  1805943450575568896u, 16395571728207795868u,         143005281661u },
  { 11529215046068469760u,  6331668478323650406u,         125888805724u },
  {                    0u, 18129911846294207040u,          92343240435u },
  {                    0u,  9890094564876124160u,         243982824490u },
  {                    0u, 12290856656987750400u,          42536143100u },
  {                    0u,  8498454992640802816u,         252666288674u },
  {                    0u,  5341660584200896512u,          34460702168u },
  {                    0u,  9288674231451648000u,         216289572000u },
  {                    0u,  1152921504606846976u,         160503540039u },
  {                    0u,                    0u,          71062500000u },
  {                    0u,                    0u,         160000000000u },
  {  4564018338575530435u,                 2081u,                    0u },
  { 16553437246451512014u,        2081247415929u,                    0u },
  {  4339777136957372927u, 15212079674427582639u,                  112u },
  { 18439463366554654697u, 10179808126814248333u,         112824648491u },
  {  1370067356680643003u,  6066766544199222848u,          43551848504u },
  {  4210124040914115013u,  6625308131806923532u,          56328880073u },
  { 10692225626142609720u,  9122786786400665713u,         201359158673u },
  { 11592856673895384344u, 11932880778639151320u,         145494547262u },
  { 10284479231227406269u,  3884040911779255011u,          62646882763u },
  {  4961071383534266431u, 13441817515637357872u,         203210554279u },
  { 10960611551445686988u, 11628577856022352826u,         167728682387u },
  { 14616396723115619209u, 13296656925520243654u,         147630386468u },
  {  1025604265437492803u,  5020720704545399398u,          36720813216u },
  { 11711588454892179178u, 14121973606499014694u,         160272173814u },
  {  5580373263251565705u,  3642481034345420114u,         246765553723u },
  { 14109334653033148931u,  9845536238569696768u,          59197459292u },
  {  2899414033769399895u, 17655403572195686356u,          92533727588u },
  { 13233457234892808147u,  8377495365136654029u,         100957101345u },
  {  3287946691509034862u, 13713682649609025426u,          33454144933u },
  {  5488480288717445911u,  1367709905452854731u,         165743420226u },
  { 11687233053874362630u,  9981467701727208680u,          66074143702u },
  {  6783772100089274577u,  6277920117543306205u,         214541096448u },
  {  7898291058728402485u,  9344111460418701726u,            340326731u },
  {  4423684977486598491u,  4918507011364617264u,          75506545297u },
  {  2750833684599526706u,  6554777203830755259u,         145266632799u },
  { 15669689830489025709u,  4198262173120265648u,          95355335184u },
  { 15117307274214954517u,  8080325935698446819u,          16227588248u },
  {  8148639818575698175u, 12797633874200091733u,         152438035346u },
  { 13006484426078994901u,  8376502502208665497u,         146693761122u },
  { 10287496057845513526u,  9891973386793349173u,          98454091110u },
  { 14159876032966532430u, 14877430279003795462u,         102536244951u },
  { 15742212196465548019u,  8759933935842067041u,         215806507111u },
  {  2892220461917134150u,  3753418510388703513u,         103474876970u },
  {  7487151560715393883u,  2961383332545305985u,          42203473225u },
  {  7245756744165177933u,  2497674184068629507u,          73160536912u },
  {  3067122860671533987u, 15244544070742305452u,          80135399188u },
  {  8135043905834122525u,    45953573565810823u,          20826408390u },
  { 14730019368921022572u,  3960077421351906445u,         198002491148u },
  {   495969939682055458u,  3173330011013883118u,          12214676227u },
  {  5617761407265775598u, 11026266219545759160u,           3172026564u },
  {  2087044847072781811u,  8886757764964685632u,         196597735089u },
  { 15929674232061203330u, 13952322129918090479u,         177481752103u },
  {  8658086469608285873u,  4127250666614902202u,          39756356898u },
  { 18369871790780313570u, 17649958504065306911u,          34223738706u },
  {  3545648451947416750u, 13269305359002216873u,          82956806167u },
  { 13347376792767929959u, 16236593433831947843u,          23719330484u },
  { 14482164459838203025u, 13580930396682424057u,         180880187493u },
  {  8899577765623565820u,   421976357197961116u,         101736223712u },
  {  7095320096604405719u,  2962130818798626533u,         224022875384u },
  {  2968593824439315788u,  8234383947306356345u,         248160577433u },
  { 12621408323612585636u,  4380469931801381425u,         153446386848u },
  {  3954422936414648259u, 15279887469027055916u,         160237465750u },
  { 17143730087577690191u,  8534542821713755552u,         150828324359u },
  {  5033045529399041876u,  7814613482565088782u,           7462658493u },
  { 15857648521994521781u, 13771954404705323224u,         189423631045u },
  { 16655573486499109541u,  4568173274762548144u,         197746579144u },
  { 16652154439190075858u,  8105292616250821343u,         200247641169u },
  { 18016950600164130638u,  2923678426777275612u,          81439388793u },
  {  2086292996072613910u,  1808633176918384049u,         121158492925u },
  { 17324462585194799521u, 18118642609460438969u,         253098046200u },
  { 11079151463184927232u, 18138164175864360870u,         248982213583u },
  {  5239846817488961536u,  4031433690465792404u,         207983271850u },
  {  2778806963520143360u,  5012226396942308537u,         170218544458u },
  {  6240890740138835968u,  7889712298793536835u,          74271713337u },
  { 17250651344549707776u, 13500762396543628804u,          57427702160u },
  {  4197354852709302272u,   501020624068841347u,         144731877796u },
  {  9223372036854775808u,  8370653768288261750u,         164027160382u },
  {                    0u,   647579990023635200u,          62453774050u },
  {                    0u, 11106569307181154304u,         226035105381u },
  {                    0u, 10797461613892861952u,         101602088328u },
  {                    0u, 17627230675448889344u,         136585331566u },
  {                    0u, 12197735707942322176u,         110955574089u },
  {                    0u, 12871287735024877568u,          73661240577u },
  {                    0u,  4611686018427387904u,           1697753906u },
  {                    0u,                    0u,          50250000000u },
  {                    0u,                    0u,         128000000000u },
  {  5654803392547571318u,             31757315u,                    0u },
  {  2931628102185393332u,    31757315306547506u,                    0u },
  { 15964697617980212305u,  9451803574512021605u,              1721567u },
  {   450380868305846606u,  8662766454758138424u,         223512383298u },
  { 14631133530814566148u,  9207992007314947035u,          66469609510u },
  {    31969822783742095u, 17118602861291201802u,          38499166246u },
  { 10437269029385743245u, 11186560605745599967u,          38928001320u },
  { 15196146496377392433u, 10505549821532796847u,          40606424665u },
  {  4409099735137480938u, 18133667530488679216u,          89569506996u },
  { 10644987914903248118u, 10778135771244330799u,         180983028086u },
  {  3154431617534062973u, 17087985777033767391u,         118584283910u },
  { 11702056331247960454u,  2639185991757283040u,           6926341565u },
  { 15575315065965259114u,  5401720287293896400u,         189143070559u },
  { 10759747609480050226u,  9816495392633895233u,          95292827843u },
  { 12538236653960743718u, 10042051500090034990u,         195532153281u },
  { 17857942663978005403u, 11629689537856384738u,         193544380702u },
  { 11443004154750813211u,  2099086731766010483u,          30630446733u },
  {  4004313188770806737u, 13665537898516458594u,         141113791719u },
  { 17134872954824183228u, 16375672064669490764u,         231740810293u },
  {  2659553912986171234u,  7770550512184564348u,          53887726961u },
  {  9501854300969137926u,  6197048880720627314u,         113421242387u },
  { 14528169966301018150u, 17963594118523106281u,          19335942692u },
  { 18172091996515901778u,  8255454642407818663u,          36973808388u },
  {  1133541705604751035u, 16744201957549498409u,           4447529092u },
  { 18280349987988641497u, 17442505417202859722u,         132907705006u },
  {  9936015874712336386u,  6383975767786687150u,         174945560113u },
  { 15876720399740689614u, 15245442964998335795u,          49346076019u },
  {  8618117825152456982u,  2910016124519524433u,         115826457119u },
  {  8085525680745921564u,  3847913871169988463u,          31157752290u },
  {  8072355444669730953u, 17210451512590059177u,         226208595828u },
  {  9395030504766848294u, 17899408909991454145u,         116932980445u },
  {  3537903114058185903u,  5920601932753251608u,         221970328901u },
  {  2126094743961928691u, 16521781895108979744u,          69320956473u },
  {   289185362555601115u,  3697493405554698771u,          57895647591u },
  { 16909937501450129614u,  2816108280295732065u,         103200441519u },
  { 14449642060360499058u, 14251078772056398988u,         175152661535u },
  { 12433818908498244393u,  4543066550096031417u,          31772552528u },
  { 11884444034578008581u,  3099369389734296977u,          80246280131u },
  {   988625838444140793u,  5243484113636490986u,         195168017151u },
  {  1675370907158909973u,  6823370511605197226u,         255284249843u },
  { 15920186275316934067u, 11396290277624641942u,         243369895656u },
  {  5600921198503757726u, 15934361408437566099u,         232617794133u },
  { 10457357161776341741u, 14939272230935131954u,          85863803462u },
  { 12225356765775740093u,  7500666177940329347u,          70809859570u },
  {  4486633318598164537u,  4806714453065462270u,         242406611928u },
  { 10302486602879381361u, 11557851247268441487u,         216260572512u },
  { 15536428611301239541u, 10655523157206817381u,          96626552371u },
  { 12026126645955462603u, 14769600176490881210u,          51577637067u },
  { 14877968141142123551u, 16688495540925795167u,         203800661629u },
  {   734560801645383190u,   909793965395524173u,         125904685156u },
  { 15648943144911081638u, 12724590949761703756u,         100049320029u },
  { 13664182862003235646u, 10810739657314826395u,          93689801457u },
  {  3895127525902132786u,  2431218615388671301u,         241586051371u },
  {  5249187334214137467u,  4235001167959059286u,          43131796625u },
  { 10642260063359027505u,  6253317787396334247u,         145229579873u },
  {   783598951897779422u,  9534525563070371898u,          97338993036u },
  {  5538576558607624843u,  8392783992374030728u,         140516867666u },
  { 15974581187564609611u, 16356257019231647540u,          82454973731u },
  {  7474269406918257428u, 12896334001521091877u,          35886674469u },
  {  8045286838779138019u,  1427636373320877084u,          37699111667u },
  {  8184246376556341732u, 16116755731295043521u,         243077392322u },
  {  1493267152679331840u, 15945633911163986837u,         194873691078u },
  { 10179074811222818816u,  7510154241072743838u,         198864414546u },
  {  3892499202005008384u,  3571560509790395119u,          82407126277u },
  { 10341173215925108736u,  3576991649007035076u,           5193614683u },
  {  6230307872002015232u, 15509961892750732443u,          91193909105u },
  {  9295429630892703744u, 17789791359353349378u,         113840796718u },
  {                    0u, 18331227331079738314u,          46964386521u },
  {                    0u, 15386712883100476416u,         217993737824u },
  {                    0u, 14082462055028752384u,          96834115376u },
  {                    0u, 12919043128765186048u,          48763411797u },
  {                    0u,  6125373368465096704u,          85700342731u },
  {                    0u, 12335992698065387520u,         203332057155u },
  {                    0u,  2774217370460225536u,          67668735504u },
  {                    0u,                    0u,          16150390625u },
  {                    0u,                    0u,          97000000000u },
  { 10665454627995623288u,                  484u,                    0u },
  { 16803537892767562832u,         484578175453u,                    0u },
  {  8099123106849104444u,  4962829537462579598u,                   26u },
  {  7077413686679401728u,  5711259460785241095u,          26269035528u },
  { 13536636358372449666u, 13845894607204897444u,           8309607995u },
  {  7280632235418610318u, 12116633056637003327u,          59750587450u },
  {  6187823673116858809u,  2965791047992089560u,          58656843994u },
  {  8624343686231740255u, 16021997451315962529u,         218160775854u },
  {   806211610822132771u,  3942052271663803856u,         174868554222u },
  { 18388078233202190882u, 15669876414782439922u,         238213699081u },
  {  7628864426595573600u, 10594415915406145286u,           9849465702u },
  {  4530799784343874981u, 10789820553031921377u,         102574324437u },
  {  8561580552078486438u,  3989990218583987244u,         213584917344u },
  { 13349114951221999594u,  2937341169808224563u,          96216297803u },
  { 10029144738508991772u, 16267436558584536843u,          75159233583u },
  { 12601907197916268979u, 16221580362814625793u,          47881859502u },
  {  1329580921391066941u,  9695437602320209830u,         174879373633u },
  {  3198179786356761112u, 10729753156793715126u,          65525590725u },
  { 11406753413634654142u,  2609241432056861929u,         197581661084u },
  { 11131812960525182090u,  8462663743997037565u,         156141447261u },
  { 14299636753645227208u, 14993422143908194069u,          93458761920u },
  { 12964114684643663326u,  1307443894537745373u,         192812795043u },
  {  5019257593846306316u, 10017257439419829265u,         163070876675u },
  {  6929086798159998121u, 16754772009970777891u,           3543036613u },
  { 18359765766933703649u, 11722573031602862387u,         197908278010u },
  {  9993076234752063198u,  7363764277467092384u,         250635481957u },
  {  3257189215046584509u,  6733958494847390772u,         101399190461u },
  {  2905234736672690348u,  8799796600227451045u,         189365048621u },
  { 12064985302079670056u, 10512023194742249826u,          45477037929u },
  { 14315096064942799930u,  4572542132337197059u,         105569857919u },
  { 11943971043551974038u, 12600500455757416832u,         127247878005u },
  { 12472773152119929647u,  7873789864743195199u,         117683074498u },
  {  7791259796982183085u, 15724851676325671539u,         194426839003u },
  { 16866829442051086686u,  8748017220462413167u,         219852445917u },
  {  3702498393844653053u, 14172589522760466448u,         221474230963u },
  {  2057239613841701716u,  9520545591489413768u,         179768297617u },
  { 17201969976738286226u, 12488551088392570222u,         145516109810u },
  { 18271566505443461640u,  1135798823651241684u,         242677005711u },
  { 18368509115417119804u, 11168725610120161972u,         143061571777u },
  {  7613923684154518587u,  9580104948718508826u,         193605457828u },
  { 17984805084714865232u, 16638722716909738765u,         164519338529u },
  {  4220802739051410373u, 15732724012348272797u,          33901986965u },
  { 17812459042810815760u, 12269722190021214142u,         149852872677u },
  { 10629526089664605307u, 13110655916311972587u,         229665142972u },
  { 17437443267816548473u,  6618112997062866867u,         188710730081u },
  { 12506371893701049304u,  8457936459015989309u,          97358768624u },
  { 15737221540003030739u,  3329167139937134914u,         240458505654u },
  {  2358380859011605513u,  5245511557216705097u,         182180474512u },
  { 10042972713837039706u,  5655931353280440466u,         144284359751u },
  { 13424397272769642495u,   604622132328697393u,          71306608653u },
  {  6867102315755663029u,  8673282619234652338u,          13032776631u },
  {  8690748404825506734u, 16929477433058445690u,         183470179592u },
  {   956229930815387710u, 11036952409253549455u,           8917748810u },
  {  7734449506297687888u, 18199392190170386320u,          74598314388u },
  { 16332184961683848151u,  9683116091880335715u,         148986591027u },
  { 15580777817612768828u,  2993913337608915120u,          51524922775u },
  { 17404245271944696092u,  4490779842162392585u,         151162300367u },
  { 13201420160494469229u,   946849923353644618u,         207243445663u },
  { 16511717657124068078u,  3613491058474899828u,         159051328837u },
  { 14131292492116594062u, 14624054199004410935u,          69195887742u },
  { 18429136031865875691u, 12088470271991908244u,         126792771566u },
  {  2563978348305862197u, 10071980927725011290u,         238655317286u },
  { 14239974392147482896u,  2833441711428854664u,          38546003180u },
  { 11164201396098998272u, 17655572411864340446u,         236153601182u },
  {  7116971104932986880u,  4997642792058747802u,         158957110498u },
  { 12437629862867369984u, 11489200787635734848u,         226270922758u },
  { 16501893821638901760u, 12983586226429536913u,           6622830822u },
  { 10649324268870959104u, 12311150768725063152u,         230703841619u },
  {  7205759403792793600u,  8530052476845967905u,          83667388820u },
  {                    0u,  6282736361499820264u,         148462415071u },
  {                    0u, 11337164765929082880u,         223340587820u },
  {                    0u,  8343856200414134272u,          44614588933u },
  {                    0u, 17889330377156198400u,           5452321350u },
  {                    0u, 17730714064155312128u,          70969782542u },
  {                    0u,  7449235258647511040u,          14961183935u },
  {                    0u,  9943947977234055168u,         191403823852u },
  {                    0u,                    0u,         236539062500u },
  {                    0u,                    0u,         228000000000u },
  {  3016823727048309817u,              7394076u,                    0u },
  { 17405973192644624358u,     7394076163542341u,                    0u },
  {  8937219978302591747u, 12396245121240683569u,               400833u },
  { 15178463196824222317u, 10248996648596888561u,         193672001794u },
  { 11979404627460330594u, 11257495103713935002u,           2555599221u },
  {  2006448052689740002u,  7555396579247433114u,         117610270032u },
  { 16330465320863239865u,  4805022328730367462u,          80409578869u },
  { 17136208883957646553u,  7056637817080232586u,         117260480782u },
  {   140455118208931867u, 10811411483818434913u,          14382541102u },
  {  3964972929179372247u, 16962406704495245447u,          46586087790u },
  {  3378050330022776379u, 18074517319117194669u,         110919533909u },
  {  6065353437512901255u,  3702019776117654523u,          85979821547u },
  { 12768753059854699889u,  3551977551381082764u,         235200686894u },
  {  6848720690951013326u, 16442608985936005282u,          46192553088u },
  { 10953228058585475132u,  3580046275479139588u,         128891355619u },
  { 15539127852083296166u,  8737412692712715330u,         227194074697u },
  { 14534853647735598497u,  3082033243045084752u,          73473656091u },
  {  1506909603576368170u, 16401023756841128699u,          27167077356u },
  {  5475702579938239025u,  7520296082779572869u,         236889101279u },
  { 12039747373985783332u,  9854104766152464159u,         223407676067u },
  { 17572399137760898460u, 14169188802648310188u,         163534192089u },
  {   869552790852091236u,  2018609909210367042u,         217768113264u },
  {  4549585778048181804u,  8270271948267674359u,         112109429062u },
  {  4121918231767210357u, 12320338602894572099u,          70448332340u },
  {  1558397953312543179u, 17538536685990080547u,          52667886893u },
  {  6067524298738069781u, 15833914616956760474u,          45950765978u },
  {  5811095224555517056u,  6137696141415969855u,         154858358231u },
  {  6440894514158997188u,  9757490468419438919u,         215332725174u },
  {  4612748874388784257u,  3566639201356598903u,         182528954618u },
  {  9908101430749813367u,  9760900035773954449u,         250193347898u },
  { 15150017990912190499u,  3873778773990716438u,          58529139451u },
  { 17470426264690059239u,  2295668377270167832u,         251209997968u },
  {  9615161096851907726u,  1791721710912807593u,         144124448432u },
  {  9227932132124142224u, 10571009006922683279u,         176097129428u },
  {  4794113194321211621u,  9840791932778184867u,         212573055546u },
  {   391512698859146347u, 11525464956561274613u,          58533470399u },
  { 17209658878068655842u,  4435781488897895433u,         191624796707u },
  {  3077364726606876150u,  6395563367070996741u,          35240464196u },
  {  1952989567673965814u, 15538690795135662932u,          68346704184u },
  { 11172860676923186449u, 16294558813563371936u,          56842354115u },
  { 17338078544784947239u,  4942096228426070342u,         195883329803u },
  {  4593380466519703278u,  6910116424372647153u,          11267911573u },
  {   786884753602720052u, 17923400669760829478u,         149374598161u },
  { 17848875822468020539u,  4134686917293039955u,          17971629497u },
  {  2899664567187130618u, 16857102463116098681u,         185224141826u },
  {  2973178834961857409u, 11364321508775167451u,           2913825355u },
  { 11117453141176836727u,  7966947780972783899u,          75616061103u },
  {  7535238370146462002u, 11261055695926686278u,         175431889104u },
  { 10246175467290865448u,  9227040437353594058u,         208610463052u },
  {  1203128834127050464u,  7185344074282882061u,          76500198864u },
  { 14518048959078919658u, 14197856148610578032u,         208389518282u },
  {  1553474987376920024u,   885688687260429427u,         202769667324u },
  { 14956572380830948369u, 17407816160380305183u,         252048013279u },
  {  7594162606042048292u, 17812728703806357349u,         223943679604u },
  { 14461296147288811288u, 17120198191964319867u,         116965629957u },
  { 18305427728131488265u, 12091952048375408786u,           5928087803u },
  { 10253208939347909876u,   405056939269888281u,         251655506034u },
  {  6446028915490812012u, 12485440679452408690u,         114021958180u },
  { 12986063676957432257u,  8394369900823444407u,          36676837095u },
  {  9769714697972762807u,  2877421667354294258u,         231455059704u },
  {    97429465146664592u,  2676980714750756239u,         248155985341u },
  { 16395571728207795868u,  6119309228579057021u,         189145119415u },
  {  6331668478323650406u, 18203256146533333852u,         183331728417u },
  { 18129911846294207040u,   351919978865493747u,          33986800493u },
  {  9890094564876124160u,  5190010931882390570u,         109019077620u },
  { 12290856656987750400u,  6982466386088036604u,         244281351056u },
  {  8498454992640802816u,  4707293888784996898u,         144378520261u },
  {  5341660584200896512u,   690306801165964760u,         197255182913u },
  {  9288674231451648000u, 12456770961278956704u,          65037421606u },
  {  1152921504606846976u, 16946092489294063943u,          38675282906u },
  {                    0u, 11098404173866185376u,         218918649514u },
  {                    0u, 15152070965853306880u,         170601645695u },
  {                    0u, 17370091362040414208u,         127821395412u },
  {                    0u, 10141938552171134976u,         212941634539u },
  {                    0u, 10586988556645826560u,         235549795590u },
  {                    0u, 12169852093061922816u,           6573921799u },
  {                    0u, 16717361816799281152u,           7659729003u },
  {                    0u,                    0u,         107906250000u },
  {                    0u,                    0u,          16000000000u },
  { 15212079674427582639u,                  112u,                    0u },
  { 10179808126814248333u,         112824648491u,                    0u },
  {  6066766544199222848u,  2144184049294538808u,                    6u },
  {  6625308131806923532u,  4108002197393276873u,           6116236450u },
  {  9122786786400665713u,  6446230217393892753u,         162222695245u },
  { 11932880778639151320u,  5571068025259989822u,          77349450840u },
  {  3884040911779255011u, 14804812668872528331u,          88302008202u },
  { 13441817515637357872u, 17369928488562523047u,         138802570502u },
  { 11628577856022352826u,  2967474173531035027u,           6941625710u },
  { 13296656925520243654u,  5291425437992807716u,         110160867097u },
  {  5020720704545399398u, 14219547193739388064u,          25286848747u },
  { 14121973606499014694u, 17720313647158217462u,         235770843197u },
  {  3642481034345420114u, 12334850628290578491u,          61960620127u },
  {  9845536238569696768u,  7818499847417334620u,          95668673592u },
  { 17655403572195686356u,   136007040922198372u,          56423841726u },
  {  8377495365136654029u,  8523477092112604449u,         190007372956u },
  { 13713682649609025426u,   367934822655966629u,         156462058619u },
  {  1367709905452854731u, 12964987687054730050u,         123019945786u },
  {  9981467701727208680u, 15267036012420885462u,          58702833390u },
  {  6277920117543306205u, 11142900264750765568u,         238827627680u },
  {  9344111460418701726u, 13680181547777718603u,         160604057833u },
  {  4918507011364617264u, 13001922925761426065u,         233741604127u },
  {  6554777203830755259u,  2397730045956515935u,          31704835654u },
  {  4198262173120265648u,  4482395522588406288u,          70129981206u },
  {  8080325935698446819u,  3255525722490493080u,          22242991148u },
  { 12797633874200091733u,   836222287193822098u,          44176482403u },
  {  8376502502208665497u,   420898743993182306u,          99045331701u },
  {  9891973386793349173u, 11652649973356574054u,         245022816966u },
  { 14877430279003795462u, 15058402726661910231u,         198631691420u },
  {  8759933935842067041u,  9600134495208339559u,         156816317647u },
  {  3753418510388703513u, 14626343323989004842u,         207520424333u },
  {  2961383332545305985u,  6813981265331086665u,         141792895660u },
  {  2497674184068629507u, 10281745288790487888u,         172369386664u },
  { 15244544070742305452u, 17569829347075761940u,         168557374528u },
  {    45953573565810823u,  7654580675237889478u,          64952462357u },
  {  3960077421351906445u, 16194838649686212364u,          21414955649u },
  {  3173330011013883118u,  6495102772252453635u,         129877923962u },
  { 11026266219545759160u, 14935159852819761348u,         122352100226u },
  {  8886757764964685632u, 17381879863441579697u,         130809636637u },
  { 13952322129918090479u,  9062335510435372583u,          29942273595u },
  {  4127250666614902202u,  7569219009130126626u,          59491270192u },
  { 17649958504065306911u, 12652124168176193362u,          48410328184u },
  { 13269305359002216873u,  8940200224697247767u,         120685873025u },
  { 16236593433831947843u,  5600570701927432884u,         129484649225u },
  { 13580930396682424057u,  2018432801986093157u,           9303607546u },
  {   421976357197961116u,  8235849749361824736u,         250109419461u },
  {  2962130818798626533u,  9705097287982370040u,         197446466309u },
  {  8234383947306356345u,  3517483139049842585u,           5526114378u },
  {  4380469931801381425u,   958281614186777760u,          74190683143u },
  { 15279887469027055916u,  7336473432636108950u,           7051948550u },
  {  8534542821713755552u, 12955383920176764423u,           6397711021u },
  {  7814613482565088782u, 10735469126281273789u,         173702312769u },
  { 13771954404705323224u,  8637888232514730693u,          65581970947u },
  {  4568173274762548144u,  6806336737533581000u,           3468260859u },
  {  8105292616250821343u, 16142569672872330321u,         251368972253u },
  {  2923678426777275612u,  8141285259947963513u,         221875090455u },
  {  1808633176918384049u,  5220241098754220797u,          23441339958u },
  { 18118642609460438969u,   154438799943119608u,          54282989837u },
  { 18138164175864360870u,  2226876628677628879u,          13008372144u },
  {  4031433690465792404u, 17219557081221357482u,         176120719223u },
  {  5012226396942308537u, 15401507148161015114u,         119933474059u },
  {  7889712298793536835u,  8842629766613985337u,          11834917375u },
  { 13500762396543628804u,  3180100571546071440u,         255479359920u },
  {   501020624068841347u,  7740848704392475044u,         176172393597u },
  {  8370653768288261750u,  2014314126623495998u,         125419632249u },
  {   647579990023635200u, 11209566016506885858u,         121109196187u },
  { 11106569307181154304u,  7117166613733441125u,         155607671791u },
  { 10797461613892861952u,  4197646860931880328u,         239385822375u },
  { 17627230675448889344u,  5487263271238026094u,         167227554892u },
  { 12197735707942322176u, 18148076225293562697u,          76297465137u },
  { 12871287735024877568u,  9127276943027950849u,          49983809183u },
  {  4611686018427387904u,  9691696125379324722u,         159494790674u },
  {                    0u, 13102362262487705216u,          18525387899u },
  {                    0u,  8929385439893192704u,         123710280481u },
  {                    0u, 11891353410743566336u,          33484062954u },
  {                    0u,  1587423090877399040u,         234644631560u },
  {                    0u,  3489137423026225152u,           8086054378u },
  {                    0u, 13046928120492326912u,         234189146518u },
  {                    0u, 11529215046068469760u,         150707275390u },
  {                    0u,                    0u,         126625000000u },
  {                    0u,                    0u,          64000000000u },
  {  9451803574512021605u,              1721567u,                    0u },
  {  8662766454758138424u,     1721567512383298u,                    0u },
  {  9207992007314947035u,  6674960280855494694u,                93326u },
  { 17118602861291201802u, 16378845781483497510u,         142361850321u },
  { 11186560605745599967u, 17606907750956804392u,         209887899008u },
  { 10505549821532796847u, 13225609159240506969u,         128954472381u },
  { 18133667530488679216u,  2668084873338435252u,         189716961709u },
  { 10778135771244330799u, 14802814305275861366u,         173144637170u },
  { 17087985777033767391u,  8005510553372365574u,         242802462171u },
  {  2639185991757283040u, 12748500143273514429u,         219433979596u },
  {  5401720287293896400u, 10393733905569036127u,         204691097577u },
  {  9816495392633895233u,   603389089974790339u,         233563445444u },
  { 10042051500090034990u,  2033494532597735873u,         196032709788u },
  { 11629689537856384738u,  9204796763694620958u,         156110235959u },
  {  2099086731766010483u,  7826260310402107021u,          55498993032u },
  { 13665537898516458594u, 10122690201685169383u,         136424262421u },
  { 16375672064669490764u,  7438455564568110133u,          21548752135u },
  {  7770550512184564348u,  2805412574380520817u,           7403239484u },
  {  6197048880720627314u,  7250965427231182867u,          60152081720u },
  { 17963594118523106281u,  8136242944826085924u,          56393075623u },
  {  8255454642407818663u, 15357191647956011780u,         167441066613u },
  { 16744201957549498409u,  7369614426695395460u,         117832515027u },
  { 17442505417202859722u, 10886957545142526638u,         211399507598u },
  {  6383975767786687150u,  2030047207417538097u,         142590183151u },
  { 15245442964998335795u, 11557093828502314355u,         239110049079u },
  {  2910016124519524433u, 15201062539664128543u,          55626511311u },
  {  3847913871169988463u,  8846936323343880674u,         207824051251u },
  { 17210451512590059177u,  1485291750116245364u,          51479593379u },
  { 17899408909991454145u,  2076024439668322013u,         163080517827u },
  {  5920601932753251608u,  7029497773682748741u,         195112541510u },
  { 16521781895108979744u, 16333533921668749881u,          70381069837u },
  {  3697493405554698771u,  2065057316131928423u,          13885442648u },
  {  2816108280295732065u,  7800502648925570223u,          88111946981u },
  { 14251078772056398988u, 17011619967093802015u,         229422866095u },
  {  4543066550096031417u,  5368819344429198672u,         175922201766u },
  {  3099369389734296977u, 15598879366754275267u,         166291044279u },
  {  5243484113636490986u, 16393893486035835647u,         183845616944u },
  {  6823370511605197226u, 12042046205096920307u,          48888714746u },
  { 11396290277624641942u, 15437070428008474344u,         250652800632u },
  { 15934361408437566099u, 13704569163204647509u,         120836845264u },
  { 14939272230935131954u, 18192483750856993350u,         208742926182u },
  {  7500666177940329347u,  5152535865317963250u,         102986216520u },
  {  4806714453065462270u, 17512614083933854680u,          72279319528u },
  { 11557851247268441487u, 14481918350603613536u,         232949360711u },
  { 10655523157206817381u, 16124419709964004915u,          71785066366u },
  { 14769600176490881210u, 18088011566435813579u,         126874106543u },
  { 16688495540925795167u, 15008862380698848893u,         175980553071u },
  {   909793965395524173u, 18160498644611827812u,         111813632059u },
  { 12724590949761703756u,  3604680497457231965u,          59984482604u },
  { 10810739657314826395u,  5957615565551495921u,          44195410121u },
  {  2431218615388671301u, 17528455034961565995u,         201322962986u },
  {  4235001167959059286u,  8503772325120113809u,          42950219451u },
  {  6253317787396334247u,  8501492578048509537u,         187460990421u },
  {  9534525563070371898u,  2296237701094386060u,         213460866836u },
  {  8392783992374030728u,  3753593040591076946u,          20124479295u },
  { 16356257019231647540u,  8518075399775653155u,          63203482686u },
  { 12896334001521091877u, 12757855675959554597u,          62461765792u },
  {  1427636373320877084u,   121631169379748595u,         160691604742u },
  { 16116755731295043521u, 16679062494579173314u,           6006593638u },
  { 15945633911163986837u, 10739912744743898054u,         102904173789u },
  {  7510154241072743838u,  9367340677776287570u,         221582211836u },
  {  3571560509790395119u, 12227321512794715397u,         252507804555u },
  {  3576991649007035076u,  7241061891859170651u,         139662844427u },
  { 15509961892750732443u, 13148571323079237489u,          11392538751u },
  { 17789791359353349378u, 12509763434355012654u,         127712785479u },
  { 18331227331079738314u, 11812768946960181977u,          71678155634u },
  { 15386712883100476416u, 14170358803552564832u,         114640371487u },
  { 14082462055028752384u, 18179989524780635952u,          31768176689u },
  { 12919043128765186048u, 17091718978514754901u,          49985539206u },
  {  6125373368465096704u,  7394768384359232459u,         134926543942u },
  { 12335992698065387520u,  6778628272692852803u,          70400871197u },
  {  2774217370460225536u, 18193335045875234320u,          29367470174u },
  {                    0u,  1378519212560967521u,          94986262669u },
  {                    0u,  4677732610631043584u,         141074729676u },
  {                    0u, 17296098591070486528u,         204253580392u },
  {                    0u,  7343735382392963072u,         104937623383u },
  {                    0u, 14525996728454217728u,          87398104692u },
  {                    0u,  9691359370008330240u,         116787455860u },
  {                    0u,  3044433348102455296u,         116525369644u },
  {                    0u,  9223372036854775808u,          44165039062u },
  {                    0u,                    0u,         214500000000u },
  {  4962829537462579598u,                   26u,                    0u },
  {  5711259460785241095u,          26269035528u,                    0u },
  { 13845894607204897444u,  7822291454600056379u,                    1u },
  { 12116633056637003327u,  8201586317771250746u,           1424047269u },
  {  2965791047992089560u,  3278889188817135834u,         165444608885u },
  { 16021997451315962529u,  1710725240251040430u,         117177748939u },
  {  3942052271663803856u,  1850175733663425006u,         203092738601u },
  { 15669876414782439922u,  9147599666163914249u,          41100298227u },
  { 10594415915406145286u, 10221885933644344166u,         243495892371u },
  { 10789820553031921377u, 14901479793736678101u,         147554129546u },
  {  3989990218583987244u,  5181831442059703136u,         138807810838u },
  {  2937341169808224563u,  6396246577759793483u,          22280907645u },
  { 16267436558584536843u, 14167229556464870447u,         125346741221u },
  { 16221580362814625793u,  2969982933326311854u,         229768007053u },
  {  9695437602320209830u,  7892677766222018881u,         141161003097u },
  { 10729753156793715126u,   798698968922663621u,          89427862919u },
  {  2609241432056861929u, 15926812109043458972u,         135043297557u },
  {  8462663743997037565u,  8663842590352697437u,          21863394214u },
  { 14993422143908194069u, 17093523026636671168u,         166469667847u },
  {  1307443894537745373u,   839764004742743203u,           7926641740u },
  { 10017257439419829265u, 16894643909298232323u,          76045523697u },
  { 16754772009970777891u,  9066702926218949317u,         241915860481u },
  { 11722573031602862387u,  9119392417260546810u,           1491506950u },
  {  7363764277467092384u,  9723021096578315109u,           6494363253u },
  {  6733958494847390772u, 14787464248751217597u,         117527086029u },
  {  8799796600227451045u,  3733434565920249133u,         205801630043u },
  { 10512023194742249826u,  6643788868836820841u,          91202389893u },
  {  4572542132337197059u,  4729646697422664063u,         133360160516u },
  { 12600500455757416832u,  4090144564201555829u,           4256394661u },
  {  7873789864743195199u,  2109480737093400002u,         165221727181u },
  { 15724851676325671539u, 16577155033369419739u,         205114355179u },
  {  8748017220462413167u,   745377248603805917u,         235898649375u },
  { 14172589522760466448u, 11305561465807999667u,          31040406981u },
  {  9520545591489413768u,  2211245518782892177u,         197612875715u },
  { 12488551088392570222u, 14170095199249735666u,         195119871859u },
  {  1135798823651241684u, 17849973668116118927u,         115768162399u },
  { 11168725610120161972u,  9020960204585720001u,          95967649011u },
  {  9580104948718508826u, 10807134002871850916u,         243489027232u },
  { 16638722716909738765u,  3925122626254791201u,         160585855908u },
  { 15732724012348272797u, 17208463291312718997u,         164212781323u },
  { 12269722190021214142u,  5145077219589447653u,          11932872664u },
  { 13110655916311972587u, 17602397765035489468u,         216278915194u },
  {  6618112997062866867u, 16422643262490753377u,         122954227894u },
  {  8457936459015989309u,  2902509461400906224u,         182890273275u },
  {  3329167139937134914u,  3422418805967265206u,         251157345353u },
  {  5245511557216705097u,  4228874576277237392u,          73185529695u },
  {  5655931353280440466u,  2553488530807495751u,          95229247750u },
  {   604622132328697393u, 11546099176912486413u,           6138424890u },
  {  8673282619234652338u, 10460791037534167991u,          58625915290u },
  { 16929477433058445690u,  8127117908566000904u,         154567080618u },
  { 11036952409253549455u, 11541304458088287306u,         170440571944u },
  { 18199392190170386320u,  6249718665174839700u,          40625655368u },
  {  9683116091880335715u, 13102508413386290995u,          72338797927u },
  {  2993913337608915120u,  6274675218640661911u,         103710288404u },
  {  4490779842162392585u,  3404497118599817167u,          20340150825u },
  {   946849923353644618u, 11258566093988562335u,          41184558158u },
  {  3613491058474899828u, 16762592482501635397u,          78610328090u },
  { 14624054199004410935u,  5550125446725071998u,          26908701959u },
  { 12088470271991908244u,  6370033225258510318u,           7300872903u },
  { 10071980927725011290u,  1503521728674735398u,         199345320193u },
  {  2833441711428854664u,  4250415082606384364u,           1081506076u },
  { 17655572411864340446u,  6020091901030562974u,          28230415463u },
  {  4997642792058747802u, 16288222967151527138u,         103326349835u },
  { 11489200787635734848u,  6377016228656203782u,          11882986336u },
  { 12983586226429536913u,  8378856515587563750u,          96345698742u },
  { 12311150768725063152u, 15812881490200838483u,         182454218721u },
  {  8530052476845967905u,  4548570371183413652u,         225857218023u },
  {  6282736361499820264u, 16731431495283420383u,         231246578493u },
  { 11337164765929082880u, 14737727629551135532u,          61907012718u },
  {  8343856200414134272u, 12413722258104293893u,         110798933815u },
  { 17889330377156198400u,   800899742400762438u,          55672949232u },
  { 17730714064155312128u,   603197008376033550u,         240043416862u },
  {  7449235258647511040u,  6380777281587743935u,          30032699375u },
  {  9943947977234055168u, 10001440249018225388u,         239345902629u },
  {                    0u,  5505914461980436708u,          37542179162u },
  {                    0u,  1105464290051876864u,          90298476221u },
  {                    0u,  4500443576769970176u,         189059927339u },
  {                    0u,  2843045143185981440u,          43243969535u },
  {                    0u,   660949699682893824u,         255154121786u },
  {                    0u,   276549164618219520u,          58035830155u },
  {                    0u,  4683743612465315840u,         139014991760u },
  {                    0u,                    0u,         144253906250u },
  {                    0u,                    0u,          74000000000u },
  { 12396245121240683569u,               400833u,                    0u },
  { 10248996648596888561u,      400833672001794u,                    0u },
  { 11257495103713935002u,  4370024159708535157u,                21729u },
  {  7555396579247433114u,  7166684413908503888u,         225236899484u },
  {  4805022328730367462u, 10217286283215687029u,         156388506740u },
  {  7056637817080232586u,  4767369911989629198u,         116553880199u },
  { 10811411483818434913u, 14407999214182082862u,         135258439640u },
  { 16962406704495245447u,  8472271297615317358u,         216781059202u },
  { 18074517319117194669u,  6236024012584764757u,         130459282747u },
  {  3702019776117654523u,  1951826556984620523u,          59338055539u },
  {  3551977551381082764u, 12357130551551830830u,         115105808729u },
  { 16442608985936005282u,  8927758011099278464u,          89669881389u },
  {  3580046275479139588u, 10199854049407140323u,          45483974731u },
  {  8737412692712715330u, 17895455027038549577u,          75552935195u },
  {  3082033243045084752u, 16539200343720527131u,          27970114560u },
  { 16401023756841128699u,  3536976106235802604u,            896591847u },
  {  7520296082779572869u, 16980391644793590751u,         231191739858u },
  {  9854104766152464159u, 10090294316609084067u,         210920508875u },
  { 14169188802648310188u, 17603457857266236889u,         203546995950u },
  {  2018609909210367042u, 11164962743035868272u,         238954285362u },
  {  8270271948267674359u,  1585686890718568774u,          50605253843u },
  { 12320338602894572099u, 10882524700472655412u,         211085960258u },
  { 17538536685990080547u,  2194808754940947757u,          66589942846u },
  { 15833914616956760474u,   274100791137209242u,          62118980821u },
  {  6137696141415969855u, 12203404582981010903u,         213014859033u },
  {  9757490468419438919u,   541940706340938166u,          25661547888u },
  {  3566639201356598903u, 10305434016011833594u,         112029378664u },
  {  9760900035773954449u,  7900783531944543546u,         104558658697u },
  {  3873778773990716438u,  8920818625012419323u,         137428302333u },
  {  2295668377270167832u, 12532363335400447632u,         253483598546u },
  {  1791721710912807593u, 13483507182924762800u,         210679380777u },
  { 10571009006922683279u,   415911049779278804u,          41730942389u },
  {  9840791932778184867u,  3441628281170127418u,         181022546583u },
  { 11525464956561274613u, 17830811568183566527u,         151186571042u },
  {  4435781488897895433u, 17897295813176613411u,          34966610231u },
  {  6395563367070996741u,  2086148701331574596u,          55970214350u },
  { 15538690795135662932u, 13015567826878853432u,         206113090347u },
  { 16294558813563371936u, 12944531121587846595u,          43705575345u },
  {  4942096228426070342u,  3534180912913737995u,         177701724438u },
  {  6910116424372647153u,  3447584022400118677u,          22191588331u },
  { 17923400669760829478u,  6375676813770849297u,         235186893904u },
  {  4134686917293039955u, 11580694081479200185u,          80345626132u },
  { 16857102463116098681u,  1872134358882196482u,          20627790684u },
  { 11364321508775167451u, 17602652840520938059u,          92101488606u },
  {  7966947780972783899u, 10331040597716338351u,         222954241722u },
  { 11261055695926686278u,    73785407041056976u,         186560046833u },
  {  9227040437353594058u, 17166209109167902028u,         241003999914u },
  {  7185344074282882061u,  8762475644006589904u,         170930582060u },
  { 14197856148610578032u,  8839001228645872586u,          44475014756u },
  {   885688687260429427u, 13558262784529110268u,         100479163216u },
  { 17407816160380305183u,  5640853896420358111u,          80734994898u },
  { 17812728703806357349u,  8459930353450835572u,         210305791302u },
  { 17120198191964319867u,  7643830211500171269u,          70458613743u },
  { 12091952048375408786u,  1308629115231236347u,         239414372866u },
  {   405056939269888281u,  8957268500971669618u,           2070940926u },
  { 12485440679452408690u,  7645679094277669412u,         254485574498u },
  {  8394369900823444407u,  3821107497040617191u,          98414473094u },
  {  2877421667354294258u,  8847137191985934072u,         134207142652u },
  {  2676980714750756239u,  3531126524756088253u,         252479604268u },
  {  6119309228579057021u,  8726915034124352183u,          44191422752u },
  { 18203256146533333852u, 17611136727168068641u,          32473087011u },
  {   351919978865493747u, 18017743272784259949u,          35954701634u },
  {  5190010931882390570u, 18113575006829616116u,          66976743819u },
  {  6982466386088036604u, 12805550441678740368u,         139981938868u },
  {  4707293888784996898u,  8061966093393027781u,         180694190280u },
  {   690306801165964760u, 11954593141554100801u,         200437040057u },
  { 12456770961278956704u, 14068656112359197734u,         185648059792u },
  { 16946092489294063943u,   895878255770467290u,         144762663376u },
  { 11098404173866185376u, 10319906489512197802u,         208048565657u },
  { 15152070965853306880u, 14551142616794302079u,         153559443251u },
  { 17370091362040414208u, 15933181735739307476u,          51788819021u },
  { 10141938552171134976u, 11524527334398983147u,          77863739512u },
  { 10586988556645826560u, 11828012606225556742u,         120624745878u },
  { 12169852093061922816u,  3556238869349799431u,         150641197848u },
  { 16717361816799281152u,  7403090230513381483u,          24192784095u },
  {                    0u, 10172292854665622800u,         223401322325u },
  {                    0u, 11240746576366182400u,          85551441100u },
  {                    0u, 17021927826892259328u,         204609362092u },
  {                    0u,  9046328496309141504u,         172922760556u },
  {                    0u,  8038996803112140800u,         108490402450u },
  {                    0u, 17098478935265509376u,         146435794889u },
  {                    0u,  7205759403792793600u,         201926910400u },
  {                    0u,                    0u,         192390625000u },
  {                    0u,                    0u,         232000000000u },
  {  2144184049294538808u,                    6u,                    0u },
  {  4108002197393276873u,           6116236450u,                    0u },
  {  6446230217393892753u,  6116236450222695245u,                    0u },
  {  5571068025259989822u,  6240972538554414168u,            331561842u },
  { 14804812668872528331u,  4356262642990299018u,         114338323799u },
  { 17369928488562523047u,  1335108558830511366u,          87236153471u },
  {  2967474173531035027u, 18435704923261947246u,         127072376379u },
  {  5291425437992807716u,  8395401931972636441u,          59999401566u },
  { 14219547193739388064u, 12482665946362458347u,          94455115650u },
  { 17720313647158217462u, 16101242875289374781u,         130676686676u },
  { 12334850628290578491u,  4708983440241068127u,          84872850125u },
  {  7818499847417334620u, 14856666972541426744u,         205255274503u },
  {   136007040922198372u,  6938795288315789246u,           7805381530u },
  {  8523477092112604449u,  5556307628265073820u,         154376152846u },
  {   367934822655966629u,  1441404248927865979u,          14301208040u },
  { 12964987687054730050u, 16710378912353838906u,         232078138680u },
  { 15267036012420885462u, 18289940136919312110u,          56905871455u },
  { 11142900264750765568u, 10217414145292657824u,          95991499641u },
  { 13680181547777718603u, 12461165826430955753u,         121553887130u },
  { 13001922925761426065u,   662762458988270879u,         154675521153u },
  {  2397730045956515935u, 16488546856395302470u,         129035928424u },
  {  4482395522588406288u,  2612816787977180950u,         104893845916u },
  {  3255525722490493080u, 16446616379327454252u,         156141641081u },
  {   836222287193822098u,  7842178508581740643u,         121891572860u },
  {   420898743993182306u, 14779029861369369333u,         124425125348u },
  { 11652649973356574054u,  2697664446153849542u,         228801172814u },
  { 15058402726661910231u, 12135106444393649308u,          78146240682u },
  {  9600134495208339559u,  9550285041205189839u,         170657845438u },
  { 14626343323989004842u,  8790318168586740109u,         190517721989u },
  {  6813981265331086665u, 14038474217155846828u,         133476524102u },
  { 10281745288790487888u,  4263144264274812072u,          70761027212u },
  { 17569829347075761940u, 11940456333341715520u,         140231105513u },
  {  7654580675237889478u, 15751110736831573013u,         233647293434u },
  { 16194838649686212364u, 18384528705472318081u,         250853869423u },
  {  6495102772252453635u,  2393654818032310394u,         111996627298u },
  { 14935159852819761348u, 12812209822018626434u,          98129760287u },
  { 17381879863441579697u,  3110778569433458461u,          31694551286u },
  {  9062335510435372583u,  2860264756226872891u,         246168635644u },
  {  7569219009130126626u,  2384146980060315184u,         252155055263u },
  { 12652124168176193362u, 14117430062880324728u,         159129244866u },
  {  8940200224697247767u,  3769610173216737153u,         194765307417u },
  {  5600570701927432884u, 17731974340232672009u,          25204350976u },
  {  2018432801986093157u,  1971479303384713466u,            961252255u },
  {  8235849749361824736u,  3449462959779012549u,         159106874107u },
  {  9705097287982370040u, 13743454852043766533u,         251186995761u },
  {  3517483139049842585u,  7417711187131879498u,          49745034180u },
  {   958281614186777760u,  3650992383501007879u,         196402114929u },
  {  7336473432636108950u, 12838770342493958662u,         113197920693u },
  { 12955383920176764423u, 16025068246546338477u,         181695991134u },
  { 10735469126281273789u,  6579965938260177729u,          94868720690u },
  {  8637888232514730693u,  4742939430174291459u,          50356700668u },
  {  6806336737533581000u, 13062256857527449083u,         252257115261u },
  { 16142569672872330321u,  2301174570202439645u,         125708106363u },
  {  8141285259947963513u,  7638687886069412887u,         123124746923u },
  {  5220241098754220797u,   936322449610274358u,         171414094100u },
  {   154438799943119608u, 12926010544311283981u,          20050758141u },
  {  2226876628677628879u, 12647854908989899184u,         253700720435u },
  { 17219557081221357482u,  8862093163358513015u,          51685641588u },
  { 15401507148161015114u,   444784343917630731u,         116480415033u },
  {  8842629766613985337u, 11033952249213387263u,          57024111807u },
  {  3180100571546071440u, 18168634046363183536u,         191598151749u },
  {  7740848704392475044u,  3837904761417065597u,          69984923625u },
  {  2014314126623495998u,   111459007020906105u,         233208053234u },
  { 11209566016506885858u, 16191761957496794523u,         242006042204u },
  {  7117166613733441125u,  9856250800340378607u,          92877757174u },
  {  4197646860931880328u,  9491800102275105959u,         246534308426u },
  {  5487263271238026094u, 10777328578953608268u,          74514551514u },
  { 18148076225293562697u, 17424440628313779505u,         218584240152u },
  {  9127276943027950849u,  3285814872419755679u,          24944580819u },
  {  9691696125379324722u,  2824823424107240978u,         211178124381u },
  { 13102362262487705216u, 12271707680713669755u,          93153133984u },
  {  8929385439893192704u,  6951481875178001185u,         160665250606u },
  { 11891353410743566336u, 10202522487003824362u,          46376840587u },
  {  1587423090877399040u,  4834668463880990728u,         139553079852u },
  {  3489137423026225152u, 10871520987687904746u,          44262087902u },
  { 13046928120492326912u, 12057698794225322390u,         222589346333u },
  { 11529215046068469760u,  7263351819222681214u,          29653649161u },
  {                    0u,  1778055686910650944u,           9393747091u },
  {                    0u, 17108187120491986944u,         147096388591u },
  {                    0u,  3067636961549221888u,         239927436682u },
  {                    0u, 16702141595163557888u,         138166296932u },
  {                    0u,  2432053749942845440u,         100905424910u },
  {                    0u, 17791470327927144448u,          14131841897u },
  {                    0u,  1152921504606846976u,         105964477539u },
  {                    0u,                    0u,          99062500000u },
  {                    0u,                    0u,         160000000000u },
  {  6674960280855494694u,                93326u,                    0u },
  { 16378845781483497510u,       93326361850321u,                    0u },
  { 17606907750956804392u,  4283581425266273664u,                 5059u },
  { 13225609159240506969u,  6725911039793895357u,         195232213414u },
  {  2668084873338435252u,  1188689198788975021u,         166364612368u },
  { 14802814305275861366u, 10825527435847761650u,          16064438970u },
  {  8005510553372365574u,  3917696829526085083u,         186586853018u },
  { 12748500143273514429u, 12646861173976387276u,         154212378770u },
  { 10393733905569036127u, 18398576063183996905u,         146685587717u },
  {   603389089974790339u, 16919251228485834948u,           5997388806u },
  {  2033494532597735873u, 17296019588687185052u,           6917194446u },
  {  9204796763694620958u, 12365301604512770359u,         206937619100u },
  {  7826260310402107021u,  2814271599679204744u,         156670324343u },
  { 10122690201685169383u,  2154994415780170517u,         119152561969u },
  {  7438455564568110133u,  6717373824370072839u,          49116822481u },
  {  2805412574380520817u, 12709155755801344060u,         209364149564u },
  {  7250965427231182867u,   826847911966403896u,          60688964714u },
  {  8136242944826085924u,  2277322703890025383u,         106044823515u },
  { 15357191647956011780u,  2774508958389496437u,         219123453911u },
  {  7369614426695395460u,   245697774950120915u,         215150406432u },
  { 10886957545142526638u,  1268929063431863950u,          32013319303u },
  {  2030047207417538097u,  6735665673159411439u,         135068788782u },
  { 11557093828502314355u, 14734771742997073207u,          46365141167u },
  { 15201062539664128543u, 13683287077957612495u,         175798773576u },
  {  8846936323343880674u, 15370263741354826803u,          72741772478u },
  {  1485291750116245364u,    48035913070297507u,         190833223667u },
  {  2076024439668322013u,  1206547475966802115u,         243002604032u },
  {  7029497773682748741u, 13512340386605768006u,             65407069u },
  { 16333533921668749881u,  2325760467700278797u,          93732505440u },
  {  2065057316131928423u, 10848110652847753816u,          96126079727u },
  {  7800502648925570223u, 15846378960784301285u,         239588077256u },
  { 17011619967093802015u, 14121839924449844911u,         200859033924u },
  {  5368819344429198672u,  5147613424753296550u,          68765546476u },
  { 15598879366754275267u, 16817040482828810167u,         236279052682u },
  { 16393893486035835647u,  5773528746119363888u,         138911653591u },
  { 12042046205096920307u,  8716201595536184826u,         215312983620u },
  { 15437070428008474344u,  5259122109038474872u,          68472506235u },
  { 13704569163204647509u, 14744540084230155984u,         123285097580u },
  { 18192483750856993350u, 10719345477982635878u,         108799303119u },
  {  5152535865317963250u, 13698037261310555208u,         207581096882u },
  { 17512614083933854680u, 16141171632951976936u,         178742572087u },
  { 14481918350603613536u, 10060790174955808839u,          55875014667u },
  { 16124419709964004915u,  4250043307981877118u,          11545396528u },
  { 18088011566435813579u,  7075646198054337199u,          48230395309u },
  { 15008862380698848893u, 18141738384245531503u,         173383571548u },
  { 18160498644611827812u,  8174370508376809531u,          92983465608u },
  {  3604680497457231965u,  3581964982731575596u,         136443133513u },
  {  5957615565551495921u, 14798509948722114761u,          73194178710u },
  { 17528455034961565995u, 14713923334885122090u,         150802228831u },
  {  8503772325120113809u,  5042978054260414139u,          95797643382u },
  {  8501492578048509537u,  2052996319372883413u,         118273380388u },
  {  2296237701094386060u,  8825683007899981588u,          36111293153u },
  {  3753593040591076946u,  9992196755378745151u,         225478441234u },
  {  8518075399775653155u,  9301073417573669950u,          18541678071u },
  { 12757855675959554597u,  5331614769144850592u,         247504212200u },
  {   121631169379748595u, 14354009428310052102u,         232289027415u },
  { 16679062494579173314u,  5581221063029119078u,          87778132410u },
  { 10739912744743898054u,  1529260335339476189u,         186302558600u },
  {  9367340677776287570u, 16483061525949201148u,         136082901368u },
  { 12227321512794715397u, 14431217812333089675u,         120893548555u },
  {  7241061891859170651u,  3452349151135392267u,          11782317885u },
  { 13148571323079237489u,  9075317899834447999u,          61187152222u },
  { 12509763434355012654u,  2764331337978901575u,          94491973969u },
  { 11812768946960181977u,  1942890683708857202u,          81149854702u },
  { 14170358803552564832u,   165089169728028447u,         238105324315u },
  { 18179989524780635952u, 15193620741871233073u,          27008949501u },
  { 17091718978514754901u, 14995000835194145926u,         253823647830u },
  {  7394768384359232459u,  1788823614552255558u,          86812880624u },
  {  6778628272692852803u,  8384901184618498845u,         240096972322u },
  { 18193335045875234320u,   405511217862281310u,          34454546404u },
  {  1378519212560967521u,  3111530463755196557u,         228021982807u },
  {  4677732610631043584u,  7893558450035460812u,          87168676404u },
  { 17296098591070486528u,   156573858237402216u,          52427910661u },
  {  7343735382392963072u, 15915324019419451223u,           5008487885u },
  { 14525996728454217728u, 16293363012778802804u,         205862771443u },
  {  9691359370008330240u, 14342105318291351412u,         243883264978u },
  {  3044433348102455296u,  3788398842525387052u,         210777487087u },
  {  9223372036854775808u, 14118764407048307670u,         239205369512u },
  {                    0u,  2705021334614720768u,         168765379752u },
  {                    0u,  7017988973805568000u,         168146639500u },
  {                    0u, 10956732053634154496u,         140380445944u },
  {                    0u, 14657517938546835456u,         248593965634u },
  {                    0u, 11268868284797157376u,          66794585639u },
  {                    0u, 14600669991935148032u,          39610886573u },
  {                    0u,  4611686018427387904u,         173791503906u },
  {                    0u,                    0u,          34250000000u },
  {                    0u,                    0u,         128000000000u },
  {  8201586317771250746u,           1424047269u,                    0u },
  {  3278889188817135834u,  1424047269444608885u,                    0u },
  {  1710725240251040430u,  3001188830946823627u,             77197757u },
  {  1850175733663425006u,  9732296932705387049u,         189162694772u },
  {  9147599666163914249u, 16337535782679529459u,         116527588873u },
  { 10221885933644344166u,  7969742269895046547u,           9885659589u },
  { 14901479793736678101u,  2923592083903829642u,         197432040594u },
  {  5181831442059703136u,  8144196241160608534u,         146158488244u },
  {  6396246577759793483u, 16431078457793424253u,         180441497762u },
  { 14167229556464870447u,   202362949592775653u,         162890730548u },
  {  2969982933326311854u,  8835125248522947981u,          52010970117u },
  {  7892677766222018881u,  7959873808777345113u,           5478953099u },
  {   798698968922663621u, 14929747122315126151u,         139431505623u },
  { 15926812109043458972u,  4310328817360515349u,         215809343213u },
  {  8663842590352697437u,  7294899422760201126u,         237233663393u },
  { 17093523026636671168u,  2047461597291187207u,         161395457290u },
  {   839764004742743203u, 10942374468813517900u,          10110993115u },
  { 16894643909298232323u, 10364795403063433969u,         219593187308u },
  {  9066702926218949317u, 12330859528790939137u,         236561876684u },
  {  9119392417260546810u,  8973160144879916806u,         204668457234u },
  {  9723021096578315109u,  2895354388547509877u,          18486435986u },
  { 14787464248751217597u, 16766844772497556429u,         146156957475u },
  {  3733434565920249133u,  7442407174620948827u,          35908932476u },
  {  6643788868836820841u,  6683013428676659077u,         124403453701u },
  {  4729646697422664063u, 16713703375071907588u,           5362286883u },
  {  4090144564201555829u,  8791044883080637861u,          35906051675u },
  {  2109480737093400002u,   602844107089214413u,          91476563498u },
  { 16577155033369419739u,  9754832281172880875u,          42032680244u },
  {   745377248603805917u, 10587846778003503903u,          52528810517u },
  { 11305561465807999667u, 17206244172922947013u,          21573968323u },
  {  2211245518782892177u, 11620628420699303875u,         195932752365u },
  { 14170095199249735666u, 17864732368219338611u,         237629955528u },
  { 17849973668116118927u,  4146383014621345887u,         200968449082u },
  {  9020960204585720001u, 11445705075042688243u,          58224775873u },
  { 10807134002871850916u,  7369147888966546592u,         193620472915u },
  {  3925122626254791201u,  9762476865090597796u,          83399482307u },
  { 17208463291312718997u,  5507001428194242827u,         195529224931u },
  {  5145077219589447653u, 11371471148365328344u,         227298535145u },
  { 17602397765035489468u,  3148788104946538618u,         233616448686u },
  { 16422643262490753377u,  3762722308424507574u,         174170696145u },
  {  2902509461400906224u,  1156171244825745915u,         209203977585u },
  {  3422418805967265206u, 14208921674868257865u,         113062676168u },
  {  4228874576277237392u,  7903080886897905503u,         200770267187u },
  {  2553488530807495751u,  6367240794154270982u,          51428426873u },
  { 11546099176912486413u,  1623672396662369850u,         121345168815u },
  { 10460791037534167991u, 18323231215381674394u,         175088019456u },
  {  8127117908566000904u,  9842279843006544554u,            993304354u },
  { 11541304458088287306u,  7376839231308610600u,          34533551059u },
  {  6249718665174839700u,   609751749293657672u,         211399899256u },
  { 13102508413386290995u, 10386457966860989799u,         120033054708u },
  {  6274675218640661911u, 11160336020836149780u,         244563051014u },
  {  3404497118599817167u, 17947559933847409193u,           6605003027u },
  { 11258566093988562335u, 10229787001712704590u,          19972939173u },
  { 16762592482501635397u, 10441677090043619866u,         165554557864u },
  {  5550125446725071998u,  4996681336392922375u,         168566044449u },
  {  6370033225258510318u,   124497102381021895u,          33270870638u },
  {  1503521728674735398u,  8180812057779384577u,         110006749001u },
  {  4250415082606384364u,  5294232873532946716u,          73443482710u },
  {  6020091901030562974u,  2885620189169448039u,          86287000939u },
  { 16288222967151527138u, 16662526875008170507u,         107156429783u },
  {  6377016228656203782u, 15663095032402672480u,         215903277391u },
  {  8378856515587563750u,  1824281504410546614u,          79849098083u },
  { 15812881490200838483u,  9506565509584809953u,          99098894498u },
  {  4548570371183413652u, 16941136942345070055u,         162515351948u },
  { 16731431495283420383u, 15924115693705937725u,         140918380873u },
  { 14737727629551135532u,  9247807690406628462u,          73863248041u },
  { 12413722258104293893u,  7993916633864834871u,         169501324659u },
  {   800899742400762438u,  1018504409177639408u,         115433351089u },
  {   603197008376033550u, 12097800686634130718u,         177055213234u },
  {  6380777281587743935u,  6221488888422637551u,         178655823089u },
  { 10001440249018225388u,  8229322865256080421u,         241337267588u },
  {  5505914461980436708u,  7927745108183101786u,         132446112486u },
  {  1105464290051876864u,  8488683721235326653u,         230429763923u },
  {  4500443576769970176u, 11165516518170922283u,          83460172466u },
  {  2843045143185981440u,  5463648141113596927u,         178605283863u },
  {   660949699682893824u,  3958440403860778042u,          23296184959u },
  {   276549164618219520u,  5091534813990256011u,         127214587484u },
  {  4683743612465315840u,  6100166970623291280u,          92276012655u },
  {                    0u,  1913011027739012426u,         111330690714u },
  {                    0u, 11310957650604221440u,         154103704535u },
  {                    0u, 16303817257009020928u,         215613168242u },
  {                    0u,  9090406322154766336u,         114883831704u },
  {                    0u,  3003279315069566976u,         152492791914u },
  {                    0u, 16582887146675765248u,         106162808097u },
  {                    0u,  9691746398101307392u,          33898960113u },
  {                    0u,                    0u,         241525390625u },
  {                    0u,                    0u,          33000000000u },
};


}


#pragma warning(pop)
#pragma pack(pop)

#line 4828 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu_tables.h"
#line 4829 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu_tables.h"
#line 46 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu.h"


#line 51 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu.h"

#line 53 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu.h"


#line 57 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu.h"


#line 61 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu.h"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {


[[nodiscard]] inline uint32_t __decimalLength9(const uint32_t __v) {
  
  
  ;
  if (__v >= 100000000) { return 9; }
  if (__v >= 10000000) { return 8; }
  if (__v >= 1000000) { return 7; }
  if (__v >= 100000) { return 6; }
  if (__v >= 10000) { return 5; }
  if (__v >= 1000) { return 4; }
  if (__v >= 100) { return 3; }
  if (__v >= 10) { return 2; }
  return 1;
}


[[nodiscard]] inline int32_t __pow5bits(const int32_t __e) {
  
  
  ;
  ;
  return static_cast<int32_t>(((static_cast<uint32_t>(__e) * 1217359) >> 19) + 1);
}


[[nodiscard]] inline uint32_t __log10Pow2(const int32_t __e) {
  
  ;
  ;
  return (static_cast<uint32_t>(__e) * 78913) >> 18;
}


[[nodiscard]] inline uint32_t __log10Pow5(const int32_t __e) {
  
  ;
  ;
  return (static_cast<uint32_t>(__e) * 732923) >> 20;
}

[[nodiscard]] inline uint32_t __float_to_bits(const float __f) {
  uint32_t __bits = 0;
  :: memcpy(&__bits, &__f, sizeof(float));
  return __bits;
}

[[nodiscard]] inline uint64_t __double_to_bits(const double __d) {
  uint64_t __bits = 0;
  :: memcpy(&__bits, &__d, sizeof(double));
  return __bits;
}


inline constexpr int __DOUBLE_MANTISSA_BITS = 52;
inline constexpr int __DOUBLE_BIAS = 1023;

inline constexpr int __DOUBLE_POW5_INV_BITCOUNT = 122;
inline constexpr int __DOUBLE_POW5_BITCOUNT = 121;


#line 165 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu.h"

[[nodiscard]] __forceinline uint64_t __ryu_umul128(const uint64_t __a, const uint64_t __b, uint64_t* const __productHi) {
  
  
  const uint32_t __aLo = static_cast<uint32_t>(__a);
  const uint32_t __aHi = static_cast<uint32_t>(__a >> 32);
  const uint32_t __bLo = static_cast<uint32_t>(__b);
  const uint32_t __bHi = static_cast<uint32_t>(__b >> 32);

  const uint64_t __b00 = static_cast<uint64_t>(__aLo) * __bLo;
  const uint64_t __b01 = static_cast<uint64_t>(__aLo) * __bHi;
  const uint64_t __b10 = static_cast<uint64_t>(__aHi) * __bLo;
  const uint64_t __b11 = static_cast<uint64_t>(__aHi) * __bHi;

  const uint32_t __b00Lo = static_cast<uint32_t>(__b00);
  const uint32_t __b00Hi = static_cast<uint32_t>(__b00 >> 32);

  const uint64_t __mid1 = __b10 + __b00Hi;
  const uint32_t __mid1Lo = static_cast<uint32_t>(__mid1);
  const uint32_t __mid1Hi = static_cast<uint32_t>(__mid1 >> 32);

  const uint64_t __mid2 = __b01 + __mid1Lo;
  const uint32_t __mid2Lo = static_cast<uint32_t>(__mid2);
  const uint32_t __mid2Hi = static_cast<uint32_t>(__mid2 >> 32);

  const uint64_t __pHi = __b11 + __mid1Hi + __mid2Hi;
  const uint64_t __pLo = (static_cast<uint64_t>(__mid2Lo) << 32) | __b00Lo;

  *__productHi = __pHi;
  return __pLo;
}

[[nodiscard]] inline uint64_t __ryu_shiftright128(const uint64_t __lo, const uint64_t __hi, const uint32_t __dist) {
  
  ;


  ;
  return (__hi << (64 - __dist)) | (static_cast<uint32_t>(__lo >> 32) >> (__dist - 32));
#line 208 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu.h"
}

#line 211 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu.h"


[[nodiscard]] inline uint64_t __umulh(const uint64_t __a, const uint64_t __b) {
  
  
  uint64_t __hi;
  (void) __ryu_umul128(__a, __b, &__hi);
  return __hi;
}


[[nodiscard]] inline uint64_t __div5(const uint64_t __x) {
  return __umulh(__x, 0xCCCCCCCCCCCCCCCDu) >> 2;
}

[[nodiscard]] inline uint64_t __div10(const uint64_t __x) {
  return __umulh(__x, 0xCCCCCCCCCCCCCCCDu) >> 3;
}

[[nodiscard]] inline uint64_t __div100(const uint64_t __x) {
  return __umulh(__x >> 2, 0x28F5C28F5C28F5C3u) >> 2;
}

[[nodiscard]] inline uint64_t __div1e8(const uint64_t __x) {
  return __umulh(__x, 0xABCC77118461CEFDu) >> 26;
}

[[nodiscard]] inline uint64_t __div1e9(const uint64_t __x) {
  return __umulh(__x >> 9, 0x44B82FA09B5A53u) >> 11;
}

[[nodiscard]] inline uint32_t __mod1e9(const uint64_t __x) {
  
  
  return static_cast<uint32_t>(__x) - 1000000000 * static_cast<uint32_t>(__div1e9(__x));
}


#line 296 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu.h"

[[nodiscard]] inline uint32_t __pow5Factor(uint64_t __value) {
  uint32_t __count = 0;
  for (;;) {
    ;
    const uint64_t __q = __div5(__value);
    const uint32_t __r = static_cast<uint32_t>(__value) - 5 * static_cast<uint32_t>(__q);
    if (__r != 0) {
      break;
    }
    __value = __q;
    ++__count;
  }
  return __count;
}


[[nodiscard]] inline bool __multipleOfPowerOf5(const uint64_t __value, const uint32_t __p) {
  
  return __pow5Factor(__value) >= __p;
}


[[nodiscard]] inline bool __multipleOfPowerOf2(const uint64_t __value, const uint32_t __p) {
  ;
  ;
  
  return (__value & ((1ull << __p) - 1)) == 0;
}


inline constexpr int __POW10_ADDITIONAL_BITS = 120;


#line 364 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu.h"

[[nodiscard]] inline uint32_t __mulShift_mod1e9(const uint64_t __m, const uint64_t* const __mul, const int32_t __j) {
  uint64_t __high0;                                               
  const uint64_t __low0 = __ryu_umul128(__m, __mul[0], &__high0); 
  uint64_t __high1;                                               
  const uint64_t __low1 = __ryu_umul128(__m, __mul[1], &__high1); 
  uint64_t __high2;                                               
  const uint64_t __low2 = __ryu_umul128(__m, __mul[2], &__high2); 
  const uint64_t __s0low = __low0;                  
  (void) __s0low; 
  const uint64_t __s0high = __low1 + __high0;       
  const uint32_t __c1 = __s0high < __low1;
  const uint64_t __s1low = __low2 + __high1 + __c1; 
  const uint32_t __c2 = __s1low < __low2; 
  const uint64_t __s1high = __high2 + __c2;         
  ;
  ;


#line 387 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu.h"
  if (__j < 160) { 
    const uint64_t __r0 = __mod1e9(__s1high);
    const uint64_t __r1 = __mod1e9((__r0 << 32) | (__s1low >> 32));
    const uint64_t __r2 = ((__r1 << 32) | (__s1low & 0xffffffff));
    return __mod1e9(__r2 >> (__j - 128));
  } else { 
    const uint64_t __r0 = __mod1e9(__s1high);
    const uint64_t __r1 = ((__r0 << 32) | (__s1low >> 32));
    return __mod1e9(__r1 >> (__j - 160));
  }
#line 398 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu.h"
}


template <class _CharT>
void __append_n_digits(const uint32_t __olength, uint32_t __digits, _CharT* const __result) {
  uint32_t __i = 0;
  while (__digits >= 10000) {


    const uint32_t __c = __digits % 10000;
#line 411 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu.h"
    __digits /= 10000;
    const uint32_t __c0 = (__c % 100) << 1;
    const uint32_t __c1 = (__c / 100) << 1;
    :: memcpy(__result + __olength - __i - 2, __DIGIT_TABLE<_CharT> + __c0, 2 * sizeof(_CharT));
    :: memcpy(__result + __olength - __i - 4, __DIGIT_TABLE<_CharT> + __c1, 2 * sizeof(_CharT));
    __i += 4;
  }
  if (__digits >= 100) {
    const uint32_t __c = (__digits % 100) << 1;
    __digits /= 100;
    :: memcpy(__result + __olength - __i - 2, __DIGIT_TABLE<_CharT> + __c, 2 * sizeof(_CharT));
    __i += 2;
  }
  if (__digits >= 10) {
    const uint32_t __c = __digits << 1;
    :: memcpy(__result + __olength - __i - 2, __DIGIT_TABLE<_CharT> + __c, 2 * sizeof(_CharT));
  } else {
    __result[0] = static_cast<_CharT>(static_cast<_CharT>(is_same_v<_CharT, char> ? '0' : L'0') + __digits);
  }
}

inline void __append_d_digits(const uint32_t __olength, uint32_t __digits, char* const __result) {
  uint32_t __i = 0;
  while (__digits >= 10000) {


    const uint32_t __c = __digits % 10000;
#line 440 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu.h"
    __digits /= 10000;
    const uint32_t __c0 = (__c % 100) << 1;
    const uint32_t __c1 = (__c / 100) << 1;
    :: memcpy(__result + __olength + 1 - __i - 2, __DIGIT_TABLE<char> + __c0, 2);
    :: memcpy(__result + __olength + 1 - __i - 4, __DIGIT_TABLE<char> + __c1, 2);
    __i += 4;
  }
  if (__digits >= 100) {
    const uint32_t __c = (__digits % 100) << 1;
    __digits /= 100;
    :: memcpy(__result + __olength + 1 - __i - 2, __DIGIT_TABLE<char> + __c, 2);
    __i += 2;
  }
  if (__digits >= 10) {
    const uint32_t __c = __digits << 1;
    __result[2] = __DIGIT_TABLE<char>[__c + 1];
    __result[1] = '.';
    __result[0] = __DIGIT_TABLE<char>[__c];
  } else {
    __result[1] = '.';
    __result[0] = static_cast<char>('0' + __digits);
  }
}

template <class _CharT>
void __append_c_digits(const uint32_t __count, uint32_t __digits, _CharT* const __result) {
  uint32_t __i = 0;
  for (; __i < __count - 1; __i += 2) {
    const uint32_t __c = (__digits % 100) << 1;
    __digits /= 100;
    :: memcpy(__result + __count - __i - 2, __DIGIT_TABLE<_CharT> + __c, 2 * sizeof(_CharT));
  }
  if (__i < __count) {
    const _CharT __c = static_cast<_CharT>(static_cast<_CharT>(is_same_v<_CharT, char> ? '0' : L'0') + (__digits % 10));
    __result[__count - __i - 1] = __c;
  }
}

template <class _CharT>
void __append_nine_digits(uint32_t __digits, _CharT* const __result) {
  if (__digits == 0) {
    ::std:: fill_n(__result, 9, static_cast<_CharT>(is_same_v<_CharT, char> ? '0' : L'0'));
    return;
  }

  for (uint32_t __i = 0; __i < 5; __i += 4) {


    const uint32_t __c = __digits % 10000;
#line 491 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu.h"
    __digits /= 10000;
    const uint32_t __c0 = (__c % 100) << 1;
    const uint32_t __c1 = (__c / 100) << 1;
    :: memcpy(__result + 7 - __i, __DIGIT_TABLE<_CharT> + __c0, 2 * sizeof(_CharT));
    :: memcpy(__result + 5 - __i, __DIGIT_TABLE<_CharT> + __c1, 2 * sizeof(_CharT));
  }
  __result[0] = static_cast<_CharT>(static_cast<_CharT>(is_same_v<_CharT, char> ? '0' : L'0') + __digits);
}

[[nodiscard]] inline uint32_t __indexForExponent(const uint32_t __e) {
  return (__e + 15) / 16;
}

[[nodiscard]] inline uint32_t __pow10BitsForIndex(const uint32_t __idx) {
  return 16 * __idx + __POW10_ADDITIONAL_BITS;
}

[[nodiscard]] inline uint32_t __lengthForIndex(const uint32_t __idx) {
  
  return (__log10Pow2(16 * static_cast<int32_t>(__idx)) + 1 + 16 + 8) / 9;
}

template <class _CharT>
[[nodiscard]] pair<_CharT*, errc> __d2fixed_buffered_n(_CharT* _First, _CharT* const _Last, const double __d,
  const uint32_t __precision) {
  _CharT* const _Original_first = _First;

  const uint64_t __bits = __double_to_bits(__d);

  
  if (__bits == 0) {
    const int32_t _Total_zero_length = 1 
      + static_cast<int32_t>(__precision != 0) 
      + static_cast<int32_t>(__precision); 

    if (_Last - _First < _Total_zero_length) {
      return { _Last, errc::value_too_large };
    }

    *_First++ = static_cast<_CharT>(is_same_v<_CharT, char> ? '0' : L'0');
    if (__precision > 0) {
      *_First++ = static_cast<_CharT>(is_same_v<_CharT, char> ? '.' : L'.');
      ::std:: fill_n(_First, __precision, static_cast<_CharT>(is_same_v<_CharT, char> ? '0' : L'0'));
      _First += __precision;
    }
    return { _First, errc{} };
  }

  
  const uint64_t __ieeeMantissa = __bits & ((1ull << __DOUBLE_MANTISSA_BITS) - 1);
  const uint32_t __ieeeExponent = static_cast<uint32_t>(__bits >> __DOUBLE_MANTISSA_BITS);

  int32_t __e2;
  uint64_t __m2;
  if (__ieeeExponent == 0) {
    __e2 = 1 - __DOUBLE_BIAS - __DOUBLE_MANTISSA_BITS;
    __m2 = __ieeeMantissa;
  } else {
    __e2 = static_cast<int32_t>(__ieeeExponent) - __DOUBLE_BIAS - __DOUBLE_MANTISSA_BITS;
    __m2 = (1ull << __DOUBLE_MANTISSA_BITS) | __ieeeMantissa;
  }

  bool __nonzero = false;
  if (__e2 >= -52) {
    const uint32_t __idx = __e2 < 0 ? 0 : __indexForExponent(static_cast<uint32_t>(__e2));
    const uint32_t __p10bits = __pow10BitsForIndex(__idx);
    const int32_t __len = static_cast<int32_t>(__lengthForIndex(__idx));
    for (int32_t __i = __len - 1; __i >= 0; --__i) {
      const uint32_t __j = __p10bits - __e2;
      
      
      const uint32_t __digits = __mulShift_mod1e9(__m2 << 8, __POW10_SPLIT[__POW10_OFFSET[__idx] + __i],
        static_cast<int32_t>(__j + 8));
      if (__nonzero) {
        if (_Last - _First < 9) {
          return { _Last, errc::value_too_large };
        }
        __append_nine_digits(__digits, _First);
        _First += 9;
      } else if (__digits != 0) {
        const uint32_t __olength = __decimalLength9(__digits);
        if (_Last - _First < static_cast<ptrdiff_t>(__olength)) {
          return { _Last, errc::value_too_large };
        }
        __append_n_digits(__olength, __digits, _First);
        _First += __olength;
        __nonzero = true;
      }
    }
  }
  if (!__nonzero) {
    if (_First == _Last) {
      return { _Last, errc::value_too_large };
    }
    *_First++ = static_cast<_CharT>(is_same_v<_CharT, char> ? '0' : L'0');
  }
  if (__precision > 0) {
    if (_First == _Last) {
      return { _Last, errc::value_too_large };
    }
    *_First++ = static_cast<_CharT>(is_same_v<_CharT, char> ? '.' : L'.');
  }
  if (__e2 < 0) {
    const int32_t __idx = -__e2 / 16;
    const uint32_t __blocks = __precision / 9 + 1;
    
    int __roundUp = 0;
    uint32_t __i = 0;
    if (__blocks <= __MIN_BLOCK_2[__idx]) {
      __i = __blocks;
      if (_Last - _First < static_cast<ptrdiff_t>(__precision)) {
        return { _Last, errc::value_too_large };
      }
      ::std:: fill_n(_First, __precision, static_cast<_CharT>(is_same_v<_CharT, char> ? '0' : L'0'));
      _First += __precision;
    } else if (__i < __MIN_BLOCK_2[__idx]) {
      __i = __MIN_BLOCK_2[__idx];
      if (_Last - _First < static_cast<ptrdiff_t>(9 * __i)) {
        return { _Last, errc::value_too_large };
      }
      ::std:: fill_n(_First, 9 * __i, static_cast<_CharT>(is_same_v<_CharT, char> ? '0' : L'0'));
      _First += 9 * __i;
    }
    for (; __i < __blocks; ++__i) {
      const int32_t __j = __ADDITIONAL_BITS_2 + (-__e2 - 16 * __idx);
      const uint32_t __p = __POW10_OFFSET_2[__idx] + __i - __MIN_BLOCK_2[__idx];
      if (__p >= __POW10_OFFSET_2[__idx + 1]) {
        
        
        const uint32_t __fill = __precision - 9 * __i;
        if (_Last - _First < static_cast<ptrdiff_t>(__fill)) {
          return { _Last, errc::value_too_large };
        }
        ::std:: fill_n(_First, __fill, static_cast<_CharT>(is_same_v<_CharT, char> ? '0' : L'0'));
        _First += __fill;
        break;
      }
      
      
      uint32_t __digits = __mulShift_mod1e9(__m2 << 8, __POW10_SPLIT_2[__p], __j + 8);
      if (__i < __blocks - 1) {
        if (_Last - _First < 9) {
          return { _Last, errc::value_too_large };
        }
        __append_nine_digits(__digits, _First);
        _First += 9;
      } else {
        const uint32_t __maximum = __precision - 9 * __i;
        uint32_t __lastDigit = 0;
        for (uint32_t __k = 0; __k < 9 - __maximum; ++__k) {
          __lastDigit = __digits % 10;
          __digits /= 10;
        }
        if (__lastDigit != 5) {
          __roundUp = __lastDigit > 5;
        } else {
          
          const int32_t __requiredTwos = -__e2 - static_cast<int32_t>(__precision) - 1;
          const bool __trailingZeros = __requiredTwos <= 0
            || (__requiredTwos < 60 && __multipleOfPowerOf2(__m2, static_cast<uint32_t>(__requiredTwos)));
          __roundUp = __trailingZeros ? 2 : 1;
        }
        if (__maximum > 0) {
          if (_Last - _First < static_cast<ptrdiff_t>(__maximum)) {
            return { _Last, errc::value_too_large };
          }
          __append_c_digits(__maximum, __digits, _First);
          _First += __maximum;
        }
        break;
      }
    }
    if (__roundUp != 0) {
      _CharT* _Round = _First;
      _CharT* _Dot = _Last;
      while (true) {
        if (_Round == _Original_first) {
          _Round[0] = static_cast<_CharT>(is_same_v<_CharT, char> ? '1' : L'1');
          if (_Dot != _Last) {
            _Dot[0] = static_cast<_CharT>(is_same_v<_CharT, char> ? '0' : L'0');
            _Dot[1] = static_cast<_CharT>(is_same_v<_CharT, char> ? '.' : L'.');
          }
          if (_First == _Last) {
            return { _Last, errc::value_too_large };
          }
          *_First++ = static_cast<_CharT>(is_same_v<_CharT, char> ? '0' : L'0');
          break;
        }
        --_Round;
        const _CharT __c = _Round[0];
        if (__c == static_cast<_CharT>(is_same_v<_CharT, char> ? '.' : L'.')) {
          _Dot = _Round;
        } else if (__c == static_cast<_CharT>(is_same_v<_CharT, char> ? '9' : L'9')) {
          _Round[0] = static_cast<_CharT>(is_same_v<_CharT, char> ? '0' : L'0');
          __roundUp = 1;
        } else {
          if (__roundUp == 1 || __c % 2 != 0) {
            _Round[0] = static_cast<_CharT>(__c + 1);
          }
          break;
        }
      }
    }
  } else {
    if (_Last - _First < static_cast<ptrdiff_t>(__precision)) {
      return { _Last, errc::value_too_large };
    }
    ::std:: fill_n(_First, __precision, static_cast<_CharT>(is_same_v<_CharT, char> ? '0' : L'0'));
    _First += __precision;
  }
  return { _First, errc{} };
}

[[nodiscard]] inline to_chars_result __d2exp_buffered_n(char* _First, char* const _Last, const double __d,
  uint32_t __precision) {
  char* const _Original_first = _First;

  const uint64_t __bits = __double_to_bits(__d);

  
  if (__bits == 0) {
    const int32_t _Total_zero_length = 1 
      + static_cast<int32_t>(__precision != 0) 
      + static_cast<int32_t>(__precision) 
      + 4; 
    if (_Last - _First < _Total_zero_length) {
      return { _Last, errc::value_too_large };
    }
    *_First++ = '0';
    if (__precision > 0) {
      *_First++ = '.';
      :: memset(_First, '0', __precision);
      _First += __precision;
    }
    :: memcpy(_First, "e+00", 4);
    _First += 4;
    return { _First, errc{} };
  }

  
  const uint64_t __ieeeMantissa = __bits & ((1ull << __DOUBLE_MANTISSA_BITS) - 1);
  const uint32_t __ieeeExponent = static_cast<uint32_t>(__bits >> __DOUBLE_MANTISSA_BITS);

  int32_t __e2;
  uint64_t __m2;
  if (__ieeeExponent == 0) {
    __e2 = 1 - __DOUBLE_BIAS - __DOUBLE_MANTISSA_BITS;
    __m2 = __ieeeMantissa;
  } else {
    __e2 = static_cast<int32_t>(__ieeeExponent) - __DOUBLE_BIAS - __DOUBLE_MANTISSA_BITS;
    __m2 = (1ull << __DOUBLE_MANTISSA_BITS) | __ieeeMantissa;
  }

  const bool __printDecimalPoint = __precision > 0;
  ++__precision;
  uint32_t __digits = 0;
  uint32_t __printedDigits = 0;
  uint32_t __availableDigits = 0;
  int32_t __exp = 0;
  if (__e2 >= -52) {
    const uint32_t __idx = __e2 < 0 ? 0 : __indexForExponent(static_cast<uint32_t>(__e2));
    const uint32_t __p10bits = __pow10BitsForIndex(__idx);
    const int32_t __len = static_cast<int32_t>(__lengthForIndex(__idx));
    for (int32_t __i = __len - 1; __i >= 0; --__i) {
      const uint32_t __j = __p10bits - __e2;
      
      
      __digits = __mulShift_mod1e9(__m2 << 8, __POW10_SPLIT[__POW10_OFFSET[__idx] + __i],
        static_cast<int32_t>(__j + 8));
      if (__printedDigits != 0) {
        if (__printedDigits + 9 > __precision) {
          __availableDigits = 9;
          break;
        }
        if (_Last - _First < 9) {
          return { _Last, errc::value_too_large };
        }
        __append_nine_digits(__digits, _First);
        _First += 9;
        __printedDigits += 9;
      } else if (__digits != 0) {
        __availableDigits = __decimalLength9(__digits);
        __exp = __i * 9 + static_cast<int32_t>(__availableDigits) - 1;
        if (__availableDigits > __precision) {
          break;
        }
        if (__printDecimalPoint) {
          if (_Last - _First < static_cast<ptrdiff_t>(__availableDigits + 1)) {
            return { _Last, errc::value_too_large };
          }
          __append_d_digits(__availableDigits, __digits, _First);
          _First += __availableDigits + 1; 
        } else {
          if (_First == _Last) {
            return { _Last, errc::value_too_large };
          }
          *_First++ = static_cast<char>('0' + __digits);
        }
        __printedDigits = __availableDigits;
        __availableDigits = 0;
      }
    }
  }

  if (__e2 < 0 && __availableDigits == 0) {
    const int32_t __idx = -__e2 / 16;
    for (int32_t __i = __MIN_BLOCK_2[__idx]; __i < 200; ++__i) {
      const int32_t __j = __ADDITIONAL_BITS_2 + (-__e2 - 16 * __idx);
      const uint32_t __p = __POW10_OFFSET_2[__idx] + static_cast<uint32_t>(__i) - __MIN_BLOCK_2[__idx];
      
      
      __digits = (__p >= __POW10_OFFSET_2[__idx + 1]) ? 0 : __mulShift_mod1e9(__m2 << 8, __POW10_SPLIT_2[__p], __j + 8);
      if (__printedDigits != 0) {
        if (__printedDigits + 9 > __precision) {
          __availableDigits = 9;
          break;
        }
        if (_Last - _First < 9) {
          return { _Last, errc::value_too_large };
        }
        __append_nine_digits(__digits, _First);
        _First += 9;
        __printedDigits += 9;
      } else if (__digits != 0) {
        __availableDigits = __decimalLength9(__digits);
        __exp = -(__i + 1) * 9 + static_cast<int32_t>(__availableDigits) - 1;
        if (__availableDigits > __precision) {
          break;
        }
        if (__printDecimalPoint) {
          if (_Last - _First < static_cast<ptrdiff_t>(__availableDigits + 1)) {
            return { _Last, errc::value_too_large };
          }
          __append_d_digits(__availableDigits, __digits, _First);
          _First += __availableDigits + 1; 
        } else {
          if (_First == _Last) {
            return { _Last, errc::value_too_large };
          }
          *_First++ = static_cast<char>('0' + __digits);
        }
        __printedDigits = __availableDigits;
        __availableDigits = 0;
      }
    }
  }

  const uint32_t __maximum = __precision - __printedDigits;
  if (__availableDigits == 0) {
    __digits = 0;
  }
  uint32_t __lastDigit = 0;
  if (__availableDigits > __maximum) {
    for (uint32_t __k = 0; __k < __availableDigits - __maximum; ++__k) {
      __lastDigit = __digits % 10;
      __digits /= 10;
    }
  }
  
  int __roundUp = 0;
  if (__lastDigit != 5) {
    __roundUp = __lastDigit > 5;
  } else {
    
    
    const int32_t __rexp = static_cast<int32_t>(__precision) - __exp;
    const int32_t __requiredTwos = -__e2 - __rexp;
    bool __trailingZeros = __requiredTwos <= 0
      || (__requiredTwos < 60 && __multipleOfPowerOf2(__m2, static_cast<uint32_t>(__requiredTwos)));
    if (__rexp < 0) {
      const int32_t __requiredFives = -__rexp;
      __trailingZeros = __trailingZeros && __multipleOfPowerOf5(__m2, static_cast<uint32_t>(__requiredFives));
    }
    __roundUp = __trailingZeros ? 2 : 1;
  }
  if (__printedDigits != 0) {
    if (_Last - _First < static_cast<ptrdiff_t>(__maximum)) {
      return { _Last, errc::value_too_large };
    }
    if (__digits == 0) {
      :: memset(_First, '0', __maximum);
    } else {
      __append_c_digits(__maximum, __digits, _First);
    }
    _First += __maximum;
  } else {
    if (__printDecimalPoint) {
      if (_Last - _First < static_cast<ptrdiff_t>(__maximum + 1)) {
        return { _Last, errc::value_too_large };
      }
      __append_d_digits(__maximum, __digits, _First);
      _First += __maximum + 1; 
    } else {
      if (_First == _Last) {
        return { _Last, errc::value_too_large };
      }
      *_First++ = static_cast<char>('0' + __digits);
    }
  }
  if (__roundUp != 0) {
    char* _Round = _First;
    while (true) {
      if (_Round == _Original_first) {
        _Round[0] = '1';
        ++__exp;
        break;
      }
      --_Round;
      const char __c = _Round[0];
      if (__c == '.') {
        
      } else if (__c == '9') {
        _Round[0] = '0';
        __roundUp = 1;
      } else {
        if (__roundUp == 1 || __c % 2 != 0) {
          _Round[0] = __c + 1;
        }
        break;
      }
    }
  }

  char _Sign_character;

  if (__exp < 0) {
    _Sign_character = '-';
    __exp = -__exp;
  } else {
    _Sign_character = '+';
  }

  const int _Exponent_part_length = __exp >= 100
    ? 5 
    : 4; 

  if (_Last - _First < _Exponent_part_length) {
    return { _Last, errc::value_too_large };
  }

  *_First++ = 'e';
  *_First++ = _Sign_character;

  if (__exp >= 100) {
    const int32_t __c = __exp % 10;
    :: memcpy(_First, __DIGIT_TABLE<char> + 2 * (__exp / 10), 2);
    _First[2] = static_cast<char>('0' + __c);
    _First += 3;
  } else {
    :: memcpy(_First, __DIGIT_TABLE<char> + 2 * __exp, 2);
    _First += 2;
  }

  return { _First, errc{} };
}


inline constexpr int __FLOAT_MANTISSA_BITS = 23;
inline constexpr int __FLOAT_BIAS = 127;


inline constexpr int __FLOAT_POW5_INV_BITCOUNT = 59;
inline constexpr uint64_t __FLOAT_POW5_INV_SPLIT[31] = {
  576460752303423489u, 461168601842738791u, 368934881474191033u, 295147905179352826u,
  472236648286964522u, 377789318629571618u, 302231454903657294u, 483570327845851670u,
  386856262276681336u, 309485009821345069u, 495176015714152110u, 396140812571321688u,
  316912650057057351u, 507060240091291761u, 405648192073033409u, 324518553658426727u,
  519229685853482763u, 415383748682786211u, 332306998946228969u, 531691198313966350u,
  425352958651173080u, 340282366920938464u, 544451787073501542u, 435561429658801234u,
  348449143727040987u, 557518629963265579u, 446014903970612463u, 356811923176489971u,
  570899077082383953u, 456719261665907162u, 365375409332725730u
};
inline constexpr int __FLOAT_POW5_BITCOUNT = 61;
inline constexpr uint64_t __FLOAT_POW5_SPLIT[47] = {
  1152921504606846976u, 1441151880758558720u, 1801439850948198400u, 2251799813685248000u,
  1407374883553280000u, 1759218604441600000u, 2199023255552000000u, 1374389534720000000u,
  1717986918400000000u, 2147483648000000000u, 1342177280000000000u, 1677721600000000000u,
  2097152000000000000u, 1310720000000000000u, 1638400000000000000u, 2048000000000000000u,
  1280000000000000000u, 1600000000000000000u, 2000000000000000000u, 1250000000000000000u,
  1562500000000000000u, 1953125000000000000u, 1220703125000000000u, 1525878906250000000u,
  1907348632812500000u, 1192092895507812500u, 1490116119384765625u, 1862645149230957031u,
  1164153218269348144u, 1455191522836685180u, 1818989403545856475u, 2273736754432320594u,
  1421085471520200371u, 1776356839400250464u, 2220446049250313080u, 1387778780781445675u,
  1734723475976807094u, 2168404344971008868u, 1355252715606880542u, 1694065894508600678u,
  2117582368135750847u, 1323488980084844279u, 1654361225106055349u, 2067951531382569187u,
  1292469707114105741u, 1615587133892632177u, 2019483917365790221u
};

[[nodiscard]] inline uint32_t __pow5Factor(uint32_t __value) {
  uint32_t __count = 0;
  for (;;) {
    ;
    const uint32_t __q = __value / 5;
    const uint32_t __r = __value % 5;
    if (__r != 0) {
      break;
    }
    __value = __q;
    ++__count;
  }
  return __count;
}


[[nodiscard]] inline bool __multipleOfPowerOf5(const uint32_t __value, const uint32_t __p) {
  return __pow5Factor(__value) >= __p;
}


[[nodiscard]] inline bool __multipleOfPowerOf2(const uint32_t __value, const uint32_t __p) {
  ;
  ;
  
  return (__value & ((1u << __p) - 1)) == 0;
}

[[nodiscard]] inline uint32_t __mulShift(const uint32_t __m, const uint64_t __factor, const int32_t __shift) {
  ;

  
  const uint32_t __factorLo = static_cast<uint32_t>(__factor);
  const uint32_t __factorHi = static_cast<uint32_t>(__factor >> 32);
  const uint64_t __bits0 = static_cast<uint64_t>(__m) * __factorLo;
  const uint64_t __bits1 = static_cast<uint64_t>(__m) * __factorHi;


  const uint32_t __bits0Hi = static_cast<uint32_t>(__bits0 >> 32);
  uint32_t __bits1Lo = static_cast<uint32_t>(__bits1);
  uint32_t __bits1Hi = static_cast<uint32_t>(__bits1 >> 32);
  __bits1Lo += __bits0Hi;
  __bits1Hi += (__bits1Lo < __bits0Hi);
  const int32_t __s = __shift - 32;
  return (__bits1Hi << (32 - __s)) | (__bits1Lo >> __s);


#line 1036 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu.h"
}

[[nodiscard]] inline uint32_t __mulPow5InvDivPow2(const uint32_t __m, const uint32_t __q, const int32_t __j) {
  return __mulShift(__m, __FLOAT_POW5_INV_SPLIT[__q], __j);
}

[[nodiscard]] inline uint32_t __mulPow5divPow2(const uint32_t __m, const uint32_t __i, const int32_t __j) {
  return __mulShift(__m, __FLOAT_POW5_SPLIT[__i], __j);
}


struct __floating_decimal_32 {
  uint32_t __mantissa;
  int32_t __exponent;
};

[[nodiscard]] inline __floating_decimal_32 __f2d(const uint32_t __ieeeMantissa, const uint32_t __ieeeExponent) {
  int32_t __e2;
  uint32_t __m2;
  if (__ieeeExponent == 0) {
    
    __e2 = 1 - __FLOAT_BIAS - __FLOAT_MANTISSA_BITS - 2;
    __m2 = __ieeeMantissa;
  } else {
    __e2 = static_cast<int32_t>(__ieeeExponent) - __FLOAT_BIAS - __FLOAT_MANTISSA_BITS - 2;
    __m2 = (1u << __FLOAT_MANTISSA_BITS) | __ieeeMantissa;
  }
  const bool __even = (__m2 & 1) == 0;
  const bool __acceptBounds = __even;

  
  const uint32_t __mv = 4 * __m2;
  const uint32_t __mp = 4 * __m2 + 2;
  
  const uint32_t __mmShift = __ieeeMantissa != 0 || __ieeeExponent <= 1;
  const uint32_t __mm = 4 * __m2 - 1 - __mmShift;

  
  uint32_t __vr, __vp, __vm;
  int32_t __e10;
  bool __vmIsTrailingZeros = false;
  bool __vrIsTrailingZeros = false;
  uint8_t __lastRemovedDigit = 0;
  if (__e2 >= 0) {
    const uint32_t __q = __log10Pow2(__e2);
    __e10 = static_cast<int32_t>(__q);
    const int32_t __k = __FLOAT_POW5_INV_BITCOUNT + __pow5bits(static_cast<int32_t>(__q)) - 1;
    const int32_t __i = -__e2 + static_cast<int32_t>(__q) + __k;
    __vr = __mulPow5InvDivPow2(__mv, __q, __i);
    __vp = __mulPow5InvDivPow2(__mp, __q, __i);
    __vm = __mulPow5InvDivPow2(__mm, __q, __i);
    if (__q != 0 && (__vp - 1) / 10 <= __vm / 10) {
      
      
      const int32_t __l = __FLOAT_POW5_INV_BITCOUNT + __pow5bits(static_cast<int32_t>(__q - 1)) - 1;
      __lastRemovedDigit = static_cast<uint8_t>(__mulPow5InvDivPow2(__mv, __q - 1,
        -__e2 + static_cast<int32_t>(__q) - 1 + __l) % 10);
    }
    if (__q <= 9) {
      
      
      if (__mv % 5 == 0) {
        __vrIsTrailingZeros = __multipleOfPowerOf5(__mv, __q);
      } else if (__acceptBounds) {
        __vmIsTrailingZeros = __multipleOfPowerOf5(__mm, __q);
      } else {
        __vp -= __multipleOfPowerOf5(__mp, __q);
      }
    }
  } else {
    const uint32_t __q = __log10Pow5(-__e2);
    __e10 = static_cast<int32_t>(__q) + __e2;
    const int32_t __i = -__e2 - static_cast<int32_t>(__q);
    const int32_t __k = __pow5bits(__i) - __FLOAT_POW5_BITCOUNT;
    int32_t __j = static_cast<int32_t>(__q) - __k;
    __vr = __mulPow5divPow2(__mv, static_cast<uint32_t>(__i), __j);
    __vp = __mulPow5divPow2(__mp, static_cast<uint32_t>(__i), __j);
    __vm = __mulPow5divPow2(__mm, static_cast<uint32_t>(__i), __j);
    if (__q != 0 && (__vp - 1) / 10 <= __vm / 10) {
      __j = static_cast<int32_t>(__q) - 1 - (__pow5bits(__i + 1) - __FLOAT_POW5_BITCOUNT);
      __lastRemovedDigit = static_cast<uint8_t>(__mulPow5divPow2(__mv, static_cast<uint32_t>(__i + 1), __j) % 10);
    }
    if (__q <= 1) {
      
      
      __vrIsTrailingZeros = true;
      if (__acceptBounds) {
        
        __vmIsTrailingZeros = __mmShift == 1;
      } else {
        
        --__vp;
      }
    } else if (__q < 31) { 
      __vrIsTrailingZeros = __multipleOfPowerOf2(__mv, __q - 1);
    }
  }

  
  int32_t __removed = 0;
  uint32_t _Output;
  if (__vmIsTrailingZeros || __vrIsTrailingZeros) {
    
    while (__vp / 10 > __vm / 10) {


      __vmIsTrailingZeros &= __vm % 10 == 0;
#line 1146 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu.h"
      __vrIsTrailingZeros &= __lastRemovedDigit == 0;
      __lastRemovedDigit = static_cast<uint8_t>(__vr % 10);
      __vr /= 10;
      __vp /= 10;
      __vm /= 10;
      ++__removed;
    }
    if (__vmIsTrailingZeros) {
      while (__vm % 10 == 0) {
        __vrIsTrailingZeros &= __lastRemovedDigit == 0;
        __lastRemovedDigit = static_cast<uint8_t>(__vr % 10);
        __vr /= 10;
        __vp /= 10;
        __vm /= 10;
        ++__removed;
      }
    }
    if (__vrIsTrailingZeros && __lastRemovedDigit == 5 && __vr % 2 == 0) {
      
      __lastRemovedDigit = 4;
    }
    
    _Output = __vr + ((__vr == __vm && (!__acceptBounds || !__vmIsTrailingZeros)) || __lastRemovedDigit >= 5);
  } else {
    
    
    while (__vp / 10 > __vm / 10) {
      __lastRemovedDigit = static_cast<uint8_t>(__vr % 10);
      __vr /= 10;
      __vp /= 10;
      __vm /= 10;
      ++__removed;
    }
    
    _Output = __vr + (__vr == __vm || __lastRemovedDigit >= 5);
  }
  const int32_t __exp = __e10 + __removed;

  __floating_decimal_32 __fd;
  __fd.__exponent = __exp;
  __fd.__mantissa = _Output;
  return __fd;
}

template <class _CharT>
[[nodiscard]] pair<_CharT*, errc> _Large_integer_to_chars(_CharT* const _First, _CharT* const _Last,
  const uint32_t _Mantissa2, const int32_t _Exponent2) {

  
  ;
  ; 

  
  constexpr uint32_t _Data_size = 4;
  uint32_t _Data[_Data_size]{};

  
  uint32_t _Maxidx = ((24 + static_cast<uint32_t>(_Exponent2) + 31) / 32) - 1;
  ;

  const uint32_t _Bit_shift = static_cast<uint32_t>(_Exponent2) % 32;
  if (_Bit_shift <= 8) { 
    _Data[_Maxidx] = _Mantissa2 << _Bit_shift;
  } else { 
    _Data[_Maxidx - 1] = _Mantissa2 << _Bit_shift;
    _Data[_Maxidx] = _Mantissa2 >> (32 - _Bit_shift);
  }

  
  uint32_t _Blocks[4];
  int32_t _Filled_blocks = 0;
  
  
  if (_Maxidx != 0) { 
                      
    for (;;) {
      

      const uint32_t _Most_significant_elem = _Data[_Maxidx];
      const uint32_t _Initial_remainder = _Most_significant_elem % 1000000000;
      const uint32_t _Initial_quotient = _Most_significant_elem / 1000000000;
      _Data[_Maxidx] = _Initial_quotient;
      uint64_t _Remainder = _Initial_remainder;

      
      uint32_t _Idx = _Maxidx;
      do {
        --_Idx; 

        
        _Remainder = (_Remainder << 32) | _Data[_Idx];

        
        const uint32_t _Quotient = static_cast<uint32_t>(__div1e9(_Remainder));

        
        _Remainder = static_cast<uint32_t>(_Remainder) - 1000000000u * _Quotient;

        _Data[_Idx] = _Quotient;
      } while (_Idx != 0);

      
      _Blocks[_Filled_blocks++] = static_cast<uint32_t>(_Remainder);

      if (_Initial_quotient == 0) { 
        --_Maxidx; 
        if (_Maxidx == 0) {
          break; 
        }
      }
    }
  }

  ;
  for (uint32_t _Idx = 1; _Idx < _Data_size; ++_Idx) {
    ;
  }

  const uint32_t _Data_olength = _Data[0] >= 1000000000 ? 10 : __decimalLength9(_Data[0]);
  const uint32_t _Total_fixed_length = _Data_olength + 9 * _Filled_blocks;

  if (_Last - _First < static_cast<ptrdiff_t>(_Total_fixed_length)) {
    return { _Last, errc::value_too_large };
  }

  _CharT* _Result = _First;

  
  __append_n_digits(_Data_olength, _Data[0], _Result);
  _Result += _Data_olength;

  
  for (int32_t _Idx = _Filled_blocks - 1; _Idx >= 0; --_Idx) {
    __append_nine_digits(_Blocks[_Idx], _Result);
    _Result += 9;
  }

  return { _Result, errc{} };
}

template <class _CharT>
[[nodiscard]] pair<_CharT*, errc> __to_chars(_CharT* const _First, _CharT* const _Last, const __floating_decimal_32 __v,
  chars_format _Fmt, const uint32_t __ieeeMantissa, const uint32_t __ieeeExponent) {
  
  uint32_t _Output = __v.__mantissa;
  int32_t _Ryu_exponent = __v.__exponent;
  const uint32_t __olength = __decimalLength9(_Output);
  int32_t _Scientific_exponent = _Ryu_exponent + static_cast<int32_t>(__olength) - 1;

  if (_Fmt == chars_format{}) {
    int32_t _Lower;
    int32_t _Upper;

    if (__olength == 1) {
      
      
      _Lower = -3;
      _Upper = 4;
    } else {
      
      
      _Lower = -static_cast<int32_t>(__olength + 3);
      _Upper = 5;
    }

    if (_Lower <= _Ryu_exponent && _Ryu_exponent <= _Upper) {
      _Fmt = chars_format::fixed;
    } else {
      _Fmt = chars_format::scientific;
    }
  } else if (_Fmt == chars_format::general) {
    
    
    if (-4 <= _Scientific_exponent && _Scientific_exponent < 6) {
      _Fmt = chars_format::fixed;
    } else {
      _Fmt = chars_format::scientific;
    }
  }

  if (_Fmt == chars_format::fixed) {
    

    const int32_t _Whole_digits = static_cast<int32_t>(__olength) + _Ryu_exponent;

    uint32_t _Total_fixed_length;
    if (_Ryu_exponent >= 0) { 
      _Total_fixed_length = static_cast<uint32_t>(_Whole_digits);
      if (_Output == 1) {
        
        
        static constexpr uint8_t _Adjustment[39] = {
          0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,0,1,1,1,0,0,1,1,0,1,0,1,1,0,0,1,0,1,1,0,1,1,1 };
        _Total_fixed_length -= _Adjustment[_Ryu_exponent];
        
      }
    } else if (_Whole_digits > 0) { 
      _Total_fixed_length = __olength + 1;
    } else { 
      _Total_fixed_length = static_cast<uint32_t>(2 - _Ryu_exponent);
    }

    if (_Last - _First < static_cast<ptrdiff_t>(_Total_fixed_length)) {
      return { _Last, errc::value_too_large };
    }

    _CharT* _Mid;
    if (_Ryu_exponent > 0) { 
      bool _Can_use_ryu;

      if (_Ryu_exponent > 10) { 
        _Can_use_ryu = false;
      } else {
        
        
        static constexpr uint32_t _Max_shifted_mantissa[11] = {
          16777215, 3355443, 671088, 134217, 26843, 5368, 1073, 214, 42, 8, 1 };

        unsigned long _Trailing_zero_bits;
        (void) _BitScanForward(&_Trailing_zero_bits, __v.__mantissa); 
        const uint32_t _Shifted_mantissa = __v.__mantissa >> _Trailing_zero_bits;
        _Can_use_ryu = _Shifted_mantissa <= _Max_shifted_mantissa[_Ryu_exponent];
      }

      if (!_Can_use_ryu) {
        const uint32_t _Mantissa2 = __ieeeMantissa | (1u << __FLOAT_MANTISSA_BITS); 
        const int32_t _Exponent2 = static_cast<int32_t>(__ieeeExponent)
          - __FLOAT_BIAS - __FLOAT_MANTISSA_BITS; 

        
        return _Large_integer_to_chars(_First, _Last, _Mantissa2, _Exponent2);
      }

      
      _Mid = _First + __olength;
    } else { 
      
      _Mid = _First + _Total_fixed_length;
    }

    while (_Output >= 10000) {


      const uint32_t __c = _Output % 10000;
#line 1463 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu.h"
      _Output /= 10000;
      const uint32_t __c0 = (__c % 100) << 1;
      const uint32_t __c1 = (__c / 100) << 1;
      :: memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __c0, 2 * sizeof(_CharT));
      :: memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __c1, 2 * sizeof(_CharT));
    }
    if (_Output >= 100) {
      const uint32_t __c = (_Output % 100) << 1;
      _Output /= 100;
      :: memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __c, 2 * sizeof(_CharT));
    }
    if (_Output >= 10) {
      const uint32_t __c = _Output << 1;
      :: memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __c, 2 * sizeof(_CharT));
    } else {
      *--_Mid = static_cast<_CharT>(static_cast<_CharT>(is_same_v<_CharT, char> ? '0' : L'0') + _Output);
    }

    if (_Ryu_exponent > 0) { 
      
      ::std:: fill_n(_First + __olength, _Ryu_exponent, static_cast<_CharT>(is_same_v<_CharT, char> ? '0' : L'0'));
    } else if (_Ryu_exponent == 0) { 
      
    } else if (_Whole_digits > 0) { 
      
      :: memmove(_First, _First + 1, static_cast<size_t>(_Whole_digits) * sizeof(_CharT));
      _First[_Whole_digits] = static_cast<_CharT>(is_same_v<_CharT, char> ? '.' : L'.');
    } else { 
      
      _First[0] = static_cast<_CharT>(is_same_v<_CharT, char> ? '0' : L'0');
      _First[1] = static_cast<_CharT>(is_same_v<_CharT, char> ? '.' : L'.');
      ::std:: fill_n(_First + 2, -_Whole_digits, static_cast<_CharT>(is_same_v<_CharT, char> ? '0' : L'0'));
    }

    return { _First + _Total_fixed_length, errc{} };
  }

  const uint32_t _Total_scientific_length =
    __olength + (__olength > 1) + 4; 
  if (_Last - _First < static_cast<ptrdiff_t>(_Total_scientific_length)) {
    return { _Last, errc::value_too_large };
  }
  _CharT* const __result = _First;

  
  uint32_t __i = 0;
  while (_Output >= 10000) {


    const uint32_t __c = _Output % 10000;
#line 1515 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu.h"
    _Output /= 10000;
    const uint32_t __c0 = (__c % 100) << 1;
    const uint32_t __c1 = (__c / 100) << 1;
    :: memcpy(__result + __olength - __i - 1, __DIGIT_TABLE<_CharT> + __c0, 2 * sizeof(_CharT));
    :: memcpy(__result + __olength - __i - 3, __DIGIT_TABLE<_CharT> + __c1, 2 * sizeof(_CharT));
    __i += 4;
  }
  if (_Output >= 100) {
    const uint32_t __c = (_Output % 100) << 1;
    _Output /= 100;
    :: memcpy(__result + __olength - __i - 1, __DIGIT_TABLE<_CharT> + __c, 2 * sizeof(_CharT));
    __i += 2;
  }
  if (_Output >= 10) {
    const uint32_t __c = _Output << 1;
    
    __result[2] = __DIGIT_TABLE<_CharT>[__c + 1];
    __result[0] = __DIGIT_TABLE<_CharT>[__c];
  } else {
    __result[0] = static_cast<_CharT>(static_cast<_CharT>(is_same_v<_CharT, char> ? '0' : L'0') + _Output);
  }

  
  uint32_t __index;
  if (__olength > 1) {
    __result[1] = static_cast<_CharT>(is_same_v<_CharT, char> ? '.' : L'.');
    __index = __olength + 1;
  } else {
    __index = 1;
  }

  
  __result[__index++] = static_cast<_CharT>(is_same_v<_CharT, char> ? 'e' : L'e');
  if (_Scientific_exponent < 0) {
    __result[__index++] = static_cast<_CharT>(is_same_v<_CharT, char> ? '-' : L'-');
    _Scientific_exponent = -_Scientific_exponent;
  } else {
    __result[__index++] = static_cast<_CharT>(is_same_v<_CharT, char> ? '+' : L'+');
  }

  :: memcpy(__result + __index, __DIGIT_TABLE<_CharT> + 2 * _Scientific_exponent, 2 * sizeof(_CharT));
  __index += 2;

  return { _First + _Total_scientific_length, errc{} };
}

[[nodiscard]] inline to_chars_result _Convert_to_chars_result(const pair<char*, errc>& _Pair) {
    return {_Pair.first, _Pair.second};
}

template <class _CharT>
[[nodiscard]] pair<_CharT*, errc> __f2s_buffered_n(_CharT* const _First, _CharT* const _Last, const float __f,
  const chars_format _Fmt) {

  
  const uint32_t __bits = __float_to_bits(__f);

  
  if (__bits == 0) {
    if (_Fmt == chars_format::scientific) {
      if (_Last - _First < 5) {
        return { _Last, errc::value_too_large };
      }

      if constexpr (is_same_v<_CharT, char>) {
        :: memcpy(_First, "0e+00", 5);
      } else {
        :: memcpy(_First, L"0e+00", 5 * sizeof(wchar_t));
      }

      return { _First + 5, errc{} };
    }

    
    if (_First == _Last) {
      return { _Last, errc::value_too_large };
    }

    *_First = static_cast<_CharT>(is_same_v<_CharT, char> ? '0' : L'0');

    return { _First + 1, errc{} };
  }

  
  const uint32_t __ieeeMantissa = __bits & ((1u << __FLOAT_MANTISSA_BITS) - 1);
  const uint32_t __ieeeExponent = __bits >> __FLOAT_MANTISSA_BITS;

  
  if (_Fmt == chars_format::fixed) {
    const uint32_t _Mantissa2 = __ieeeMantissa | (1u << __FLOAT_MANTISSA_BITS); 
    const int32_t _Exponent2 = static_cast<int32_t>(__ieeeExponent)
      - __FLOAT_BIAS - __FLOAT_MANTISSA_BITS; 

    
    if (_Exponent2 > 0) {
      return _Large_integer_to_chars(_First, _Last, _Mantissa2, _Exponent2);
    }
  }

  const __floating_decimal_32 __v = __f2d(__ieeeMantissa, __ieeeExponent);
  return __to_chars(_First, _Last, __v, _Fmt, __ieeeMantissa, __ieeeExponent);
}


#line 1685 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu.h"

[[nodiscard]] __forceinline uint64_t __mulShiftAll(uint64_t __m, const uint64_t* const __mul, const int32_t __j,
  uint64_t* const __vp, uint64_t* const __vm, const uint32_t __mmShift) { 
  __m <<= 1;
  
  uint64_t __tmp;
  const uint64_t __lo = __ryu_umul128(__m, __mul[0], &__tmp);
  uint64_t __hi;
  const uint64_t __mid = __tmp + __ryu_umul128(__m, __mul[1], &__hi);
  __hi += __mid < __tmp; 

  const uint64_t __lo2 = __lo + __mul[0];
  const uint64_t __mid2 = __mid + __mul[1] + (__lo2 < __lo);
  const uint64_t __hi2 = __hi + (__mid2 < __mid);
  *__vp = __ryu_shiftright128(__mid2, __hi2, static_cast<uint32_t>(__j - 64 - 1));

  if (__mmShift == 1) {
    const uint64_t __lo3 = __lo - __mul[0];
    const uint64_t __mid3 = __mid - __mul[1] - (__lo3 > __lo);
    const uint64_t __hi3 = __hi - (__mid3 > __mid);
    *__vm = __ryu_shiftright128(__mid3, __hi3, static_cast<uint32_t>(__j - 64 - 1));
  } else {
    const uint64_t __lo3 = __lo + __lo;
    const uint64_t __mid3 = __mid + __mid + (__lo3 < __lo);
    const uint64_t __hi3 = __hi + __hi + (__mid3 < __mid);
    const uint64_t __lo4 = __lo3 - __mul[0];
    const uint64_t __mid4 = __mid3 - __mul[1] - (__lo4 > __lo3);
    const uint64_t __hi4 = __hi3 - (__mid4 > __mid3);
    *__vm = __ryu_shiftright128(__mid4, __hi4, static_cast<uint32_t>(__j - 64));
  }

  return __ryu_shiftright128(__mid, __hi, static_cast<uint32_t>(__j - 64 - 1));
}

#line 1720 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu.h"

[[nodiscard]] inline uint32_t __decimalLength17(const uint64_t __v) {
  
  
  ;
  if (__v >= 10000000000000000u) { return 17; }
  if (__v >= 1000000000000000u) { return 16; }
  if (__v >= 100000000000000u) { return 15; }
  if (__v >= 10000000000000u) { return 14; }
  if (__v >= 1000000000000u) { return 13; }
  if (__v >= 100000000000u) { return 12; }
  if (__v >= 10000000000u) { return 11; }
  if (__v >= 1000000000u) { return 10; }
  if (__v >= 100000000u) { return 9; }
  if (__v >= 10000000u) { return 8; }
  if (__v >= 1000000u) { return 7; }
  if (__v >= 100000u) { return 6; }
  if (__v >= 10000u) { return 5; }
  if (__v >= 1000u) { return 4; }
  if (__v >= 100u) { return 3; }
  if (__v >= 10u) { return 2; }
  return 1;
}


struct __floating_decimal_64 {
  uint64_t __mantissa;
  int32_t __exponent;
};

[[nodiscard]] inline __floating_decimal_64 __d2d(const uint64_t __ieeeMantissa, const uint32_t __ieeeExponent) {
  int32_t __e2;
  uint64_t __m2;
  if (__ieeeExponent == 0) {
    
    __e2 = 1 - __DOUBLE_BIAS - __DOUBLE_MANTISSA_BITS - 2;
    __m2 = __ieeeMantissa;
  } else {
    __e2 = static_cast<int32_t>(__ieeeExponent) - __DOUBLE_BIAS - __DOUBLE_MANTISSA_BITS - 2;
    __m2 = (1ull << __DOUBLE_MANTISSA_BITS) | __ieeeMantissa;
  }
  const bool __even = (__m2 & 1) == 0;
  const bool __acceptBounds = __even;

  
  const uint64_t __mv = 4 * __m2;
  
  const uint32_t __mmShift = __ieeeMantissa != 0 || __ieeeExponent <= 1;
  
  
  uint64_t __vr, __vp, __vm;
  int32_t __e10;
  bool __vmIsTrailingZeros = false;
  bool __vrIsTrailingZeros = false;
  if (__e2 >= 0) {
    
    
    const uint32_t __q = __log10Pow2(__e2) - (__e2 > 3);
    __e10 = static_cast<int32_t>(__q);
    const int32_t __k = __DOUBLE_POW5_INV_BITCOUNT + __pow5bits(static_cast<int32_t>(__q)) - 1;
    const int32_t __i = -__e2 + static_cast<int32_t>(__q) + __k;
    __vr = __mulShiftAll(__m2, __DOUBLE_POW5_INV_SPLIT[__q], __i, &__vp, &__vm, __mmShift);
    if (__q <= 21) {
      
      
      const uint32_t __mvMod5 = static_cast<uint32_t>(__mv) - 5 * static_cast<uint32_t>(__div5(__mv));
      if (__mvMod5 == 0) {
        __vrIsTrailingZeros = __multipleOfPowerOf5(__mv, __q);
      } else if (__acceptBounds) {
        
        
        __vmIsTrailingZeros = __multipleOfPowerOf5(__mv - 1 - __mmShift, __q);
      } else {
        
        __vp -= __multipleOfPowerOf5(__mv + 2, __q);
      }
    }
  } else {
    
    const uint32_t __q = __log10Pow5(-__e2) - (-__e2 > 1);
    __e10 = static_cast<int32_t>(__q) + __e2;
    const int32_t __i = -__e2 - static_cast<int32_t>(__q);
    const int32_t __k = __pow5bits(__i) - __DOUBLE_POW5_BITCOUNT;
    const int32_t __j = static_cast<int32_t>(__q) - __k;
    __vr = __mulShiftAll(__m2, __DOUBLE_POW5_SPLIT[__i], __j, &__vp, &__vm, __mmShift);
    if (__q <= 1) {
      
      
      __vrIsTrailingZeros = true;
      if (__acceptBounds) {
        
        __vmIsTrailingZeros = __mmShift == 1;
      } else {
        
        --__vp;
      }
    } else if (__q < 63) { 
      
      
      __vrIsTrailingZeros = __multipleOfPowerOf2(__mv, __q - 1);
    }
  }

  
  int32_t __removed = 0;
  uint8_t __lastRemovedDigit = 0;
  uint64_t _Output;
  
  if (__vmIsTrailingZeros || __vrIsTrailingZeros) {
    
    for (;;) {
      const uint64_t __vpDiv10 = __div10(__vp);
      const uint64_t __vmDiv10 = __div10(__vm);
      if (__vpDiv10 <= __vmDiv10) {
        break;
      }
      const uint32_t __vmMod10 = static_cast<uint32_t>(__vm) - 10 * static_cast<uint32_t>(__vmDiv10);
      const uint64_t __vrDiv10 = __div10(__vr);
      const uint32_t __vrMod10 = static_cast<uint32_t>(__vr) - 10 * static_cast<uint32_t>(__vrDiv10);
      __vmIsTrailingZeros &= __vmMod10 == 0;
      __vrIsTrailingZeros &= __lastRemovedDigit == 0;
      __lastRemovedDigit = static_cast<uint8_t>(__vrMod10);
      __vr = __vrDiv10;
      __vp = __vpDiv10;
      __vm = __vmDiv10;
      ++__removed;
    }
    if (__vmIsTrailingZeros) {
      for (;;) {
        const uint64_t __vmDiv10 = __div10(__vm);
        const uint32_t __vmMod10 = static_cast<uint32_t>(__vm) - 10 * static_cast<uint32_t>(__vmDiv10);
        if (__vmMod10 != 0) {
          break;
        }
        const uint64_t __vpDiv10 = __div10(__vp);
        const uint64_t __vrDiv10 = __div10(__vr);
        const uint32_t __vrMod10 = static_cast<uint32_t>(__vr) - 10 * static_cast<uint32_t>(__vrDiv10);
        __vrIsTrailingZeros &= __lastRemovedDigit == 0;
        __lastRemovedDigit = static_cast<uint8_t>(__vrMod10);
        __vr = __vrDiv10;
        __vp = __vpDiv10;
        __vm = __vmDiv10;
        ++__removed;
      }
    }
    if (__vrIsTrailingZeros && __lastRemovedDigit == 5 && __vr % 2 == 0) {
      
      __lastRemovedDigit = 4;
    }
    
    _Output = __vr + ((__vr == __vm && (!__acceptBounds || !__vmIsTrailingZeros)) || __lastRemovedDigit >= 5);
  } else {
    
    bool __roundUp = false;
    const uint64_t __vpDiv100 = __div100(__vp);
    const uint64_t __vmDiv100 = __div100(__vm);
    if (__vpDiv100 > __vmDiv100) { 
      const uint64_t __vrDiv100 = __div100(__vr);
      const uint32_t __vrMod100 = static_cast<uint32_t>(__vr) - 100 * static_cast<uint32_t>(__vrDiv100);
      __roundUp = __vrMod100 >= 50;
      __vr = __vrDiv100;
      __vp = __vpDiv100;
      __vm = __vmDiv100;
      __removed += 2;
    }
    
    
    for (;;) {
      const uint64_t __vpDiv10 = __div10(__vp);
      const uint64_t __vmDiv10 = __div10(__vm);
      if (__vpDiv10 <= __vmDiv10) {
        break;
      }
      const uint64_t __vrDiv10 = __div10(__vr);
      const uint32_t __vrMod10 = static_cast<uint32_t>(__vr) - 10 * static_cast<uint32_t>(__vrDiv10);
      __roundUp = __vrMod10 >= 5;
      __vr = __vrDiv10;
      __vp = __vpDiv10;
      __vm = __vmDiv10;
      ++__removed;
    }
    
    _Output = __vr + (__vr == __vm || __roundUp);
  }
  const int32_t __exp = __e10 + __removed;

  __floating_decimal_64 __fd;
  __fd.__exponent = __exp;
  __fd.__mantissa = _Output;
  return __fd;
}

template <class _CharT>
[[nodiscard]] pair<_CharT*, errc> __to_chars(_CharT* const _First, _CharT* const _Last, const __floating_decimal_64 __v,
  chars_format _Fmt, const double __f) {
  
  uint64_t _Output = __v.__mantissa;
  int32_t _Ryu_exponent = __v.__exponent;
  const uint32_t __olength = __decimalLength17(_Output);
  int32_t _Scientific_exponent = _Ryu_exponent + static_cast<int32_t>(__olength) - 1;

  if (_Fmt == chars_format{}) {
    int32_t _Lower;
    int32_t _Upper;

    if (__olength == 1) {
      
      
      _Lower = -3;
      _Upper = 4;
    } else {
      
      
      _Lower = -static_cast<int32_t>(__olength + 3);
      _Upper = 5;
    }

    if (_Lower <= _Ryu_exponent && _Ryu_exponent <= _Upper) {
      _Fmt = chars_format::fixed;
    } else {
      _Fmt = chars_format::scientific;
    }
  } else if (_Fmt == chars_format::general) {
    
    
    if (-4 <= _Scientific_exponent && _Scientific_exponent < 6) {
      _Fmt = chars_format::fixed;
    } else {
      _Fmt = chars_format::scientific;
    }
  }

  if (_Fmt == chars_format::fixed) {
    

    const int32_t _Whole_digits = static_cast<int32_t>(__olength) + _Ryu_exponent;

    uint32_t _Total_fixed_length;
    if (_Ryu_exponent >= 0) { 
      _Total_fixed_length = static_cast<uint32_t>(_Whole_digits);
      if (_Output == 1) {
        
        
        static constexpr uint8_t _Adjustment[309] = {
          0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,1,1,0,1,0,1,1,1,0,1,1,1,0,0,0,0,0,
          1,1,0,0,1,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,0,0,1,1,1,1,0,1,0,1,0,1,1,0,0,0,0,1,1,1,
          1,0,0,0,0,0,0,0,1,1,0,1,1,0,0,1,0,1,0,1,0,1,1,0,0,0,0,0,1,1,1,0,0,1,1,1,1,1,0,1,0,1,1,0,1,
          1,0,0,0,0,0,0,0,0,0,1,1,1,0,0,1,0,0,1,0,0,1,1,1,1,0,0,1,1,0,1,1,0,1,1,0,1,0,0,0,1,0,0,0,1,
          0,1,0,1,0,1,1,1,0,0,0,0,0,0,1,1,1,1,0,0,1,0,1,1,1,0,0,0,1,0,1,1,1,1,1,1,0,1,0,1,1,0,0,0,1,
          1,1,0,1,1,0,0,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,1,1,0,0,1,1,1,0,0,0,1,0,1,0,0,0,0,0,1,1,0,
          0,1,0,1,1,1,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,1,1,0,1,0,0,0,0,0,1,1,0,1,0 };
        _Total_fixed_length -= _Adjustment[_Ryu_exponent];
        
      }
    } else if (_Whole_digits > 0) { 
      _Total_fixed_length = __olength + 1;
    } else { 
      _Total_fixed_length = static_cast<uint32_t>(2 - _Ryu_exponent);
    }

    if (_Last - _First < static_cast<ptrdiff_t>(_Total_fixed_length)) {
      return { _Last, errc::value_too_large };
    }

    _CharT* _Mid;
    if (_Ryu_exponent > 0) { 
      bool _Can_use_ryu;

      if (_Ryu_exponent > 22) { 
        _Can_use_ryu = false;
      } else {
        
        
        static constexpr uint64_t _Max_shifted_mantissa[23] = {
          9007199254740991u, 1801439850948198u, 360287970189639u, 72057594037927u, 14411518807585u,
          2882303761517u, 576460752303u, 115292150460u, 23058430092u, 4611686018u, 922337203u, 184467440u,
          36893488u, 7378697u, 1475739u, 295147u, 59029u, 11805u, 2361u, 472u, 94u, 18u, 3u };

        unsigned long _Trailing_zero_bits;


        const uint32_t _Low_mantissa = static_cast<uint32_t>(__v.__mantissa);
        if (_Low_mantissa != 0) {
          (void) _BitScanForward(&_Trailing_zero_bits, _Low_mantissa);
        } else {
          const uint32_t _High_mantissa = static_cast<uint32_t>(__v.__mantissa >> 32); 
          (void) _BitScanForward(&_Trailing_zero_bits, _High_mantissa);
          _Trailing_zero_bits += 32;
        }
#line 2063 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu.h"
        const uint64_t _Shifted_mantissa = __v.__mantissa >> _Trailing_zero_bits;
        _Can_use_ryu = _Shifted_mantissa <= _Max_shifted_mantissa[_Ryu_exponent];
      }

      if (!_Can_use_ryu) {
        
        
        return __d2fixed_buffered_n(_First, _Last, __f, 0);
      }

      
      _Mid = _First + __olength;
    } else { 
      
      _Mid = _First + _Total_fixed_length;
    }

    
    if ((_Output >> 32) != 0) {
      
      const uint64_t __q = __div1e8(_Output);
      uint32_t __output2 = static_cast<uint32_t>(_Output - 100000000 * __q);
      _Output = __q;

      const uint32_t __c = __output2 % 10000;
      __output2 /= 10000;
      const uint32_t __d = __output2 % 10000;
      const uint32_t __c0 = (__c % 100) << 1;
      const uint32_t __c1 = (__c / 100) << 1;
      const uint32_t __d0 = (__d % 100) << 1;
      const uint32_t __d1 = (__d / 100) << 1;

      :: memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __c0, 2 * sizeof(_CharT));
      :: memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __c1, 2 * sizeof(_CharT));
      :: memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __d0, 2 * sizeof(_CharT));
      :: memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __d1, 2 * sizeof(_CharT));
    }
    uint32_t __output2 = static_cast<uint32_t>(_Output);
    while (__output2 >= 10000) {


      const uint32_t __c = __output2 % 10000;
#line 2112 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu.h"
      __output2 /= 10000;
      const uint32_t __c0 = (__c % 100) << 1;
      const uint32_t __c1 = (__c / 100) << 1;
      :: memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __c0, 2 * sizeof(_CharT));
      :: memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __c1, 2 * sizeof(_CharT));
    }
    if (__output2 >= 100) {
      const uint32_t __c = (__output2 % 100) << 1;
      __output2 /= 100;
      :: memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __c, 2 * sizeof(_CharT));
    }
    if (__output2 >= 10) {
      const uint32_t __c = __output2 << 1;
      :: memcpy(_Mid -= 2, __DIGIT_TABLE<_CharT> + __c, 2 * sizeof(_CharT));
    } else {
      *--_Mid = static_cast<_CharT>(static_cast<_CharT>(is_same_v<_CharT, char> ? '0' : L'0') + __output2);
    }

    if (_Ryu_exponent > 0) { 
      
      ::std:: fill_n(_First + __olength, _Ryu_exponent, static_cast<_CharT>(is_same_v<_CharT, char> ? '0' : L'0'));
    } else if (_Ryu_exponent == 0) { 
      
    } else if (_Whole_digits > 0) { 
      
      :: memmove(_First, _First + 1, static_cast<size_t>(_Whole_digits) * sizeof(_CharT));
      _First[_Whole_digits] = static_cast<_CharT>(is_same_v<_CharT, char> ? '.' : L'.');
    } else { 
      
      _First[0] = static_cast<_CharT>(is_same_v<_CharT, char> ? '0' : L'0');
      _First[1] = static_cast<_CharT>(is_same_v<_CharT, char> ? '.' : L'.');
      ::std:: fill_n(_First + 2, -_Whole_digits, static_cast<_CharT>(is_same_v<_CharT, char> ? '0' : L'0'));
    }

    return { _First + _Total_fixed_length, errc{} };
  }

  const uint32_t _Total_scientific_length = __olength + (__olength > 1) 
    + (-100 < _Scientific_exponent && _Scientific_exponent < 100 ? 4 : 5); 
  if (_Last - _First < static_cast<ptrdiff_t>(_Total_scientific_length)) {
    return { _Last, errc::value_too_large };
  }
  _CharT* const __result = _First;

  
  uint32_t __i = 0;
  
  
  if ((_Output >> 32) != 0) {
    
    const uint64_t __q = __div1e8(_Output);
    uint32_t __output2 = static_cast<uint32_t>(_Output) - 100000000 * static_cast<uint32_t>(__q);
    _Output = __q;

    const uint32_t __c = __output2 % 10000;
    __output2 /= 10000;
    const uint32_t __d = __output2 % 10000;
    const uint32_t __c0 = (__c % 100) << 1;
    const uint32_t __c1 = (__c / 100) << 1;
    const uint32_t __d0 = (__d % 100) << 1;
    const uint32_t __d1 = (__d / 100) << 1;
    :: memcpy(__result + __olength - __i - 1, __DIGIT_TABLE<_CharT> + __c0, 2 * sizeof(_CharT));
    :: memcpy(__result + __olength - __i - 3, __DIGIT_TABLE<_CharT> + __c1, 2 * sizeof(_CharT));
    :: memcpy(__result + __olength - __i - 5, __DIGIT_TABLE<_CharT> + __d0, 2 * sizeof(_CharT));
    :: memcpy(__result + __olength - __i - 7, __DIGIT_TABLE<_CharT> + __d1, 2 * sizeof(_CharT));
    __i += 8;
  }
  uint32_t __output2 = static_cast<uint32_t>(_Output);
  while (__output2 >= 10000) {


    const uint32_t __c = __output2 % 10000;
#line 2188 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu.h"
    __output2 /= 10000;
    const uint32_t __c0 = (__c % 100) << 1;
    const uint32_t __c1 = (__c / 100) << 1;
    :: memcpy(__result + __olength - __i - 1, __DIGIT_TABLE<_CharT> + __c0, 2 * sizeof(_CharT));
    :: memcpy(__result + __olength - __i - 3, __DIGIT_TABLE<_CharT> + __c1, 2 * sizeof(_CharT));
    __i += 4;
  }
  if (__output2 >= 100) {
    const uint32_t __c = (__output2 % 100) << 1;
    __output2 /= 100;
    :: memcpy(__result + __olength - __i - 1, __DIGIT_TABLE<_CharT> + __c, 2 * sizeof(_CharT));
    __i += 2;
  }
  if (__output2 >= 10) {
    const uint32_t __c = __output2 << 1;
    
    __result[2] = __DIGIT_TABLE<_CharT>[__c + 1];
    __result[0] = __DIGIT_TABLE<_CharT>[__c];
  } else {
    __result[0] = static_cast<_CharT>(static_cast<_CharT>(is_same_v<_CharT, char> ? '0' : L'0') + __output2);
  }

  
  uint32_t __index;
  if (__olength > 1) {
    __result[1] = static_cast<_CharT>(is_same_v<_CharT, char> ? '.' : L'.');
    __index = __olength + 1;
  } else {
    __index = 1;
  }

  
  __result[__index++] = static_cast<_CharT>(is_same_v<_CharT, char> ? 'e' : L'e');
  if (_Scientific_exponent < 0) {
    __result[__index++] = static_cast<_CharT>(is_same_v<_CharT, char> ? '-' : L'-');
    _Scientific_exponent = -_Scientific_exponent;
  } else {
    __result[__index++] = static_cast<_CharT>(is_same_v<_CharT, char> ? '+' : L'+');
  }

  if (_Scientific_exponent >= 100) {
    const int32_t __c = _Scientific_exponent % 10;
    :: memcpy(__result + __index, __DIGIT_TABLE<_CharT> + 2 * (_Scientific_exponent / 10), 2 * sizeof(_CharT));
    __result[__index + 2] = static_cast<_CharT>(static_cast<_CharT>(is_same_v<_CharT, char> ? '0' : L'0') + __c);
    __index += 3;
  } else {
    :: memcpy(__result + __index, __DIGIT_TABLE<_CharT> + 2 * _Scientific_exponent, 2 * sizeof(_CharT));
    __index += 2;
  }

  return { _First + _Total_scientific_length, errc{} };
}

[[nodiscard]] inline bool __d2d_small_int(const uint64_t __ieeeMantissa, const uint32_t __ieeeExponent,
  __floating_decimal_64* const __v) {
  const uint64_t __m2 = (1ull << __DOUBLE_MANTISSA_BITS) | __ieeeMantissa;
  const int32_t __e2 = static_cast<int32_t>(__ieeeExponent) - __DOUBLE_BIAS - __DOUBLE_MANTISSA_BITS;

  if (__e2 > 0) {
    
    
    return false;
  }

  if (__e2 < -52) {
    
    return false;
  }

  
  const uint64_t __mask = (1ull << -__e2) - 1;
  const uint64_t __fraction = __m2 & __mask;
  if (__fraction != 0) {
    return false;
  }

  
  __v->__mantissa = __m2 >> -__e2;
  __v->__exponent = 0;
  return true;
}

template <class _CharT>
[[nodiscard]] pair<_CharT*, errc> __d2s_buffered_n(_CharT* const _First, _CharT* const _Last, const double __f,
  const chars_format _Fmt) {

  
  const uint64_t __bits = __double_to_bits(__f);

  
  if (__bits == 0) {
    if (_Fmt == chars_format::scientific) {
      if (_Last - _First < 5) {
        return { _Last, errc::value_too_large };
      }

      if constexpr (is_same_v<_CharT, char>) {
        :: memcpy(_First, "0e+00", 5);
      } else {
        :: memcpy(_First, L"0e+00", 5 * sizeof(wchar_t));
      }

      return { _First + 5, errc{} };
    }

    
    if (_First == _Last) {
      return { _Last, errc::value_too_large };
    }

    *_First = static_cast<_CharT>(is_same_v<_CharT, char> ? '0' : L'0');

    return { _First + 1, errc{} };
  }

  
  const uint64_t __ieeeMantissa = __bits & ((1ull << __DOUBLE_MANTISSA_BITS) - 1);
  const uint32_t __ieeeExponent = static_cast<uint32_t>(__bits >> __DOUBLE_MANTISSA_BITS);

  if (_Fmt == chars_format::fixed) {
    
    const int32_t _Exponent2 = static_cast<int32_t>(__ieeeExponent)
      - __DOUBLE_BIAS - __DOUBLE_MANTISSA_BITS; 

    
    if (_Exponent2 > 0) {
      return __d2fixed_buffered_n(_First, _Last, __f, 0);
    }
  }

  __floating_decimal_64 __v;
  const bool __isSmallInt = __d2d_small_int(__ieeeMantissa, __ieeeExponent, &__v);
  if (__isSmallInt) {
    
    
    for (;;) {
      const uint64_t __q = __div10(__v.__mantissa);
      const uint32_t __r = static_cast<uint32_t>(__v.__mantissa) - 10 * static_cast<uint32_t>(__q);
      if (__r != 0) {
        break;
      }
      __v.__mantissa = __q;
      ++__v.__exponent;
    }
  } else {
    __v = __d2d(__ieeeMantissa, __ieeeExponent);
  }

  return __to_chars(_First, _Last, __v, _Fmt, __f);
}


template <class _Floating>
[[nodiscard]] to_chars_result _Floating_to_chars_ryu(
    char* const _First, char* const _Last, const _Floating _Value, const chars_format _Fmt) noexcept {
    if constexpr (is_same_v<_Floating, float>) {
        return _Convert_to_chars_result(__f2s_buffered_n(_First, _Last, _Value, _Fmt));
    } else {
        return _Convert_to_chars_result(__d2s_buffered_n(_First, _Last, _Value, _Fmt));
    }
}

template <class _Floating>
[[nodiscard]] to_chars_result _Floating_to_chars_scientific_precision(
    char* const _First, char* const _Last, const _Floating _Value, int _Precision) noexcept {

    
    if (_Precision < 0) {
        _Precision = 6;
    } else if (_Precision < 1'000'000'000) {
        
    } else {
        
        
        return {_Last, errc::value_too_large};
    }

    return __d2exp_buffered_n(_First, _Last, _Value, static_cast<uint32_t>(_Precision));
}

template <class _Floating>
[[nodiscard]] to_chars_result _Floating_to_chars_fixed_precision(
    char* const _First, char* const _Last, const _Floating _Value, int _Precision) noexcept {

    
    if (_Precision < 0) {
        _Precision = 6;
    } else if (_Precision < 1'000'000'000) {
        
    } else {
        
        
        return {_Last, errc::value_too_large};
    }

    return _Convert_to_chars_result(__d2fixed_buffered_n(_First, _Last, _Value, static_cast<uint32_t>(_Precision)));
}

}


#pragma warning(pop)
#pragma pack(pop)

#line 2423 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu.h"
#line 2424 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xcharconv_ryu.h"
#line 20 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\charconv"


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
inline constexpr char _Charconv_digits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e',
    'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
static_assert(::std:: size(_Charconv_digits) == 36);

template <class _RawTy>
[[nodiscard]] to_chars_result _Integer_to_chars(
    char* _First, char* const _Last, const _RawTy _Raw_value, const int _Base) noexcept {
    _Adl_verify_range(_First, _Last);
    ;

    using _Unsigned = make_unsigned_t<_RawTy>;

    _Unsigned _Value = static_cast<_Unsigned>(_Raw_value);

    if constexpr (is_signed_v<_RawTy>) {
        if (_Raw_value < 0) {
            if (_First == _Last) {
                return {_Last, errc::value_too_large};
            }

            *_First++ = '-';

            _Value = static_cast<_Unsigned>(0 - _Value);
        }
    }

    constexpr size_t _Buff_size = sizeof(_Unsigned) * 8; 
    char _Buff[_Buff_size];
    char* const _Buff_end = _Buff + _Buff_size;
    char* _RNext          = _Buff_end;

    switch (_Base) {
    case 10:
        { 
            
            constexpr bool _Use_chunks = sizeof(_Unsigned) > sizeof(size_t);

            if constexpr (_Use_chunks) { 
                                         
                while (_Value > 0xFFFF'FFFFU) {
                    
                    unsigned long _Chunk = static_cast<unsigned long>(_Value % 1'000'000'000);
                    _Value               = static_cast<_Unsigned>(_Value / 1'000'000'000);

                    for (int _Idx = 0; _Idx != 9; ++_Idx) {
                        *--_RNext = static_cast<char>('0' + _Chunk % 10);
                        _Chunk /= 10;
                    }
                }
            }

            using _Truncated = conditional_t<_Use_chunks, unsigned long, _Unsigned>;

            _Truncated _Trunc = static_cast<_Truncated>(_Value);

            do {
                *--_RNext = static_cast<char>('0' + _Trunc % 10);
                _Trunc /= 10;
            } while (_Trunc != 0);
            break;
        }

    case 2:
        do {
            *--_RNext = static_cast<char>('0' + (_Value & 0b1));
            _Value >>= 1;
        } while (_Value != 0);
        break;

    case 4:
        do {
            *--_RNext = static_cast<char>('0' + (_Value & 0b11));
            _Value >>= 2;
        } while (_Value != 0);
        break;

    case 8:
        do {
            *--_RNext = static_cast<char>('0' + (_Value & 0b111));
            _Value >>= 3;
        } while (_Value != 0);
        break;

    case 16:
        do {
            *--_RNext = _Charconv_digits[_Value & 0b1111];
            _Value >>= 4;
        } while (_Value != 0);
        break;

    case 32:
        do {
            *--_RNext = _Charconv_digits[_Value & 0b11111];
            _Value >>= 5;
        } while (_Value != 0);
        break;

    case 3:
    case 5:
    case 6:
    case 7:
    case 9:
        do {
            *--_RNext = static_cast<char>('0' + _Value % _Base);
            _Value    = static_cast<_Unsigned>(_Value / _Base);
        } while (_Value != 0);
        break;

    default:
        do {
            *--_RNext = _Charconv_digits[_Value % _Base];
            _Value    = static_cast<_Unsigned>(_Value / _Base);
        } while (_Value != 0);
        break;
    }

    const ptrdiff_t _Digits_written = _Buff_end - _RNext;

    if (_Last - _First < _Digits_written) {
        return {_Last, errc::value_too_large};
    }

    :: memcpy(_First, _RNext, static_cast<size_t>(_Digits_written));

    return {_First + _Digits_written, errc{}};
}

inline to_chars_result to_chars(char* const _First, char* const _Last, const char _Value, const int _Base = 10) noexcept
 {
    return _Integer_to_chars(_First, _Last, _Value, _Base);
}
inline to_chars_result to_chars(
    char* const _First, char* const _Last, const signed char _Value, const int _Base = 10) noexcept  {
    return _Integer_to_chars(_First, _Last, _Value, _Base);
}
inline to_chars_result to_chars(char* const _First, char* const _Last, const unsigned char _Value,
    const int _Base = 10) noexcept  {
    return _Integer_to_chars(_First, _Last, _Value, _Base);
}
inline to_chars_result to_chars(
    char* const _First, char* const _Last, const short _Value, const int _Base = 10) noexcept  {
    return _Integer_to_chars(_First, _Last, _Value, _Base);
}
inline to_chars_result to_chars(char* const _First, char* const _Last, const unsigned short _Value,
    const int _Base = 10) noexcept  {
    return _Integer_to_chars(_First, _Last, _Value, _Base);
}
inline to_chars_result to_chars(char* const _First, char* const _Last, const int _Value, const int _Base = 10) noexcept
 {
    return _Integer_to_chars(_First, _Last, _Value, _Base);
}
inline to_chars_result to_chars(char* const _First, char* const _Last, const unsigned int _Value,
    const int _Base = 10) noexcept  {
    return _Integer_to_chars(_First, _Last, _Value, _Base);
}
inline to_chars_result to_chars(char* const _First, char* const _Last, const long _Value, const int _Base = 10) noexcept
 {
    return _Integer_to_chars(_First, _Last, _Value, _Base);
}
inline to_chars_result to_chars(char* const _First, char* const _Last, const unsigned long _Value,
    const int _Base = 10) noexcept  {
    return _Integer_to_chars(_First, _Last, _Value, _Base);
}
inline to_chars_result to_chars(
    char* const _First, char* const _Last, const long long _Value, const int _Base = 10) noexcept  {
    return _Integer_to_chars(_First, _Last, _Value, _Base);
}
inline to_chars_result to_chars(char* const _First, char* const _Last, const unsigned long long _Value,
    const int _Base = 10) noexcept  {
    return _Integer_to_chars(_First, _Last, _Value, _Base);
}

to_chars_result to_chars(char* _First, char* _Last, bool _Value, int _Base = 10) = delete;


struct from_chars_result {
    const char* ptr;
    errc ec;

    [[nodiscard]] friend bool operator==(const from_chars_result&, const from_chars_result&) = default;
#line 213 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\charconv"
};

[[nodiscard]] inline unsigned char _Digit_from_char(const char _Ch) noexcept {
    
    static constexpr unsigned char _Digit_from_byte[] = {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};
    static_assert(::std:: size(_Digit_from_byte) == 256);

    return _Digit_from_byte[static_cast<unsigned char>(_Ch)];
}

template <class _RawTy>
[[nodiscard]] from_chars_result _Integer_from_chars(
    const char* const _First, const char* const _Last, _RawTy& _Raw_value, const int _Base) noexcept {
    _Adl_verify_range(_First, _Last);
    ;

    bool _Minus_sign = false;

    const char* _Next = _First;

    if constexpr (is_signed_v<_RawTy>) {
        if (_Next != _Last && *_Next == '-') {
            _Minus_sign = true;
            ++_Next;
        }
    }

    using _Unsigned = make_unsigned_t<_RawTy>;

    constexpr _Unsigned _Uint_max    = static_cast<_Unsigned>(-1);
    constexpr _Unsigned _Int_max     = static_cast<_Unsigned>(_Uint_max >> 1);
    constexpr _Unsigned _Abs_int_min = static_cast<_Unsigned>(_Int_max + 1);

    _Unsigned _Risky_val;
    _Unsigned _Max_digit;

    if constexpr (is_signed_v<_RawTy>) {
        if (_Minus_sign) {
            _Risky_val = static_cast<_Unsigned>(_Abs_int_min / _Base);
            _Max_digit = static_cast<_Unsigned>(_Abs_int_min % _Base);
        } else {
            _Risky_val = static_cast<_Unsigned>(_Int_max / _Base);
            _Max_digit = static_cast<_Unsigned>(_Int_max % _Base);
        }
    } else {
        _Risky_val = static_cast<_Unsigned>(_Uint_max / _Base);
        _Max_digit = static_cast<_Unsigned>(_Uint_max % _Base);
    }

    _Unsigned _Value = 0;

    bool _Overflowed = false;

    for (; _Next != _Last; ++_Next) {
        const unsigned char _Digit = _Digit_from_char(*_Next);

        if (_Digit >= _Base) {
            break;
        }

        if (_Value < _Risky_val 
            || (_Value == _Risky_val && _Digit <= _Max_digit)) { 
            _Value = static_cast<_Unsigned>(_Value * _Base + _Digit);
        } else { 
            _Overflowed = true; 
        }
    }

    if (_Next - _First == static_cast<ptrdiff_t>(_Minus_sign)) {
        return {_First, errc::invalid_argument};
    }

    if (_Overflowed) {
        return {_Next, errc::result_out_of_range};
    }

    if constexpr (is_signed_v<_RawTy>) {
        if (_Minus_sign) {
            _Value = static_cast<_Unsigned>(0 - _Value);
        }
    }

    _Raw_value = static_cast<_RawTy>(_Value); 

    return {_Next, errc{}};
}

inline from_chars_result from_chars(
    const char* const _First, const char* const _Last, char& _Value, const int _Base = 10) noexcept  {
    return _Integer_from_chars(_First, _Last, _Value, _Base);
}
inline from_chars_result from_chars(const char* const _First, const char* const _Last, signed char& _Value,
    const int _Base = 10) noexcept  {
    return _Integer_from_chars(_First, _Last, _Value, _Base);
}
inline from_chars_result from_chars(const char* const _First, const char* const _Last, unsigned char& _Value,
    const int _Base = 10) noexcept  {
    return _Integer_from_chars(_First, _Last, _Value, _Base);
}
inline from_chars_result from_chars(const char* const _First, const char* const _Last, short& _Value,
    const int _Base = 10) noexcept  {
    return _Integer_from_chars(_First, _Last, _Value, _Base);
}
inline from_chars_result from_chars(const char* const _First, const char* const _Last, unsigned short& _Value,
    const int _Base = 10) noexcept  {
    return _Integer_from_chars(_First, _Last, _Value, _Base);
}
inline from_chars_result from_chars(
    const char* const _First, const char* const _Last, int& _Value, const int _Base = 10) noexcept  {
    return _Integer_from_chars(_First, _Last, _Value, _Base);
}
inline from_chars_result from_chars(const char* const _First, const char* const _Last, unsigned int& _Value,
    const int _Base = 10) noexcept  {
    return _Integer_from_chars(_First, _Last, _Value, _Base);
}
inline from_chars_result from_chars(
    const char* const _First, const char* const _Last, long& _Value, const int _Base = 10) noexcept  {
    return _Integer_from_chars(_First, _Last, _Value, _Base);
}
inline from_chars_result from_chars(const char* const _First, const char* const _Last, unsigned long& _Value,
    const int _Base = 10) noexcept  {
    return _Integer_from_chars(_First, _Last, _Value, _Base);
}
inline from_chars_result from_chars(const char* const _First, const char* const _Last, long long& _Value,
    const int _Base = 10) noexcept  {
    return _Integer_from_chars(_First, _Last, _Value, _Base);
}
inline from_chars_result from_chars(const char* const _First, const char* const _Last, unsigned long long& _Value,
    const int _Base = 10) noexcept  {
    return _Integer_from_chars(_First, _Last, _Value, _Base);
}


struct _Big_integer_flt {
    _Big_integer_flt() noexcept : _Myused(0) {}

    _Big_integer_flt(const _Big_integer_flt& _Other) noexcept : _Myused(_Other._Myused) {
        :: memcpy(_Mydata, _Other._Mydata, _Other._Myused * sizeof(uint32_t));
    }

    _Big_integer_flt& operator=(const _Big_integer_flt& _Other) noexcept {
        _Myused = _Other._Myused;
        :: memmove(_Mydata, _Other._Mydata, _Other._Myused * sizeof(uint32_t));
        return *this;
    }

    [[nodiscard]] bool operator<(const _Big_integer_flt& _Rhs) const noexcept {
        if (_Myused != _Rhs._Myused) {
            return _Myused < _Rhs._Myused;
        }

        for (uint32_t _Ix = _Myused - 1; _Ix != static_cast<uint32_t>(-1); --_Ix) {
            if (_Mydata[_Ix] != _Rhs._Mydata[_Ix]) {
                return _Mydata[_Ix] < _Rhs._Mydata[_Ix];
            }
        }

        return false;
    }

    static constexpr uint32_t _Maximum_bits = 1074 
                                            + 2552 
                                            + 54; 

    static constexpr uint32_t _Element_bits = 32;

    static constexpr uint32_t _Element_count = (_Maximum_bits + _Element_bits - 1) / _Element_bits;

    uint32_t _Myused; 
    uint32_t _Mydata[_Element_count]; 
};

[[nodiscard]] inline _Big_integer_flt _Make_big_integer_flt_one() noexcept {
    _Big_integer_flt _Xval{};
    _Xval._Mydata[0] = 1;
    _Xval._Myused    = 1;
    return _Xval;
}

[[nodiscard]] inline uint32_t _Bit_scan_reverse(const _Big_integer_flt& _Xval) noexcept {
    if (_Xval._Myused == 0) {
        return 0;
    }

    const uint32_t _Bx = _Xval._Myused - 1;

    ; 

    unsigned long _Index; 

    _BitScanReverse(&_Index, _Xval._Mydata[_Bx]); 

    return _Index + 1 + _Bx * _Big_integer_flt::_Element_bits;
}


[[nodiscard]] inline bool _Shift_left(_Big_integer_flt& _Xval, const uint32_t _Nx) noexcept {
    if (_Xval._Myused == 0) {
        return true;
    }

    const uint32_t _Unit_shift = _Nx / _Big_integer_flt::_Element_bits;
    const uint32_t _Bit_shift  = _Nx % _Big_integer_flt::_Element_bits;

    if (_Xval._Myused + _Unit_shift > _Big_integer_flt::_Element_count) {
        
        _Xval._Myused = 0;
        return false;
    }

    if (_Bit_shift == 0) {
        :: memmove(_Xval._Mydata + _Unit_shift, _Xval._Mydata, _Xval._Myused * sizeof(uint32_t));
        _Xval._Myused += _Unit_shift;
    } else {
        const bool _Bit_shifts_into_next_unit =
            _Bit_shift > (_Big_integer_flt::_Element_bits - _Bit_scan_reverse(_Xval._Mydata[_Xval._Myused - 1]));

        const uint32_t _New_used = _Xval._Myused + _Unit_shift + static_cast<uint32_t>(_Bit_shifts_into_next_unit);

        if (_New_used > _Big_integer_flt::_Element_count) {
            
            _Xval._Myused = 0;
            return false;
        }

        const uint32_t _Msb_bits = _Bit_shift;
        const uint32_t _Lsb_bits = _Big_integer_flt::_Element_bits - _Msb_bits;

        const uint32_t _Lsb_mask = (1UL << _Lsb_bits) - 1UL;
        const uint32_t _Msb_mask = ~_Lsb_mask;

        
        for (uint32_t _Dest_index = _New_used - 1; _Dest_index != _Unit_shift - 1; --_Dest_index) {
            

            const uint32_t _Upper_source_index = _Dest_index - _Unit_shift;

            
            const uint32_t _Lower_source_index = _Dest_index - _Unit_shift - 1;

            const uint32_t _Upper_source = _Upper_source_index < _Xval._Myused ? _Xval._Mydata[_Upper_source_index] : 0;
            const uint32_t _Lower_source = _Lower_source_index < _Xval._Myused ? _Xval._Mydata[_Lower_source_index] : 0;

            const uint32_t _Shifted_upper_source = (_Upper_source & _Lsb_mask) << _Msb_bits;
            const uint32_t _Shifted_lower_source = (_Lower_source & _Msb_mask) >> _Lsb_bits;

            const uint32_t _Combined_shifted_source = _Shifted_upper_source | _Shifted_lower_source;

            _Xval._Mydata[_Dest_index] = _Combined_shifted_source;
        }

        _Xval._Myused = _New_used;
    }

    :: memset(_Xval._Mydata, 0, _Unit_shift * sizeof(uint32_t));

    return true;
}


[[nodiscard]] inline bool _Add(_Big_integer_flt& _Xval, const uint32_t _Value) noexcept {
    if (_Value == 0) {
        return true;
    }

    uint32_t _Carry = _Value;
    for (uint32_t _Ix = 0; _Ix != _Xval._Myused; ++_Ix) {
        const uint64_t _Result = static_cast<uint64_t>(_Xval._Mydata[_Ix]) + _Carry;
        _Xval._Mydata[_Ix]     = static_cast<uint32_t>(_Result);
        _Carry                 = static_cast<uint32_t>(_Result >> 32);
    }

    if (_Carry != 0) {
        if (_Xval._Myused < _Big_integer_flt::_Element_count) {
            _Xval._Mydata[_Xval._Myused] = _Carry;
            ++_Xval._Myused;
        } else {
            _Xval._Myused = 0;
            return false;
        }
    }

    return true;
}

[[nodiscard]] inline uint32_t _Add_carry(uint32_t& _Ux1, const uint32_t _Ux2, const uint32_t _U_carry) noexcept {
    const uint64_t _Uu = static_cast<uint64_t>(_Ux1) + _Ux2 + _U_carry;
    _Ux1               = static_cast<uint32_t>(_Uu);
    return static_cast<uint32_t>(_Uu >> 32);
}

[[nodiscard]] inline uint32_t _Add_multiply_carry(
    uint32_t& _U_add, const uint32_t _U_mul_1, const uint32_t _U_mul_2, const uint32_t _U_carry) noexcept {
    const uint64_t _Uu_res = static_cast<uint64_t>(_U_mul_1) * _U_mul_2 + _U_add + _U_carry;
    _U_add                 = static_cast<uint32_t>(_Uu_res);
    return static_cast<uint32_t>(_Uu_res >> 32);
}

[[nodiscard]] inline uint32_t _Multiply_core(
    uint32_t* const _Multiplicand, const uint32_t _Multiplicand_count, const uint32_t _Multiplier) noexcept {
    uint32_t _Carry = 0;
    for (uint32_t _Ix = 0; _Ix != _Multiplicand_count; ++_Ix) {
        const uint64_t _Result = static_cast<uint64_t>(_Multiplicand[_Ix]) * _Multiplier + _Carry;
        _Multiplicand[_Ix]     = static_cast<uint32_t>(_Result);
        _Carry                 = static_cast<uint32_t>(_Result >> 32);
    }

    return _Carry;
}


[[nodiscard]] inline bool _Multiply(_Big_integer_flt& _Multiplicand, const uint32_t _Multiplier) noexcept {
    if (_Multiplier == 0) {
        _Multiplicand._Myused = 0;
        return true;
    }

    if (_Multiplier == 1) {
        return true;
    }

    if (_Multiplicand._Myused == 0) {
        return true;
    }

    const uint32_t _Carry = _Multiply_core(_Multiplicand._Mydata, _Multiplicand._Myused, _Multiplier);
    if (_Carry != 0) {
        if (_Multiplicand._Myused < _Big_integer_flt::_Element_count) {
            _Multiplicand._Mydata[_Multiplicand._Myused] = _Carry;
            ++_Multiplicand._Myused;
        } else {
            _Multiplicand._Myused = 0;
            return false;
        }
    }

    return true;
}


[[nodiscard]] inline bool _Multiply(_Big_integer_flt& _Multiplicand, const _Big_integer_flt& _Multiplier) noexcept {
    if (_Multiplicand._Myused == 0) {
        return true;
    }

    if (_Multiplier._Myused == 0) {
        _Multiplicand._Myused = 0;
        return true;
    }

    if (_Multiplier._Myused == 1) {
        return _Multiply(_Multiplicand, _Multiplier._Mydata[0]); 
    }

    if (_Multiplicand._Myused == 1) {
        const uint32_t _Small_multiplier = _Multiplicand._Mydata[0];
        _Multiplicand                    = _Multiplier;
        return _Multiply(_Multiplicand, _Small_multiplier); 
    }

    
    const bool _Multiplier_is_shorter = _Multiplier._Myused < _Multiplicand._Myused;
    const uint32_t* const _Rgu1       = _Multiplier_is_shorter ? _Multiplier._Mydata : _Multiplicand._Mydata;
    const uint32_t* const _Rgu2       = _Multiplier_is_shorter ? _Multiplicand._Mydata : _Multiplier._Mydata;

    const uint32_t _Cu1 = _Multiplier_is_shorter ? _Multiplier._Myused : _Multiplicand._Myused;
    const uint32_t _Cu2 = _Multiplier_is_shorter ? _Multiplicand._Myused : _Multiplier._Myused;

    _Big_integer_flt _Result{};
    for (uint32_t _Iu1 = 0; _Iu1 != _Cu1; ++_Iu1) {
        const uint32_t _U_cur = _Rgu1[_Iu1];
        if (_U_cur == 0) {
            if (_Iu1 == _Result._Myused) {
                _Result._Mydata[_Iu1] = 0;
                _Result._Myused       = _Iu1 + 1;
            }

            continue;
        }

        uint32_t _U_carry = 0;
        uint32_t _Iu_res  = _Iu1;
        for (uint32_t _Iu2 = 0; _Iu2 != _Cu2 && _Iu_res != _Big_integer_flt::_Element_count; ++_Iu2, ++_Iu_res) {
            if (_Iu_res == _Result._Myused) {
                _Result._Mydata[_Iu_res] = 0;
                _Result._Myused          = _Iu_res + 1;
            }

            _U_carry = _Add_multiply_carry(_Result._Mydata[_Iu_res], _U_cur, _Rgu2[_Iu2], _U_carry);
        }

        while (_U_carry != 0 && _Iu_res != _Big_integer_flt::_Element_count) {
            if (_Iu_res == _Result._Myused) {
                _Result._Mydata[_Iu_res] = 0;
                _Result._Myused          = _Iu_res + 1;
            }

            _U_carry = _Add_carry(_Result._Mydata[_Iu_res++], 0, _U_carry);
        }

        if (_Iu_res == _Big_integer_flt::_Element_count) {
            _Multiplicand._Myused = 0;
            return false;
        }
    }

    
    _Multiplicand = _Result;
    return true;
}


[[nodiscard]] inline bool _Multiply_by_power_of_ten(_Big_integer_flt& _Xval, const uint32_t _Power) noexcept {
    
    
    static constexpr uint32_t _Large_power_data[] = {0x540be400, 0x00000002, 0x63100000, 0x6bc75e2d, 0x00000005,
        0x40000000, 0x4674edea, 0x9f2c9cd0, 0x0000000c, 0xb9f56100, 0x5ca4bfab, 0x6329f1c3, 0x0000001d, 0xb5640000,
        0xc40534fd, 0x926687d2, 0x6c3b15f9, 0x00000044, 0x10000000, 0x946590d9, 0xd762422c, 0x9a224501, 0x4f272617,
        0x0000009f, 0x07950240, 0x245689c1, 0xc5faa71c, 0x73c86d67, 0xebad6ddc, 0x00000172, 0xcec10000, 0x63a22764,
        0xefa418ca, 0xcdd17b25, 0x6bdfef70, 0x9dea3e1f, 0x0000035f, 0xe4000000, 0xcdc3fe6e, 0x66bc0c6a, 0x2e391f32,
        0x5a450203, 0x71d2f825, 0xc3c24a56, 0x000007da, 0xa82e8f10, 0xaab24308, 0x8e211a7c, 0xf38ace40, 0x84c4ce0b,
        0x7ceb0b27, 0xad2594c3, 0x00001249, 0xdd1a4000, 0xcc9f54da, 0xdc5961bf, 0xc75cabab, 0xf505440c, 0xd1bc1667,
        0xfbb7af52, 0x608f8d29, 0x00002a94, 0x21000000, 0x17bb8a0c, 0x56af8ea4, 0x06479fa9, 0x5d4bb236, 0x80dc5fe0,
        0xf0feaa0a, 0xa88ed940, 0x6b1a80d0, 0x00006323, 0x324c3864, 0x8357c796, 0xe44a42d5, 0xd9a92261, 0xbd3c103d,
        0x91e5f372, 0xc0591574, 0xec1da60d, 0x102ad96c, 0x0000e6d3, 0x1e851000, 0x6e4f615b, 0x187b2a69, 0x0450e21c,
        0x2fdd342b, 0x635027ee, 0xa6c97199, 0x8e4ae916, 0x17082e28, 0x1a496e6f, 0x0002196e, 0x32400000, 0x04ad4026,
        0xf91e7250, 0x2994d1d5, 0x665bcdbb, 0xa23b2e96, 0x65fa7ddb, 0x77de53ac, 0xb020a29b, 0xc6bff953, 0x4b9425ab,
        0x0004e34d, 0xfbc32d81, 0x5222d0f4, 0xb70f2850, 0x5713f2f3, 0xdc421413, 0xd6395d7d, 0xf8591999, 0x0092381c,
        0x86b314d6, 0x7aa577b9, 0x12b7fe61, 0x000b616a, 0x1d11e400, 0x56c3678d, 0x3a941f20, 0x9b09368b, 0xbd706908,
        0x207665be, 0x9b26c4eb, 0x1567e89d, 0x9d15096e, 0x7132f22b, 0xbe485113, 0x45e5a2ce, 0x001a7f52, 0xbb100000,
        0x02f79478, 0x8c1b74c0, 0xb0f05d00, 0xa9dbc675, 0xe2d9b914, 0x650f72df, 0x77284b4c, 0x6df6e016, 0x514391c2,
        0x2795c9cf, 0xd6e2ab55, 0x9ca8e627, 0x003db1a6, 0x40000000, 0xf4ecd04a, 0x7f2388f0, 0x580a6dc5, 0x43bf046f,
        0xf82d5dc3, 0xee110848, 0xfaa0591c, 0xcdf4f028, 0x192ea53f, 0xbcd671a0, 0x7d694487, 0x10f96e01, 0x791a569d,
        0x008fa475, 0xb9b2e100, 0x8288753c, 0xcd3f1693, 0x89b43a6b, 0x089e87de, 0x684d4546, 0xfddba60c, 0xdf249391,
        0x3068ec13, 0x99b44427, 0xb68141ee, 0x5802cac3, 0xd96851f1, 0x7d7625a2, 0x014e718d, 0xfb640000, 0xf25a83e6,
        0x9457ad0f, 0x0080b511, 0x2029b566, 0xd7c5d2cf, 0xa53f6d7d, 0xcdb74d1c, 0xda9d70de, 0xb716413d, 0x71d0ca4e,
        0xd7e41398, 0x4f403a90, 0xf9ab3fe2, 0x264d776f, 0x030aafe6, 0x10000000, 0x09ab5531, 0xa60c58d2, 0x566126cb,
        0x6a1c8387, 0x7587f4c1, 0x2c44e876, 0x41a047cf, 0xc908059e, 0xa0ba063e, 0xe7cfc8e8, 0xe1fac055, 0xef0144b2,
        0x24207eb0, 0xd1722573, 0xe4b8f981, 0x071505ae, 0x7a3b6240, 0xcea45d4f, 0x4fe24133, 0x210f6d6d, 0xe55633f2,
        0x25c11356, 0x28ebd797, 0xd396eb84, 0x1e493b77, 0x471f2dae, 0x96ad3820, 0x8afaced1, 0x4edecddb, 0x5568c086,
        0xb2695da1, 0x24123c89, 0x107d4571, 0x1c410000, 0x6e174a27, 0xec62ae57, 0xef2289aa, 0xb6a2fbdd, 0x17e1efe4,
        0x3366bdf2, 0x37b48880, 0xbfb82c3e, 0x19acde91, 0xd4f46408, 0x35ff6a4e, 0x67566a0e, 0x40dbb914, 0x782a3bca,
        0x6b329b68, 0xf5afc5d9, 0x266469bc, 0xe4000000, 0xfb805ff4, 0xed55d1af, 0x9b4a20a8, 0xab9757f8, 0x01aefe0a,
        0x4a2ca67b, 0x1ebf9569, 0xc7c41c29, 0xd8d5d2aa, 0xd136c776, 0x93da550c, 0x9ac79d90, 0x254bcba8, 0x0df07618,
        0xf7a88809, 0x3a1f1074, 0xe54811fc, 0x59638ead, 0x97cbe710, 0x26d769e8, 0xb4e4723e, 0x5b90aa86, 0x9c333922,
        0x4b7a0775, 0x2d47e991, 0x9a6ef977, 0x160b40e7, 0x0c92f8c4, 0xf25ff010, 0x25c36c11, 0xc9f98b42, 0x730b919d,
        0x05ff7caf, 0xb0432d85, 0x2d2b7569, 0xa657842c, 0xd01fef10, 0xc77a4000, 0xe8b862e5, 0x10d8886a, 0xc8cd98e5,
        0x108955c5, 0xd059b655, 0x58fbbed4, 0x03b88231, 0x034c4519, 0x194dc939, 0x1fc500ac, 0x794cc0e2, 0x3bc980a1,
        0xe9b12dd1, 0x5e6d22f8, 0x7b38899a, 0xce7919d8, 0x78c67672, 0x79e5b99f, 0xe494034e, 0x00000001, 0xa1000000,
        0x6c5cd4e9, 0x9be47d6f, 0xf93bd9e7, 0x77626fa1, 0xc68b3451, 0xde2b59e8, 0xcf3cde58, 0x2246ff58, 0xa8577c15,
        0x26e77559, 0x17776753, 0xebe6b763, 0xe3fd0a5f, 0x33e83969, 0xa805a035, 0xf631b987, 0x211f0f43, 0xd85a43db,
        0xab1bf596, 0x683f19a2, 0x00000004, 0xbe7dfe64, 0x4bc9042f, 0xe1f5edb0, 0x8fa14eda, 0xe409db73, 0x674fee9c,
        0xa9159f0d, 0xf6b5b5d6, 0x7338960e, 0xeb49c291, 0x5f2b97cc, 0x0f383f95, 0x2091b3f6, 0xd1783714, 0xc1d142df,
        0x153e22de, 0x8aafdf57, 0x77f5e55f, 0xa3e7ca8b, 0x032f525b, 0x42e74f3d, 0x0000000a, 0xf4dd1000, 0x5d450952,
        0xaeb442e1, 0xa3b3342e, 0x3fcda36f, 0xb4287a6e, 0x4bc177f7, 0x67d2c8d0, 0xaea8f8e0, 0xadc93b67, 0x6cc856b3,
        0x959d9d0b, 0x5b48c100, 0x4abe8a3d, 0x52d936f4, 0x71dbe84d, 0xf91c21c5, 0x4a458109, 0xd7aad86a, 0x08e14c7c,
        0x759ba59c, 0xe43c8800, 0x00000017, 0x92400000, 0x04f110d4, 0x186472be, 0x8736c10c, 0x1478abfb, 0xfc51af29,
        0x25eb9739, 0x4c2b3015, 0xa1030e0b, 0x28fe3c3b, 0x7788fcba, 0xb89e4358, 0x733de4a4, 0x7c46f2c2, 0x8f746298,
        0xdb19210f, 0x2ea3b6ae, 0xaa5014b2, 0xea39ab8d, 0x97963442, 0x01dfdfa9, 0xd2f3d3fe, 0xa0790280, 0x00000037,
        0x509c9b01, 0xc7dcadf1, 0x383dad2c, 0x73c64d37, 0xea6d67d0, 0x519ba806, 0xc403f2f8, 0xa052e1a2, 0xd710233a,
        0x448573a9, 0xcf12d9ba, 0x70871803, 0x52dc3a9b, 0xe5b252e8, 0x0717fb4e, 0xbe4da62f, 0x0aabd7e1, 0x8c62ed4f,
        0xceb9ec7b, 0xd4664021, 0xa1158300, 0xcce375e6, 0x842f29f2, 0x00000081, 0x7717e400, 0xd3f5fb64, 0xa0763d71,
        0x7d142fe9, 0x33f44c66, 0xf3b8f12e, 0x130f0d8e, 0x734c9469, 0x60260fa8, 0x3c011340, 0xcc71880a, 0x37a52d21,
        0x8adac9ef, 0x42bb31b4, 0xd6f94c41, 0xc88b056c, 0xe20501b8, 0x5297ed7c, 0x62c361c4, 0x87dad8aa, 0xb833eade,
        0x94f06861, 0x13cc9abd, 0x8dc1d56a, 0x0000012d, 0x13100000, 0xc67a36e8, 0xf416299e, 0xf3493f0a, 0x77a5a6cf,
        0xa4be23a3, 0xcca25b82, 0x3510722f, 0xbe9d447f, 0xa8c213b8, 0xc94c324e, 0xbc9e33ad, 0x76acfeba, 0x2e4c2132,
        0x3e13cd32, 0x70fe91b4, 0xbb5cd936, 0x42149785, 0x46cc1afd, 0xe638ddf8, 0x690787d2, 0x1a02d117, 0x3eb5f1fe,
        0xc3b9abae, 0x1c08ee6f, 0x000002be, 0x40000000, 0x8140c2aa, 0x2cf877d9, 0x71e1d73d, 0xd5e72f98, 0x72516309,
        0xafa819dd, 0xd62a5a46, 0x2a02dcce, 0xce46ddfe, 0x2713248d, 0xb723d2ad, 0xc404bb19, 0xb706cc2b, 0x47b1ebca,
        0x9d094bdc, 0xc5dc02ca, 0x31e6518e, 0x8ec35680, 0x342f58a8, 0x8b041e42, 0xfebfe514, 0x05fffc13, 0x6763790f,
        0x66d536fd, 0xb9e15076, 0x00000662, 0x67b06100, 0xd2010a1a, 0xd005e1c0, 0xdb12733b, 0xa39f2e3f, 0x61b29de2,
        0x2a63dce2, 0x942604bc, 0x6170d59b, 0xc2e32596, 0x140b75b9, 0x1f1d2c21, 0xb8136a60, 0x89d23ba2, 0x60f17d73,
        0xc6cad7df, 0x0669df2b, 0x24b88737, 0x669306ed, 0x19496eeb, 0x938ddb6f, 0x5e748275, 0xc56e9a36, 0x3690b731,
        0xc82842c5, 0x24ae798e, 0x00000ede, 0x41640000, 0xd5889ac1, 0xd9432c99, 0xa280e71a, 0x6bf63d2e, 0x8249793d,
        0x79e7a943, 0x22fde64a, 0xe0d6709a, 0x05cacfef, 0xbd8da4d7, 0xe364006c, 0xa54edcb3, 0xa1a8086e, 0x748f459e,
        0xfc8e54c8, 0xcc74c657, 0x42b8c3d4, 0x57d9636e, 0x35b55bcc, 0x6c13fee9, 0x1ac45161, 0xb595badb, 0xa1f14e9d,
        0xdcf9e750, 0x07637f71, 0xde2f9f2b, 0x0000229d, 0x10000000, 0x3c5ebd89, 0xe3773756, 0x3dcba338, 0x81d29e4f,
        0xa4f79e2c, 0xc3f9c774, 0x6a1ce797, 0xac5fe438, 0x07f38b9c, 0xd588ecfa, 0x3e5ac1ac, 0x85afccce, 0x9d1f3f70,
        0xe82d6dd3, 0x177d180c, 0x5e69946f, 0x648e2ce1, 0x95a13948, 0x340fe011, 0xb4173c58, 0x2748f694, 0x7c2657bd,
        0x758bda2e, 0x3b8090a0, 0x2ddbb613, 0x6dcf4890, 0x24e4047e, 0x00005099};

    struct _Unpack_index {
        uint16_t _Offset; 
        uint8_t _Zeroes; 
        uint8_t _Size; 
    };

    static constexpr _Unpack_index _Large_power_indices[] = {{0, 0, 2}, {2, 0, 3}, {5, 0, 4}, {9, 1, 4}, {13, 1, 5},
        {18, 1, 6}, {24, 2, 6}, {30, 2, 7}, {37, 2, 8}, {45, 3, 8}, {53, 3, 9}, {62, 3, 10}, {72, 4, 10}, {82, 4, 11},
        {93, 4, 12}, {105, 5, 12}, {117, 5, 13}, {130, 5, 14}, {144, 5, 15}, {159, 6, 15}, {174, 6, 16}, {190, 6, 17},
        {207, 7, 17}, {224, 7, 18}, {242, 7, 19}, {261, 8, 19}, {280, 8, 21}, {301, 8, 22}, {323, 9, 22}, {345, 9, 23},
        {368, 9, 24}, {392, 10, 24}, {416, 10, 25}, {441, 10, 26}, {467, 10, 27}, {494, 11, 27}, {521, 11, 28},
        {549, 11, 29}};

    for (uint32_t _Large_power = _Power / 10; _Large_power != 0;) {
        const uint32_t _Current_power =
            (::std:: min)(_Large_power, static_cast<uint32_t>(::std:: size(_Large_power_indices)));

        const _Unpack_index& _Index = _Large_power_indices[_Current_power - 1];
        _Big_integer_flt _Multiplier{};
        _Multiplier._Myused = static_cast<uint32_t>(_Index._Size + _Index._Zeroes);

        const uint32_t* const _Source = _Large_power_data + _Index._Offset;

        :: memset(_Multiplier._Mydata, 0, _Index._Zeroes * sizeof(uint32_t));
        :: memcpy(_Multiplier._Mydata + _Index._Zeroes, _Source, _Index._Size * sizeof(uint32_t));

        if (!_Multiply(_Xval, _Multiplier)) { 
            return false;
        }

        _Large_power -= _Current_power;
    }

    static constexpr uint32_t _Small_powers_of_ten[9] = {
        10, 100, 1'000, 10'000, 100'000, 1'000'000, 10'000'000, 100'000'000, 1'000'000'000};

    const uint32_t _Small_power = _Power % 10;

    if (_Small_power == 0) {
        return true;
    }

    return _Multiply(_Xval, _Small_powers_of_ten[_Small_power - 1]); 
}


#line 848 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\charconv"


[[nodiscard]] inline uint32_t _Count_sequential_high_zeroes(const uint32_t _Ux) noexcept {
    unsigned long _Index; 
    return _BitScanReverse(&_Index, _Ux) ? 31 - _Index : 32;
}


[[nodiscard]] inline uint64_t _Divide(_Big_integer_flt& _Numerator, const _Big_integer_flt& _Denominator) noexcept {
    
    if (_Numerator._Myused == 0) {
        return 0;
    }

    
    ; 

    uint32_t _Max_numerator_element_index         = _Numerator._Myused - 1;
    const uint32_t _Max_denominator_element_index = _Denominator._Myused - 1;

    
    if (_Max_denominator_element_index == 0) {
        const uint32_t _Small_denominator = _Denominator._Mydata[0];

        if (_Max_numerator_element_index == 0) {
            const uint32_t _Small_numerator = _Numerator._Mydata[0];

            if (_Small_denominator == 1) {
                _Numerator._Myused = 0;
                return _Small_numerator;
            }

            _Numerator._Mydata[0] = _Small_numerator % _Small_denominator;
            _Numerator._Myused    = _Numerator._Mydata[0] > 0 ? 1u : 0u;
            return _Small_numerator / _Small_denominator;
        }

        if (_Small_denominator == 1) {
            uint64_t _Quotient = _Numerator._Mydata[1];
            _Quotient <<= 32;
            _Quotient |= _Numerator._Mydata[0];
            _Numerator._Myused = 0;
            return _Quotient;
        }

        
        uint64_t _Quotient = 0;

        uint64_t _Uu = 0;
        for (uint32_t _Iv = _Max_numerator_element_index; _Iv != static_cast<uint32_t>(-1); --_Iv) {
            _Uu       = (_Uu << 32) | _Numerator._Mydata[_Iv];
            _Quotient = (_Quotient << 32) + static_cast<uint32_t>(_Uu / _Small_denominator);
            _Uu %= _Small_denominator;
        }

        _Numerator._Mydata[1] = static_cast<uint32_t>(_Uu >> 32);
        _Numerator._Mydata[0] = static_cast<uint32_t>(_Uu);

        if (_Numerator._Mydata[1] > 0) {
            _Numerator._Myused = 2u;
        } else if (_Numerator._Mydata[0] > 0) {
            _Numerator._Myused = 1u;
        } else {
            _Numerator._Myused = 0u;
        }

        return _Quotient;
    }

    if (_Max_denominator_element_index > _Max_numerator_element_index) {
        return 0;
    }

    const uint32_t _Cu_den = _Max_denominator_element_index + 1;
    const int32_t _Cu_diff = static_cast<int32_t>(_Max_numerator_element_index - _Max_denominator_element_index);

    
    int32_t _Cu_quo = _Cu_diff;
    for (int32_t _Iu = static_cast<int32_t>(_Max_numerator_element_index);; --_Iu) {
        if (_Iu < _Cu_diff) {
            ++_Cu_quo;
            break;
        }

        if (_Denominator._Mydata[_Iu - _Cu_diff] != _Numerator._Mydata[_Iu]) {
            if (_Denominator._Mydata[_Iu - _Cu_diff] < _Numerator._Mydata[_Iu]) {
                ++_Cu_quo;
            }

            break;
        }
    }

    if (_Cu_quo == 0) {
        return 0;
    }

    
    uint32_t _U_den      = _Denominator._Mydata[_Cu_den - 1];
    uint32_t _U_den_next = _Denominator._Mydata[_Cu_den - 2];

    const uint32_t _Cbit_shift_left  = _Count_sequential_high_zeroes(_U_den);
    const uint32_t _Cbit_shift_right = 32 - _Cbit_shift_left;
    if (_Cbit_shift_left > 0) {
        _U_den = (_U_den << _Cbit_shift_left) | (_U_den_next >> _Cbit_shift_right);
        _U_den_next <<= _Cbit_shift_left;

        if (_Cu_den > 2) {
            _U_den_next |= _Denominator._Mydata[_Cu_den - 3] >> _Cbit_shift_right;
        }
    }

    uint64_t _Quotient = 0;
    for (int32_t _Iu = _Cu_quo; --_Iu >= 0;) {
        
        const uint32_t _U_num_hi =
            (_Iu + _Cu_den <= _Max_numerator_element_index) ? _Numerator._Mydata[_Iu + _Cu_den] : 0;

        uint64_t _Uu_num =
            (static_cast<uint64_t>(_U_num_hi) << 32) | static_cast<uint64_t>(_Numerator._Mydata[_Iu + _Cu_den - 1]);

        uint32_t _U_num_next = _Numerator._Mydata[_Iu + _Cu_den - 2];
        if (_Cbit_shift_left > 0) {
            _Uu_num = (_Uu_num << _Cbit_shift_left) | (_U_num_next >> _Cbit_shift_right);
            _U_num_next <<= _Cbit_shift_left;

            if (_Iu + _Cu_den >= 3) {
                _U_num_next |= _Numerator._Mydata[_Iu + _Cu_den - 3] >> _Cbit_shift_right;
            }
        }

        
        uint64_t _Uu_quo = _Uu_num / _U_den;
        uint64_t _Uu_rem = static_cast<uint32_t>(_Uu_num % _U_den);

        if (_Uu_quo > 0xffffffffui32) {
            _Uu_rem += _U_den * (_Uu_quo - 0xffffffffui32);
            _Uu_quo = 0xffffffffui32;
        }

        while (_Uu_rem <= 0xffffffffui32 && _Uu_quo * _U_den_next > ((_Uu_rem << 32) | _U_num_next)) {
            --_Uu_quo;
            _Uu_rem += _U_den;
        }

        
        if (_Uu_quo > 0) {
            uint64_t _Uu_borrow = 0;

            for (uint32_t _Iu2 = 0; _Iu2 < _Cu_den; ++_Iu2) {
                _Uu_borrow += _Uu_quo * _Denominator._Mydata[_Iu2];

                const uint32_t _U_sub = static_cast<uint32_t>(_Uu_borrow);
                _Uu_borrow >>= 32;
                if (_Numerator._Mydata[_Iu + _Iu2] < _U_sub) {
                    ++_Uu_borrow;
                }

                _Numerator._Mydata[_Iu + _Iu2] -= _U_sub;
            }

            if (_U_num_hi < _Uu_borrow) {
                
                uint32_t _U_carry = 0;
                for (uint32_t _Iu2 = 0; _Iu2 < _Cu_den; ++_Iu2) {
                    const uint64_t _Sum = static_cast<uint64_t>(_Numerator._Mydata[_Iu + _Iu2])
                                        + static_cast<uint64_t>(_Denominator._Mydata[_Iu2]) + _U_carry;

                    _Numerator._Mydata[_Iu + _Iu2] = static_cast<uint32_t>(_Sum);
                    _U_carry                       = static_cast<uint32_t>(_Sum >> 32);
                }

                --_Uu_quo;
            }

            _Max_numerator_element_index = _Iu + _Cu_den - 1;
        }

        _Quotient = (_Quotient << 32) + static_cast<uint32_t>(_Uu_quo);
    }

    
    for (uint32_t _Ix = _Max_numerator_element_index + 1; _Ix < _Numerator._Myused; ++_Ix) {
        _Numerator._Mydata[_Ix] = 0;
    }

    uint32_t _Used = _Max_numerator_element_index + 1;

    while (_Used != 0 && _Numerator._Mydata[_Used - 1] == 0) {
        --_Used;
    }

    _Numerator._Myused = _Used;

    return _Quotient;
}


struct _Floating_point_string {
    bool _Myis_negative;
    int32_t _Myexponent;
    uint32_t _Mymantissa_count;
    uint8_t _Mymantissa[768];
};


template <class _FloatingType>
void _Assemble_floating_point_zero(const bool _Is_negative, _FloatingType& _Result) noexcept {
    using _Floating_traits = _Floating_type_traits<_FloatingType>;
    using _Uint_type       = typename _Floating_traits::_Uint_type;

    _Uint_type _Sign_component = _Is_negative;
    _Sign_component <<= _Floating_traits::_Sign_shift;

    _Result = _Bit_cast<_FloatingType>(_Sign_component);
}


template <class _FloatingType>
void _Assemble_floating_point_infinity(const bool _Is_negative, _FloatingType& _Result) noexcept {
    using _Floating_traits = _Floating_type_traits<_FloatingType>;
    using _Uint_type       = typename _Floating_traits::_Uint_type;

    _Uint_type _Sign_component = _Is_negative;
    _Sign_component <<= _Floating_traits::_Sign_shift;

    const _Uint_type _Exponent_component = _Floating_traits::_Shifted_exponent_mask;

    _Result = _Bit_cast<_FloatingType>(_Sign_component | _Exponent_component);
}


[[nodiscard]] inline bool _Should_round_up(
    const bool _Lsb_bit, const bool _Round_bit, const bool _Has_tail_bits) noexcept {
    
    
    return _Round_bit && (_Has_tail_bits || _Lsb_bit);
}


[[nodiscard]] inline uint64_t _Right_shift_with_rounding(
    const uint64_t _Value, const uint32_t _Shift, const bool _Has_zero_tail) noexcept {
    constexpr uint32_t _Total_number_of_bits = 64;
    if (_Shift >= _Total_number_of_bits) {
        if (_Shift == _Total_number_of_bits) {
            constexpr uint64_t _Extra_bits_mask = (1ULL << (_Total_number_of_bits - 1)) - 1;
            constexpr uint64_t _Round_bit_mask  = (1ULL << (_Total_number_of_bits - 1));

            const bool _Round_bit = (_Value & _Round_bit_mask) != 0;
            const bool _Tail_bits = !_Has_zero_tail || (_Value & _Extra_bits_mask) != 0;

            
            return static_cast<uint64_t>(_Round_bit && _Tail_bits);
        } else {
            
            return 0;
        }
    }

    
    const uint64_t _Lsb_bit = _Value;

    
    const uint64_t _Round_bit = _Value << 1;

    
    const uint64_t _Has_tail_bits = _Round_bit - static_cast<uint64_t>(_Has_zero_tail);

    
    const uint64_t _Should_round = ((_Round_bit & (_Has_tail_bits | _Lsb_bit)) >> _Shift) & uint64_t{1};

    
    return (_Value >> _Shift) + _Should_round;
}


template <class _FloatingType>
void _Assemble_floating_point_value_no_shift(const bool _Is_negative, const int32_t _Exponent,
    const typename _Floating_type_traits<_FloatingType>::_Uint_type _Mantissa, _FloatingType& _Result) noexcept {
    
    
    using _Floating_traits = _Floating_type_traits<_FloatingType>;
    using _Uint_type       = typename _Floating_traits::_Uint_type;

    _Uint_type _Sign_component = _Is_negative;
    _Sign_component <<= _Floating_traits::_Sign_shift;

    _Uint_type _Exponent_component = static_cast<uint32_t>(_Exponent + (_Floating_traits::_Exponent_bias - 1));
    _Exponent_component <<= _Floating_traits::_Exponent_shift;

    _Result = _Bit_cast<_FloatingType>(_Sign_component | (_Exponent_component + _Mantissa));
}


template <class _FloatingType>
[[nodiscard]] errc _Assemble_floating_point_value(const uint64_t _Initial_mantissa, const int32_t _Initial_exponent,
    const bool _Is_negative, const bool _Has_zero_tail, _FloatingType& _Result) noexcept {
    using _Traits = _Floating_type_traits<_FloatingType>;

    
    const uint32_t _Initial_mantissa_bits = _Bit_scan_reverse(_Initial_mantissa);
    const int32_t _Normal_mantissa_shift  = static_cast<int32_t>(_Traits::_Mantissa_bits - _Initial_mantissa_bits);
    const int32_t _Normal_exponent        = _Initial_exponent - _Normal_mantissa_shift;

    if (_Normal_exponent > _Traits::_Maximum_binary_exponent) {
        
        _Assemble_floating_point_infinity(_Is_negative, _Result);
        return errc::result_out_of_range; 
    }

    uint64_t _Mantissa = _Initial_mantissa;
    int32_t _Exponent  = _Normal_exponent;
    errc _Error_code{};

    if (_Normal_exponent < _Traits::_Minimum_binary_exponent) {
        
        
        _Exponent = _Traits::_Minimum_binary_exponent;

        
        const int32_t _Denormal_mantissa_shift = _Initial_exponent - _Exponent;

        if (_Denormal_mantissa_shift < 0) {
            _Mantissa =
                _Right_shift_with_rounding(_Mantissa, static_cast<uint32_t>(-_Denormal_mantissa_shift), _Has_zero_tail);

            
            if (_Mantissa == 0) {
                _Error_code = errc::result_out_of_range; 
            }

            
        } else {
            _Mantissa <<= _Denormal_mantissa_shift;
        }
    } else {
        if (_Normal_mantissa_shift < 0) {
            _Mantissa =
                _Right_shift_with_rounding(_Mantissa, static_cast<uint32_t>(-_Normal_mantissa_shift), _Has_zero_tail);

            
            if (_Mantissa > _Traits::_Normal_mantissa_mask && _Exponent == _Traits::_Maximum_binary_exponent) {
                _Error_code = errc::result_out_of_range; 
                                                         
            }
        } else {
            _Mantissa <<= _Normal_mantissa_shift;
        }
    }

    
    using _Uint_type = typename _Traits::_Uint_type;

    _Assemble_floating_point_value_no_shift(_Is_negative, _Exponent, static_cast<_Uint_type>(_Mantissa), _Result);

    return _Error_code;
}


template <class _FloatingType>
[[nodiscard]] errc _Assemble_floating_point_value_from_big_integer_flt(const _Big_integer_flt& _Integer_value,
    const uint32_t _Integer_bits_of_precision, const bool _Is_negative, const bool _Has_nonzero_fractional_part,
    _FloatingType& _Result) noexcept {
    using _Traits = _Floating_type_traits<_FloatingType>;

    const int32_t _Base_exponent = _Traits::_Mantissa_bits - 1;

    
    if (_Integer_bits_of_precision <= 64) {
        const int32_t _Exponent = _Base_exponent;

        const uint32_t _Mantissa_low  = _Integer_value._Myused > 0 ? _Integer_value._Mydata[0] : 0;
        const uint32_t _Mantissa_high = _Integer_value._Myused > 1 ? _Integer_value._Mydata[1] : 0;
        const uint64_t _Mantissa      = _Mantissa_low + (static_cast<uint64_t>(_Mantissa_high) << 32);

        return _Assemble_floating_point_value(
            _Mantissa, _Exponent, _Is_negative, !_Has_nonzero_fractional_part, _Result);
    }

    const uint32_t _Top_element_bits  = _Integer_bits_of_precision % 32;
    const uint32_t _Top_element_index = _Integer_bits_of_precision / 32;

    const uint32_t _Middle_element_index = _Top_element_index - 1;
    const uint32_t _Bottom_element_index = _Top_element_index - 2;

    
    if (_Top_element_bits == 0) {
        const int32_t _Exponent = static_cast<int32_t>(_Base_exponent + _Bottom_element_index * 32);

        const uint64_t _Mantissa = _Integer_value._Mydata[_Bottom_element_index]
                                 + (static_cast<uint64_t>(_Integer_value._Mydata[_Middle_element_index]) << 32);

        bool _Has_zero_tail = !_Has_nonzero_fractional_part;
        for (uint32_t _Ix = 0; _Has_zero_tail && _Ix != _Bottom_element_index; ++_Ix) {
            _Has_zero_tail = _Integer_value._Mydata[_Ix] == 0;
        }

        return _Assemble_floating_point_value(_Mantissa, _Exponent, _Is_negative, _Has_zero_tail, _Result);
    }

    
    const uint32_t _Top_element_mask  = (1u << _Top_element_bits) - 1;
    const uint32_t _Top_element_shift = 64 - _Top_element_bits; 

    const uint32_t _Middle_element_shift = _Top_element_shift - 32; 

    const uint32_t _Bottom_element_bits  = 32 - _Top_element_bits;
    const uint32_t _Bottom_element_mask  = ~_Top_element_mask;
    const uint32_t _Bottom_element_shift = 32 - _Bottom_element_bits; 

    const int32_t _Exponent = static_cast<int32_t>(_Base_exponent + _Bottom_element_index * 32 + _Top_element_bits);

    const uint64_t _Mantissa =
        (static_cast<uint64_t>(_Integer_value._Mydata[_Top_element_index] & _Top_element_mask) << _Top_element_shift)
        + (static_cast<uint64_t>(_Integer_value._Mydata[_Middle_element_index]) << _Middle_element_shift)
        + (static_cast<uint64_t>(_Integer_value._Mydata[_Bottom_element_index] & _Bottom_element_mask)
            >> _Bottom_element_shift);

    bool _Has_zero_tail =
        !_Has_nonzero_fractional_part && (_Integer_value._Mydata[_Bottom_element_index] & _Top_element_mask) == 0;

    for (uint32_t _Ix = 0; _Has_zero_tail && _Ix != _Bottom_element_index; ++_Ix) {
        _Has_zero_tail = _Integer_value._Mydata[_Ix] == 0;
    }

    return _Assemble_floating_point_value(_Mantissa, _Exponent, _Is_negative, _Has_zero_tail, _Result);
}


inline void _Accumulate_decimal_digits_into_big_integer_flt(
    const uint8_t* const _First_digit, const uint8_t* const _Last_digit, _Big_integer_flt& _Result) noexcept {
    
    
    uint32_t _Accumulator       = 0;
    uint32_t _Accumulator_count = 0;
    for (const uint8_t* _It = _First_digit; _It != _Last_digit; ++_It) {
        if (_Accumulator_count == 9) {
            [[maybe_unused]] const bool _Success1 = _Multiply(_Result, 1'000'000'000); 
            ;
            [[maybe_unused]] const bool _Success2 = _Add(_Result, _Accumulator); 
            ;

            _Accumulator       = 0;
            _Accumulator_count = 0;
        }

        _Accumulator *= 10;
        _Accumulator += *_It;
        ++_Accumulator_count;
    }

    if (_Accumulator_count != 0) {
        [[maybe_unused]] const bool _Success3 =
            _Multiply_by_power_of_ten(_Result, _Accumulator_count); 
        ;
        [[maybe_unused]] const bool _Success4 = _Add(_Result, _Accumulator); 
        ;
    }
}


template <class _FloatingType>
[[nodiscard]] errc _Convert_decimal_string_to_floating_type(
    const _Floating_point_string& _Data, _FloatingType& _Result, bool _Has_zero_tail) noexcept {
    using _Traits = _Floating_type_traits<_FloatingType>;

    
    const uint32_t _Required_bits_of_precision = static_cast<uint32_t>(_Traits::_Mantissa_bits + 1);

    
    const uint32_t _Positive_exponent      = static_cast<uint32_t>((::std:: max)(0, _Data._Myexponent));
    const uint32_t _Integer_digits_present = (::std:: min)(_Positive_exponent, _Data._Mymantissa_count);
    const uint32_t _Integer_digits_missing = _Positive_exponent - _Integer_digits_present;
    const uint8_t* const _Integer_first    = _Data._Mymantissa;
    const uint8_t* const _Integer_last     = _Data._Mymantissa + _Integer_digits_present;

    const uint8_t* const _Fractional_first    = _Integer_last;
    const uint8_t* const _Fractional_last     = _Data._Mymantissa + _Data._Mymantissa_count;
    const uint32_t _Fractional_digits_present = static_cast<uint32_t>(_Fractional_last - _Fractional_first);

    
    _Big_integer_flt _Integer_value{};
    _Accumulate_decimal_digits_into_big_integer_flt(_Integer_first, _Integer_last, _Integer_value);

    if (_Integer_digits_missing > 0) {
        if (!_Multiply_by_power_of_ten(_Integer_value, _Integer_digits_missing)) {
            _Assemble_floating_point_infinity(_Data._Myis_negative, _Result);
            return errc::result_out_of_range; 
        }
    }

    
    const uint32_t _Integer_bits_of_precision = _Bit_scan_reverse(_Integer_value);
    {
        const bool _Has_zero_fractional_part = _Fractional_digits_present == 0 && _Has_zero_tail;

        if (_Integer_bits_of_precision >= _Required_bits_of_precision || _Has_zero_fractional_part) {
            return _Assemble_floating_point_value_from_big_integer_flt(
                _Integer_value, _Integer_bits_of_precision, _Data._Myis_negative, !_Has_zero_fractional_part, _Result);
        }
    }

    
    _Big_integer_flt _Fractional_numerator{};
    _Accumulate_decimal_digits_into_big_integer_flt(_Fractional_first, _Fractional_last, _Fractional_numerator);

    const uint32_t _Fractional_denominator_exponent =
        _Data._Myexponent < 0 ? _Fractional_digits_present + static_cast<uint32_t>(-_Data._Myexponent)
                              : _Fractional_digits_present;

    _Big_integer_flt _Fractional_denominator = _Make_big_integer_flt_one();
    if (!_Multiply_by_power_of_ten(_Fractional_denominator, _Fractional_denominator_exponent)) {
        
        
        _Assemble_floating_point_zero(_Data._Myis_negative, _Result);
        return errc::result_out_of_range; 
    }

    
    const uint32_t _Fractional_numerator_bits   = _Bit_scan_reverse(_Fractional_numerator);
    const uint32_t _Fractional_denominator_bits = _Bit_scan_reverse(_Fractional_denominator);

    const uint32_t _Fractional_shift = _Fractional_denominator_bits > _Fractional_numerator_bits
                                         ? _Fractional_denominator_bits - _Fractional_numerator_bits
                                         : 0;

    if (_Fractional_shift > 0) {
        [[maybe_unused]] const bool _Shift_success1 =
            _Shift_left(_Fractional_numerator, _Fractional_shift); 
        ;
    }

    const uint32_t _Required_fractional_bits_of_precision = _Required_bits_of_precision - _Integer_bits_of_precision;

    uint32_t _Remaining_bits_of_precision_required = _Required_fractional_bits_of_precision;
    if (_Integer_bits_of_precision > 0) {
        
        
        if (_Fractional_shift > _Remaining_bits_of_precision_required) {
            return _Assemble_floating_point_value_from_big_integer_flt(_Integer_value, _Integer_bits_of_precision,
                _Data._Myis_negative, _Fractional_digits_present != 0 || !_Has_zero_tail, _Result);
        }

        _Remaining_bits_of_precision_required -= _Fractional_shift;
    }

    
    const uint32_t _Fractional_exponent =
        _Fractional_numerator < _Fractional_denominator ? _Fractional_shift + 1 : _Fractional_shift;

    [[maybe_unused]] const bool _Shift_success2 =
        _Shift_left(_Fractional_numerator, _Remaining_bits_of_precision_required); 
    ;

    uint64_t _Fractional_mantissa = _Divide(_Fractional_numerator, _Fractional_denominator);

    _Has_zero_tail = _Has_zero_tail && _Fractional_numerator._Myused == 0;

    
    const uint32_t _Fractional_mantissa_bits = _Bit_scan_reverse(_Fractional_mantissa);
    if (_Fractional_mantissa_bits > _Required_fractional_bits_of_precision) {
        const uint32_t _Shift = _Fractional_mantissa_bits - _Required_fractional_bits_of_precision;
        _Has_zero_tail        = _Has_zero_tail && (_Fractional_mantissa & ((1ULL << _Shift) - 1)) == 0;
        _Fractional_mantissa >>= _Shift;
    }

    
    const uint32_t _Integer_mantissa_low  = _Integer_value._Myused > 0 ? _Integer_value._Mydata[0] : 0;
    const uint32_t _Integer_mantissa_high = _Integer_value._Myused > 1 ? _Integer_value._Mydata[1] : 0;
    const uint64_t _Integer_mantissa = _Integer_mantissa_low + (static_cast<uint64_t>(_Integer_mantissa_high) << 32);

    const uint64_t _Complete_mantissa =
        (_Integer_mantissa << _Required_fractional_bits_of_precision) + _Fractional_mantissa;

    
    const int32_t _Final_exponent = _Integer_bits_of_precision > 0
                                      ? static_cast<int32_t>(_Integer_bits_of_precision - 2)
                                      : -static_cast<int32_t>(_Fractional_exponent) - 1;

    return _Assemble_floating_point_value(
        _Complete_mantissa, _Final_exponent, _Data._Myis_negative, _Has_zero_tail, _Result);
}

template <class _FloatingType>
[[nodiscard]] errc _Convert_hexadecimal_string_to_floating_type(
    const _Floating_point_string& _Data, _FloatingType& _Result, bool _Has_zero_tail) noexcept {
    using _Traits = _Floating_type_traits<_FloatingType>;

    uint64_t _Mantissa = 0;
    int32_t _Exponent  = _Data._Myexponent + _Traits::_Mantissa_bits - 1;

    
    const uint8_t* const _Mantissa_last = _Data._Mymantissa + _Data._Mymantissa_count;
    const uint8_t* _Mantissa_it         = _Data._Mymantissa;
    while (_Mantissa_it != _Mantissa_last && _Mantissa <= _Traits::_Normal_mantissa_mask) {
        _Mantissa *= 16;
        _Mantissa += *_Mantissa_it++;
        _Exponent -= 4; 
    }

    while (_Has_zero_tail && _Mantissa_it != _Mantissa_last) {
        _Has_zero_tail = *_Mantissa_it++ == 0;
    }

    return _Assemble_floating_point_value(_Mantissa, _Exponent, _Data._Myis_negative, _Has_zero_tail, _Result);
}


template <class _Floating>
[[nodiscard]] from_chars_result _Ordinary_floating_from_chars(const char* const _First, const char* const _Last,
    _Floating& _Value, const chars_format _Fmt, const bool _Minus_sign, const char* _Next) noexcept {
    

    const bool _Is_hexadecimal = _Fmt == chars_format::hex;
    const int _Base{_Is_hexadecimal ? 16 : 10};

    
    _Floating_point_string _Fp_string;

    
    _Fp_string._Myis_negative = _Minus_sign;

    uint8_t* const _Mantissa_first = _Fp_string._Mymantissa;
    uint8_t* const _Mantissa_last  = ::std:: end(_Fp_string._Mymantissa);
    uint8_t* _Mantissa_it          = _Mantissa_first;

    
    const char* const _Whole_begin = _Next;

    
    for (; _Next != _Last && *_Next == '0'; ++_Next) {
    }
    const char* const _Leading_zero_end = _Next;

    
    for (; _Next != _Last; ++_Next) {
        const unsigned char _Digit_value = _Digit_from_char(*_Next);

        if (_Digit_value >= _Base) {
            break;
        }

        if (_Mantissa_it != _Mantissa_last) {
            *_Mantissa_it++ = _Digit_value;
        }
    }
    const char* const _Whole_end = _Next;

    
    constexpr ptrdiff_t _Maximum_adjustment = 1'000'000;
    constexpr ptrdiff_t _Minimum_adjustment = -1'000'000;

    
    int _Exponent_adjustment = static_cast<int>((::std:: min)(_Whole_end - _Leading_zero_end, _Maximum_adjustment));

    
    if (_Next != _Last && *_Next == '.') {
        ++_Next;
    }
    const char* const _Dot_end = _Next;

    
    if (_Exponent_adjustment == 0) {
        for (; _Next != _Last && *_Next == '0'; ++_Next) {
        }

        _Exponent_adjustment = static_cast<int>((::std:: max)(_Dot_end - _Next, _Minimum_adjustment));
    }

    
    bool _Has_zero_tail = true;

    for (; _Next != _Last; ++_Next) {
        const unsigned char _Digit_value = _Digit_from_char(*_Next);

        if (_Digit_value >= _Base) {
            break;
        }

        if (_Mantissa_it != _Mantissa_last) {
            *_Mantissa_it++ = _Digit_value;
        } else {
            _Has_zero_tail = _Has_zero_tail && _Digit_value == 0;
        }
    }
    const char* const _Frac_end = _Next;

    
    if (_Whole_begin == _Whole_end && _Dot_end == _Frac_end) {
        return {_First, errc::invalid_argument};
    }

    const char _Exponent_prefix{_Is_hexadecimal ? 'p' : 'e'};

    bool _Exponent_is_negative = false;
    int _Exponent              = 0;

    constexpr int _Maximum_temporary_decimal_exponent = 5200;
    constexpr int _Minimum_temporary_decimal_exponent = -5200;

    if (_Fmt != chars_format::fixed 
                                    
                                    
        && _Next != _Last && (static_cast<unsigned char>(*_Next) | 0x20) == _Exponent_prefix) { 
        const char* _Unread = _Next + 1;

        if (_Unread != _Last && (*_Unread == '+' || *_Unread == '-')) { 
            _Exponent_is_negative = *_Unread == '-';
            ++_Unread;
        }

        while (_Unread != _Last) {
            const unsigned char _Digit_value = _Digit_from_char(*_Unread);

            if (_Digit_value >= 10) {
                break;
            }

            
            if (_Exponent <= _Maximum_temporary_decimal_exponent) {
                _Exponent = _Exponent * 10 + _Digit_value;
            }

            ++_Unread;
            _Next = _Unread; 
        }

        if (_Exponent_is_negative) {
            _Exponent = -_Exponent;
        }
    }

    
    const char* const _Exponent_end = _Next;

    if (_Fmt == chars_format::scientific
        && _Frac_end == _Exponent_end) { 
                                         
                                         
        return {_First, errc::invalid_argument};
    }

    
    while (_Mantissa_it != _Mantissa_first && *(_Mantissa_it - 1) == 0) {
        --_Mantissa_it;
    }

    
    if (_Mantissa_it == _Mantissa_first) {
        ;
        _Assemble_floating_point_zero(_Fp_string._Myis_negative, _Value);
        return {_Next, errc{}};
    }

    
    if (_Exponent > _Maximum_temporary_decimal_exponent) {
        _Assemble_floating_point_infinity(_Fp_string._Myis_negative, _Value);
        return {_Next, errc::result_out_of_range}; 
    }

    if (_Exponent < _Minimum_temporary_decimal_exponent) {
        _Assemble_floating_point_zero(_Fp_string._Myis_negative, _Value);
        return {_Next, errc::result_out_of_range}; 
    }

    
    const int _Exponent_adjustment_multiplier{_Is_hexadecimal ? 4 : 1};

    _Exponent += _Exponent_adjustment * _Exponent_adjustment_multiplier;

    
    if (_Exponent > _Maximum_temporary_decimal_exponent) {
        _Assemble_floating_point_infinity(_Fp_string._Myis_negative, _Value);
        return {_Next, errc::result_out_of_range}; 
    }

    if (_Exponent < _Minimum_temporary_decimal_exponent) {
        _Assemble_floating_point_zero(_Fp_string._Myis_negative, _Value);
        return {_Next, errc::result_out_of_range}; 
    }

    _Fp_string._Myexponent       = _Exponent;
    _Fp_string._Mymantissa_count = static_cast<uint32_t>(_Mantissa_it - _Mantissa_first);

    if (_Is_hexadecimal) {
        const errc _Ec = _Convert_hexadecimal_string_to_floating_type(_Fp_string, _Value, _Has_zero_tail);
        return {_Next, _Ec};
    } else {
        const errc _Ec = _Convert_decimal_string_to_floating_type(_Fp_string, _Value, _Has_zero_tail);
        return {_Next, _Ec};
    }

    
}

[[nodiscard]] inline bool _Starts_with_case_insensitive(
    const char* _First, const char* const _Last, const char* _Lowercase) noexcept {
    
    for (; _First != _Last && *_Lowercase != '\0'; ++_First, ++_Lowercase) {
        if ((static_cast<unsigned char>(*_First) | 0x20) != *_Lowercase) {
            return false;
        }
    }

    return *_Lowercase == '\0';
}

template <class _Floating>
[[nodiscard]] from_chars_result _Infinity_from_chars(const char* const _First, const char* const _Last, _Floating& _Value,
    const bool _Minus_sign, const char* _Next) noexcept {
    
    if (!_Starts_with_case_insensitive(_Next + 1, _Last, "nf")) { 
        return {_First, errc::invalid_argument};
    }

    
    _Next += 3;

    if (_Starts_with_case_insensitive(_Next, _Last, "inity")) { 
        _Next += 5;
    }

    _Assemble_floating_point_infinity(_Minus_sign, _Value);

    return {_Next, errc{}};
}

template <class _Floating>
[[nodiscard]] from_chars_result _Nan_from_chars(const char* const _First, const char* const _Last, _Floating& _Value,
    bool _Minus_sign, const char* _Next) noexcept {
    
    if (!_Starts_with_case_insensitive(_Next + 1, _Last, "an")) { 
        return {_First, errc::invalid_argument};
    }

    
    _Next += 3;

    bool _Quiet = true;

    if (_Next != _Last && *_Next == '(') { 
        const char* const _Seq_begin = _Next + 1;

        for (const char* _Temp = _Seq_begin; _Temp != _Last; ++_Temp) {
            if (*_Temp == ')') { 
                _Next = _Temp + 1;

                if (_Temp - _Seq_begin == 3
                    && _Starts_with_case_insensitive(_Seq_begin, _Temp, "ind")) { 
                    
                    
                    _Minus_sign = true;
                } else if (_Temp - _Seq_begin == 4
                           && _Starts_with_case_insensitive(_Seq_begin, _Temp, "snan")) { 
                    _Quiet = false;
                }

                break;
            } else if (*_Temp == '_' || ('0' <= *_Temp && *_Temp <= '9') || ('A' <= *_Temp && *_Temp <= 'Z')
                       || ('a' <= *_Temp && *_Temp <= 'z')) { 
            } else { 
                break;
            }
        }
    }

    
    using _Traits    = _Floating_type_traits<_Floating>;
    using _Uint_type = typename _Traits::_Uint_type;

    _Uint_type _Uint_value = _Traits::_Shifted_exponent_mask;

    if (_Minus_sign) {
        _Uint_value |= _Traits::_Shifted_sign_mask;
    }

    if (_Quiet) {
        _Uint_value |= _Traits::_Special_nan_mantissa_mask;
    } else {
        _Uint_value |= 1;
    }

    _Value = _Bit_cast<_Floating>(_Uint_value);

    return {_Next, errc{}};
}

template <class _Floating>
[[nodiscard]] from_chars_result _Floating_from_chars(
    const char* const _First, const char* const _Last, _Floating& _Value, const chars_format _Fmt) noexcept {
    _Adl_verify_range(_First, _Last);

    ;
#line 1979 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\charconv"

    bool _Minus_sign = false;

    const char* _Next = _First;

    if (_Next == _Last) {
        return {_First, errc::invalid_argument};
    }

    if (*_Next == '-') {
        _Minus_sign = true;
        ++_Next;

        if (_Next == _Last) {
            return {_First, errc::invalid_argument};
        }
    }

    
    const unsigned char _Folded_start = static_cast<unsigned char>(static_cast<unsigned char>(*_Next) | 0x20);

    if (_Folded_start <= 'f') { 
        return _Ordinary_floating_from_chars(_First, _Last, _Value, _Fmt, _Minus_sign, _Next);
    } else if (_Folded_start == 'i') { 
        return _Infinity_from_chars(_First, _Last, _Value, _Minus_sign, _Next);
    } else if (_Folded_start == 'n') { 
        return _Nan_from_chars(_First, _Last, _Value, _Minus_sign, _Next);
    } else { 
        return {_First, errc::invalid_argument};
    }
}

inline from_chars_result from_chars(const char* const _First, const char* const _Last, float& _Value,
    const chars_format _Fmt = chars_format::general) noexcept  {
    return _Floating_from_chars(_First, _Last, _Value, _Fmt);
}
inline from_chars_result from_chars(const char* const _First, const char* const _Last, double& _Value,
    const chars_format _Fmt = chars_format::general) noexcept  {
    return _Floating_from_chars(_First, _Last, _Value, _Fmt);
}
inline from_chars_result from_chars(const char* const _First, const char* const _Last, long double& _Value,
    const chars_format _Fmt = chars_format::general) noexcept  {
    double _Dbl; 
    const from_chars_result _Result = _Floating_from_chars(_First, _Last, _Dbl, _Fmt);

    if (_Result.ec == errc{}) {
        _Value = _Dbl;
    }

    return _Result;
}

template <class _Floating>
[[nodiscard]] to_chars_result _Floating_to_chars_hex_precision(
    char* _First, char* const _Last, const _Floating _Value, int _Precision) noexcept {

    
    constexpr int _Full_precision         = is_same_v<_Floating, float> ? 6 : 13;
    constexpr int _Adjusted_explicit_bits = _Full_precision * 4;

    if (_Precision < 0) {
        
        
        _Precision = _Full_precision;
    }

    
    using _Traits    = _Floating_type_traits<_Floating>;
    using _Uint_type = typename _Traits::_Uint_type;

    const _Uint_type _Uint_value    = _Bit_cast<_Uint_type>(_Value);
    const _Uint_type _Ieee_mantissa = _Uint_value & _Traits::_Denormal_mantissa_mask;
    const int32_t _Ieee_exponent    = static_cast<int32_t>(_Uint_value >> _Traits::_Exponent_shift);

    
    _Uint_type _Adjusted_mantissa;

    if constexpr (is_same_v<_Floating, float>) {
        _Adjusted_mantissa = _Ieee_mantissa << 1; 
    } else {
        _Adjusted_mantissa = _Ieee_mantissa; 
    }

    int32_t _Unbiased_exponent;

    if (_Ieee_exponent == 0) { 
        

        if (_Ieee_mantissa == 0) { 
            
            _Unbiased_exponent = 0;
        } else { 
            _Unbiased_exponent = 1 - _Traits::_Exponent_bias;
        }
    } else { 
        _Adjusted_mantissa |= _Uint_type{1} << _Adjusted_explicit_bits; 
        _Unbiased_exponent = _Ieee_exponent - _Traits::_Exponent_bias;
    }

    
    char _Sign_character;
    uint32_t _Absolute_exponent;

    if (_Unbiased_exponent < 0) {
        _Sign_character    = '-';
        _Absolute_exponent = static_cast<uint32_t>(-_Unbiased_exponent);
    } else {
        _Sign_character    = '+';
        _Absolute_exponent = static_cast<uint32_t>(_Unbiased_exponent);
    }

    
    {
        int32_t _Exponent_length;

        if (_Absolute_exponent < 10) {
            _Exponent_length = 1;
        } else if (_Absolute_exponent < 100) {
            _Exponent_length = 2;
        } else if constexpr (is_same_v<_Floating, float>) {
            _Exponent_length = 3;
        } else if (_Absolute_exponent < 1000) {
            _Exponent_length = 3;
        } else {
            _Exponent_length = 4;
        }

        
        ptrdiff_t _Buffer_size = _Last - _First;

        if (_Buffer_size < _Precision) {
            return {_Last, errc::value_too_large};
        }

        _Buffer_size -= _Precision;

        const int32_t _Length_excluding_precision = 1 
                                                  + static_cast<int32_t>(_Precision > 0) 
                                                  
                                                  + 2 
                                                  + _Exponent_length; 

        if (_Buffer_size < _Length_excluding_precision) {
            return {_Last, errc::value_too_large};
        }
    }

    
    if (_Precision < _Full_precision) {
        

        const int _Dropped_bits = (_Full_precision - _Precision) * 4;

        
        const _Uint_type _Lsb_bit = _Adjusted_mantissa;

        
        const _Uint_type _Round_bit = _Adjusted_mantissa << 1;

        
        const _Uint_type _Has_tail_bits = _Round_bit - 1;

        
        const _Uint_type _Should_round = _Round_bit & (_Has_tail_bits | _Lsb_bit) & (_Uint_type{1} << _Dropped_bits);

        
        _Adjusted_mantissa += _Should_round;
    }

    
    {
        const uint32_t _Nibble = static_cast<uint32_t>(_Adjusted_mantissa >> _Adjusted_explicit_bits);
        ;
        const char _Leading_hexit = static_cast<char>('0' + _Nibble);

        *_First++ = _Leading_hexit;

        constexpr _Uint_type _Mask = (_Uint_type{1} << _Adjusted_explicit_bits) - 1;
        _Adjusted_mantissa &= _Mask;
    }

    
    if (_Precision > 0) {
        *_First++ = '.';

        int32_t _Number_of_bits_remaining = _Adjusted_explicit_bits; 

        for (;;) {
            ;
            ;
            _Number_of_bits_remaining -= 4;

            const uint32_t _Nibble = static_cast<uint32_t>(_Adjusted_mantissa >> _Number_of_bits_remaining);
            ;
            const char _Hexit = _Charconv_digits[_Nibble];

            *_First++ = _Hexit;

            
            --_Precision;
            if (_Precision == 0) {
                break; 
            }
            

            if (_Number_of_bits_remaining == 0) {
                
                :: memset(_First, '0', static_cast<size_t>(_Precision));
                _First += _Precision;
                break;
            }

            
            const _Uint_type _Mask = (_Uint_type{1} << _Number_of_bits_remaining) - 1;
            _Adjusted_mantissa &= _Mask;
        }
    }

    
    *_First++ = 'p';
    *_First++ = _Sign_character;

    
    return ::std:: to_chars(_First, _Last, _Absolute_exponent);
}

template <class _Floating>
[[nodiscard]] to_chars_result _Floating_to_chars_hex_shortest(
    char* _First, char* const _Last, const _Floating _Value) noexcept {

    
    using _Traits    = _Floating_type_traits<_Floating>;
    using _Uint_type = typename _Traits::_Uint_type;

    const _Uint_type _Uint_value = _Bit_cast<_Uint_type>(_Value);

    if (_Uint_value == 0) { 
        
        
        const char* const _Str = "0p+0";
        const size_t _Len      = 4;

        if (_Last - _First < static_cast<ptrdiff_t>(_Len)) {
            return {_Last, errc::value_too_large};
        }

        :: memcpy(_First, _Str, _Len);

        return {_First + _Len, errc{}};
    }

    const _Uint_type _Ieee_mantissa = _Uint_value & _Traits::_Denormal_mantissa_mask;
    const int32_t _Ieee_exponent    = static_cast<int32_t>(_Uint_value >> _Traits::_Exponent_shift);

    char _Leading_hexit; 
    int32_t _Unbiased_exponent;

    if (_Ieee_exponent == 0) { 
        _Leading_hexit     = '0';
        _Unbiased_exponent = 1 - _Traits::_Exponent_bias;
    } else { 
        _Leading_hexit     = '1';
        _Unbiased_exponent = _Ieee_exponent - _Traits::_Exponent_bias;
    }

    
    if (_First == _Last) {
        return {_Last, errc::value_too_large};
    }

    *_First++ = _Leading_hexit;

    if (_Ieee_mantissa == 0) {
        
    } else {
        if (_First == _Last) {
            return {_Last, errc::value_too_large};
        }

        *_First++ = '.';

        
        _Uint_type _Adjusted_mantissa;
        int32_t _Number_of_bits_remaining;

        if constexpr (is_same_v<_Floating, float>) {
            _Adjusted_mantissa        = _Ieee_mantissa << 1; 
            _Number_of_bits_remaining = 24; 
        } else {
            _Adjusted_mantissa        = _Ieee_mantissa; 
            _Number_of_bits_remaining = 52; 
        }

        
        do {
            ;
            ;
            _Number_of_bits_remaining -= 4;

            const uint32_t _Nibble = static_cast<uint32_t>(_Adjusted_mantissa >> _Number_of_bits_remaining);
            ;
            const char _Hexit = _Charconv_digits[_Nibble];

            if (_First == _Last) {
                return {_Last, errc::value_too_large};
            }

            *_First++ = _Hexit;

            const _Uint_type _Mask = (_Uint_type{1} << _Number_of_bits_remaining) - 1;
            _Adjusted_mantissa &= _Mask;

        } while (_Adjusted_mantissa != 0);
    }

    
    if (_Last - _First < 2) {
        return {_Last, errc::value_too_large};
    }

    *_First++ = 'p';

    if (_Unbiased_exponent < 0) {
        *_First++          = '-';
        _Unbiased_exponent = -_Unbiased_exponent;
    } else {
        *_First++ = '+';
    }

    
    return ::std:: to_chars(_First, _Last, static_cast<uint32_t>(_Unbiased_exponent));
}


#line 2624 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\charconv"

template <class _Floating>
struct _General_precision_tables;

template <>
struct _General_precision_tables<float> {
    static constexpr int _Max_special_P = 7;

    static constexpr uint32_t _Special_X_table[63] = {0x38C73ABCu, 0x3A79096Bu, 0x3C1BA5E3u, 0x3DC28F5Cu, 0x3F733333u,
        0x4117FFFFu, 0x38D0AAA7u, 0x3A826AA8u, 0x3C230553u, 0x3DCBC6A7u, 0x3F7EB851u, 0x411F3333u, 0x42C6FFFFu,
        0x38D19C3Fu, 0x3A8301A7u, 0x3C23C211u, 0x3DCCB295u, 0x3F7FDF3Bu, 0x411FEB85u, 0x42C7E666u, 0x4479DFFFu,
        0x38D1B468u, 0x3A8310C1u, 0x3C23D4F1u, 0x3DCCCA2Du, 0x3F7FFCB9u, 0x411FFDF3u, 0x42C7FD70u, 0x4479FCCCu,
        0x461C3DFFu, 0x38D1B6D2u, 0x3A831243u, 0x3C23D6D4u, 0x3DCCCC89u, 0x3F7FFFACu, 0x411FFFCBu, 0x42C7FFBEu,
        0x4479FFAEu, 0x461C3FCCu, 0x47C34FBFu, 0x38D1B710u, 0x3A83126Au, 0x3C23D704u, 0x3DCCCCC6u, 0x3F7FFFF7u,
        0x411FFFFAu, 0x42C7FFF9u, 0x4479FFF7u, 0x461C3FFAu, 0x47C34FF9u, 0x497423F7u, 0x38D1B716u, 0x3A83126Eu,
        0x3C23D709u, 0x3DCCCCCCu, 0x3F7FFFFFu, 0x411FFFFFu, 0x42C7FFFFu, 0x4479FFFFu, 0x461C3FFFu, 0x47C34FFFu,
        0x497423FFu, 0x4B18967Fu};

    static constexpr int _Max_P = 39;

    static constexpr uint32_t _Ordinary_X_table[44] = {0x38D1B717u, 0x3A83126Eu, 0x3C23D70Au, 0x3DCCCCCCu, 0x3F7FFFFFu,
        0x411FFFFFu, 0x42C7FFFFu, 0x4479FFFFu, 0x461C3FFFu, 0x47C34FFFu, 0x497423FFu, 0x4B18967Fu, 0x4CBEBC1Fu,
        0x4E6E6B27u, 0x501502F8u, 0x51BA43B7u, 0x5368D4A5u, 0x551184E7u, 0x56B5E620u, 0x58635FA9u, 0x5A0E1BC9u,
        0x5BB1A2BCu, 0x5D5E0B6Bu, 0x5F0AC723u, 0x60AD78EBu, 0x6258D726u, 0x64078678u, 0x65A96816u, 0x6753C21Bu,
        0x69045951u, 0x6AA56FA5u, 0x6C4ECB8Fu, 0x6E013F39u, 0x6FA18F07u, 0x7149F2C9u, 0x72FC6F7Cu, 0x749DC5ADu,
        0x76453719u, 0x77F684DFu, 0x799A130Bu, 0x7B4097CEu, 0x7CF0BDC2u, 0x7E967699u, 0x7F7FFFFFu};
};

template <>
struct _General_precision_tables<double> {
    static constexpr int _Max_special_P = 15;

    static constexpr uint64_t _Special_X_table[195] = {0x3F18E757928E0C9Du, 0x3F4F212D77318FC5u, 0x3F8374BC6A7EF9DBu,
        0x3FB851EB851EB851u, 0x3FEE666666666666u, 0x4022FFFFFFFFFFFFu, 0x3F1A1554FBDAD751u, 0x3F504D551D68C692u,
        0x3F8460AA64C2F837u, 0x3FB978D4FDF3B645u, 0x3FEFD70A3D70A3D7u, 0x4023E66666666666u, 0x4058DFFFFFFFFFFFu,
        0x3F1A3387ECC8EB96u, 0x3F506034F3FD933Eu, 0x3F84784230FCF80Du, 0x3FB99652BD3C3611u, 0x3FEFFBE76C8B4395u,
        0x4023FD70A3D70A3Du, 0x4058FCCCCCCCCCCCu, 0x408F3BFFFFFFFFFFu, 0x3F1A368D04E0BA6Au, 0x3F506218230C7482u,
        0x3F847A9E2BCF91A3u, 0x3FB99945B6C3760Bu, 0x3FEFFF972474538Eu, 0x4023FFBE76C8B439u, 0x4058FFAE147AE147u,
        0x408F3F9999999999u, 0x40C387BFFFFFFFFFu, 0x3F1A36DA54164F19u, 0x3F506248748DF16Fu, 0x3F847ADA91B16DCBu,
        0x3FB99991361DC93Eu, 0x3FEFFFF583A53B8Eu, 0x4023FFF972474538u, 0x4058FFF7CED91687u, 0x408F3FF5C28F5C28u,
        0x40C387F999999999u, 0x40F869F7FFFFFFFFu, 0x3F1A36E20F35445Du, 0x3F50624D49814ABAu, 0x3F847AE09BE19D69u,
        0x3FB99998C2DA04C3u, 0x3FEFFFFEF39085F4u, 0x4023FFFF583A53B8u, 0x4058FFFF2E48E8A7u, 0x408F3FFEF9DB22D0u,
        0x40C387FF5C28F5C2u, 0x40F869FF33333333u, 0x412E847EFFFFFFFFu, 0x3F1A36E2D51EC34Bu, 0x3F50624DC5333A0Eu,
        0x3F847AE136800892u, 0x3FB9999984200AB7u, 0x3FEFFFFFE5280D65u, 0x4023FFFFEF39085Fu, 0x4058FFFFEB074A77u,
        0x408F3FFFE5C91D14u, 0x40C387FFEF9DB22Du, 0x40F869FFEB851EB8u, 0x412E847FE6666666u, 0x416312CFEFFFFFFFu,
        0x3F1A36E2E8E94FFCu, 0x3F50624DD191D1FDu, 0x3F847AE145F6467Du, 0x3FB999999773D81Cu, 0x3FEFFFFFFD50CE23u,
        0x4023FFFFFE5280D6u, 0x4058FFFFFDE7210Bu, 0x408F3FFFFD60E94Eu, 0x40C387FFFE5C91D1u, 0x40F869FFFDF3B645u,
        0x412E847FFD70A3D7u, 0x416312CFFE666666u, 0x4197D783FDFFFFFFu, 0x3F1A36E2EAE3F7A7u, 0x3F50624DD2CE7AC8u,
        0x3F847AE14782197Bu, 0x3FB9999999629FD9u, 0x3FEFFFFFFFBB47D0u, 0x4023FFFFFFD50CE2u, 0x4058FFFFFFCA501Au,
        0x408F3FFFFFBCE421u, 0x40C387FFFFD60E94u, 0x40F869FFFFCB923Au, 0x412E847FFFBE76C8u, 0x416312CFFFD70A3Du,
        0x4197D783FFCCCCCCu, 0x41CDCD64FFBFFFFFu, 0x3F1A36E2EB16A205u, 0x3F50624DD2EE2543u, 0x3F847AE147A9AE94u,
        0x3FB9999999941A39u, 0x3FEFFFFFFFF920C8u, 0x4023FFFFFFFBB47Du, 0x4058FFFFFFFAA19Cu, 0x408F3FFFFFF94A03u,
        0x40C387FFFFFBCE42u, 0x40F869FFFFFAC1D2u, 0x412E847FFFF97247u, 0x416312CFFFFBE76Cu, 0x4197D783FFFAE147u,
        0x41CDCD64FFF99999u, 0x4202A05F1FFBFFFFu, 0x3F1A36E2EB1BB30Fu, 0x3F50624DD2F14FE9u, 0x3F847AE147ADA3E3u,
        0x3FB9999999990CDCu, 0x3FEFFFFFFFFF5014u, 0x4023FFFFFFFF920Cu, 0x4058FFFFFFFF768Fu, 0x408F3FFFFFFF5433u,
        0x40C387FFFFFF94A0u, 0x40F869FFFFFF79C8u, 0x412E847FFFFF583Au, 0x416312CFFFFF9724u, 0x4197D783FFFF7CEDu,
        0x41CDCD64FFFF5C28u, 0x4202A05F1FFF9999u, 0x42374876E7FF7FFFu, 0x3F1A36E2EB1C34C3u, 0x3F50624DD2F1A0FAu,
        0x3F847AE147AE0938u, 0x3FB9999999998B86u, 0x3FEFFFFFFFFFEE68u, 0x4023FFFFFFFFF501u, 0x4058FFFFFFFFF241u,
        0x408F3FFFFFFFEED1u, 0x40C387FFFFFFF543u, 0x40F869FFFFFFF294u, 0x412E847FFFFFEF39u, 0x416312CFFFFFF583u,
        0x4197D783FFFFF2E4u, 0x41CDCD64FFFFEF9Du, 0x4202A05F1FFFF5C2u, 0x42374876E7FFF333u, 0x426D1A94A1FFEFFFu,
        0x3F1A36E2EB1C41BBu, 0x3F50624DD2F1A915u, 0x3F847AE147AE135Au, 0x3FB9999999999831u, 0x3FEFFFFFFFFFFE3Du,
        0x4023FFFFFFFFFEE6u, 0x4058FFFFFFFFFEA0u, 0x408F3FFFFFFFFE48u, 0x40C387FFFFFFFEEDu, 0x40F869FFFFFFFEA8u,
        0x412E847FFFFFFE52u, 0x416312CFFFFFFEF3u, 0x4197D783FFFFFEB0u, 0x41CDCD64FFFFFE5Cu, 0x4202A05F1FFFFEF9u,
        0x42374876E7FFFEB8u, 0x426D1A94A1FFFE66u, 0x42A2309CE53FFEFFu, 0x3F1A36E2EB1C4307u, 0x3F50624DD2F1A9E4u,
        0x3F847AE147AE145Eu, 0x3FB9999999999975u, 0x3FEFFFFFFFFFFFD2u, 0x4023FFFFFFFFFFE3u, 0x4058FFFFFFFFFFDCu,
        0x408F3FFFFFFFFFD4u, 0x40C387FFFFFFFFE4u, 0x40F869FFFFFFFFDDu, 0x412E847FFFFFFFD5u, 0x416312CFFFFFFFE5u,
        0x4197D783FFFFFFDEu, 0x41CDCD64FFFFFFD6u, 0x4202A05F1FFFFFE5u, 0x42374876E7FFFFDFu, 0x426D1A94A1FFFFD7u,
        0x42A2309CE53FFFE6u, 0x42D6BCC41E8FFFDFu, 0x3F1A36E2EB1C4328u, 0x3F50624DD2F1A9F9u, 0x3F847AE147AE1477u,
        0x3FB9999999999995u, 0x3FEFFFFFFFFFFFFBu, 0x4023FFFFFFFFFFFDu, 0x4058FFFFFFFFFFFCu, 0x408F3FFFFFFFFFFBu,
        0x40C387FFFFFFFFFDu, 0x40F869FFFFFFFFFCu, 0x412E847FFFFFFFFBu, 0x416312CFFFFFFFFDu, 0x4197D783FFFFFFFCu,
        0x41CDCD64FFFFFFFBu, 0x4202A05F1FFFFFFDu, 0x42374876E7FFFFFCu, 0x426D1A94A1FFFFFBu, 0x42A2309CE53FFFFDu,
        0x42D6BCC41E8FFFFCu, 0x430C6BF52633FFFBu};

    static constexpr int _Max_P = 309;

    static constexpr uint64_t _Ordinary_X_table[314] = {0x3F1A36E2EB1C432Cu, 0x3F50624DD2F1A9FBu, 0x3F847AE147AE147Au,
        0x3FB9999999999999u, 0x3FEFFFFFFFFFFFFFu, 0x4023FFFFFFFFFFFFu, 0x4058FFFFFFFFFFFFu, 0x408F3FFFFFFFFFFFu,
        0x40C387FFFFFFFFFFu, 0x40F869FFFFFFFFFFu, 0x412E847FFFFFFFFFu, 0x416312CFFFFFFFFFu, 0x4197D783FFFFFFFFu,
        0x41CDCD64FFFFFFFFu, 0x4202A05F1FFFFFFFu, 0x42374876E7FFFFFFu, 0x426D1A94A1FFFFFFu, 0x42A2309CE53FFFFFu,
        0x42D6BCC41E8FFFFFu, 0x430C6BF52633FFFFu, 0x4341C37937E07FFFu, 0x4376345785D89FFFu, 0x43ABC16D674EC7FFu,
        0x43E158E460913CFFu, 0x4415AF1D78B58C3Fu, 0x444B1AE4D6E2EF4Fu, 0x4480F0CF064DD591u, 0x44B52D02C7E14AF6u,
        0x44EA784379D99DB4u, 0x45208B2A2C280290u, 0x4554ADF4B7320334u, 0x4589D971E4FE8401u, 0x45C027E72F1F1281u,
        0x45F431E0FAE6D721u, 0x46293E5939A08CE9u, 0x465F8DEF8808B024u, 0x4693B8B5B5056E16u, 0x46C8A6E32246C99Cu,
        0x46FED09BEAD87C03u, 0x4733426172C74D82u, 0x476812F9CF7920E2u, 0x479E17B84357691Bu, 0x47D2CED32A16A1B1u,
        0x48078287F49C4A1Du, 0x483D6329F1C35CA4u, 0x48725DFA371A19E6u, 0x48A6F578C4E0A060u, 0x48DCB2D6F618C878u,
        0x4911EFC659CF7D4Bu, 0x49466BB7F0435C9Eu, 0x497C06A5EC5433C6u, 0x49B18427B3B4A05Bu, 0x49E5E531A0A1C872u,
        0x4A1B5E7E08CA3A8Fu, 0x4A511B0EC57E6499u, 0x4A8561D276DDFDC0u, 0x4ABABA4714957D30u, 0x4AF0B46C6CDD6E3Eu,
        0x4B24E1878814C9CDu, 0x4B5A19E96A19FC40u, 0x4B905031E2503DA8u, 0x4BC4643E5AE44D12u, 0x4BF97D4DF19D6057u,
        0x4C2FDCA16E04B86Du, 0x4C63E9E4E4C2F344u, 0x4C98E45E1DF3B015u, 0x4CCF1D75A5709C1Au, 0x4D03726987666190u,
        0x4D384F03E93FF9F4u, 0x4D6E62C4E38FF872u, 0x4DA2FDBB0E39FB47u, 0x4DD7BD29D1C87A19u, 0x4E0DAC74463A989Fu,
        0x4E428BC8ABE49F63u, 0x4E772EBAD6DDC73Cu, 0x4EACFA698C95390Bu, 0x4EE21C81F7DD43A7u, 0x4F16A3A275D49491u,
        0x4F4C4C8B1349B9B5u, 0x4F81AFD6EC0E1411u, 0x4FB61BCCA7119915u, 0x4FEBA2BFD0D5FF5Bu, 0x502145B7E285BF98u,
        0x50559725DB272F7Fu, 0x508AFCEF51F0FB5Eu, 0x50C0DE1593369D1Bu, 0x50F5159AF8044462u, 0x512A5B01B605557Au,
        0x516078E111C3556Cu, 0x5194971956342AC7u, 0x51C9BCDFABC13579u, 0x5200160BCB58C16Cu, 0x52341B8EBE2EF1C7u,
        0x526922726DBAAE39u, 0x529F6B0F092959C7u, 0x52D3A2E965B9D81Cu, 0x53088BA3BF284E23u, 0x533EAE8CAEF261ACu,
        0x53732D17ED577D0Bu, 0x53A7F85DE8AD5C4Eu, 0x53DDF67562D8B362u, 0x5412BA095DC7701Du, 0x5447688BB5394C25u,
        0x547D42AEA2879F2Eu, 0x54B249AD2594C37Cu, 0x54E6DC186EF9F45Cu, 0x551C931E8AB87173u, 0x5551DBF316B346E7u,
        0x558652EFDC6018A1u, 0x55BBE7ABD3781ECAu, 0x55F170CB642B133Eu, 0x5625CCFE3D35D80Eu, 0x565B403DCC834E11u,
        0x569108269FD210CBu, 0x56C54A3047C694FDu, 0x56FA9CBC59B83A3Du, 0x5730A1F5B8132466u, 0x5764CA732617ED7Fu,
        0x5799FD0FEF9DE8DFu, 0x57D03E29F5C2B18Bu, 0x58044DB473335DEEu, 0x583961219000356Au, 0x586FB969F40042C5u,
        0x58A3D3E2388029BBu, 0x58D8C8DAC6A0342Au, 0x590EFB1178484134u, 0x59435CEAEB2D28C0u, 0x59783425A5F872F1u,
        0x59AE412F0F768FADu, 0x59E2E8BD69AA19CCu, 0x5A17A2ECC414A03Fu, 0x5A4D8BA7F519C84Fu, 0x5A827748F9301D31u,
        0x5AB7151B377C247Eu, 0x5AECDA62055B2D9Du, 0x5B22087D4358FC82u, 0x5B568A9C942F3BA3u, 0x5B8C2D43B93B0A8Bu,
        0x5BC19C4A53C4E697u, 0x5BF6035CE8B6203Du, 0x5C2B843422E3A84Cu, 0x5C6132A095CE492Fu, 0x5C957F48BB41DB7Bu,
        0x5CCADF1AEA12525Au, 0x5D00CB70D24B7378u, 0x5D34FE4D06DE5056u, 0x5D6A3DE04895E46Cu, 0x5DA066AC2D5DAEC3u,
        0x5DD4805738B51A74u, 0x5E09A06D06E26112u, 0x5E400444244D7CABu, 0x5E7405552D60DBD6u, 0x5EA906AA78B912CBu,
        0x5EDF485516E7577Eu, 0x5F138D352E5096AFu, 0x5F48708279E4BC5Au, 0x5F7E8CA3185DEB71u, 0x5FB317E5EF3AB327u,
        0x5FE7DDDF6B095FF0u, 0x601DD55745CBB7ECu, 0x6052A5568B9F52F4u, 0x60874EAC2E8727B1u, 0x60BD22573A28F19Du,
        0x60F2357684599702u, 0x6126C2D4256FFCC2u, 0x615C73892ECBFBF3u, 0x6191C835BD3F7D78u, 0x61C63A432C8F5CD6u,
        0x61FBC8D3F7B3340Bu, 0x62315D847AD00087u, 0x6265B4E5998400A9u, 0x629B221EFFE500D3u, 0x62D0F5535FEF2084u,
        0x630532A837EAE8A5u, 0x633A7F5245E5A2CEu, 0x63708F936BAF85C1u, 0x63A4B378469B6731u, 0x63D9E056584240FDu,
        0x64102C35F729689Eu, 0x6444374374F3C2C6u, 0x647945145230B377u, 0x64AF965966BCE055u, 0x64E3BDF7E0360C35u,
        0x6518AD75D8438F43u, 0x654ED8D34E547313u, 0x6583478410F4C7ECu, 0x65B819651531F9E7u, 0x65EE1FBE5A7E7861u,
        0x6622D3D6F88F0B3Cu, 0x665788CCB6B2CE0Cu, 0x668D6AFFE45F818Fu, 0x66C262DFEEBBB0F9u, 0x66F6FB97EA6A9D37u,
        0x672CBA7DE5054485u, 0x6761F48EAF234AD3u, 0x679671B25AEC1D88u, 0x67CC0E1EF1A724EAu, 0x680188D357087712u,
        0x6835EB082CCA94D7u, 0x686B65CA37FD3A0Du, 0x68A11F9E62FE4448u, 0x68D56785FBBDD55Au, 0x690AC1677AAD4AB0u,
        0x6940B8E0ACAC4EAEu, 0x6974E718D7D7625Au, 0x69AA20DF0DCD3AF0u, 0x69E0548B68A044D6u, 0x6A1469AE42C8560Cu,
        0x6A498419D37A6B8Fu, 0x6A7FE52048590672u, 0x6AB3EF342D37A407u, 0x6AE8EB0138858D09u, 0x6B1F25C186A6F04Cu,
        0x6B537798F428562Fu, 0x6B88557F31326BBBu, 0x6BBE6ADEFD7F06AAu, 0x6BF302CB5E6F642Au, 0x6C27C37E360B3D35u,
        0x6C5DB45DC38E0C82u, 0x6C9290BA9A38C7D1u, 0x6CC734E940C6F9C5u, 0x6CFD022390F8B837u, 0x6D3221563A9B7322u,
        0x6D66A9ABC9424FEBu, 0x6D9C5416BB92E3E6u, 0x6DD1B48E353BCE6Fu, 0x6E0621B1C28AC20Bu, 0x6E3BAA1E332D728Eu,
        0x6E714A52DFFC6799u, 0x6EA59CE797FB817Fu, 0x6EDB04217DFA61DFu, 0x6F10E294EEBC7D2Bu, 0x6F451B3A2A6B9C76u,
        0x6F7A6208B5068394u, 0x6FB07D457124123Cu, 0x6FE49C96CD6D16CBu, 0x7019C3BC80C85C7Eu, 0x70501A55D07D39CFu,
        0x708420EB449C8842u, 0x70B9292615C3AA53u, 0x70EF736F9B3494E8u, 0x7123A825C100DD11u, 0x7158922F31411455u,
        0x718EB6BAFD91596Bu, 0x71C33234DE7AD7E2u, 0x71F7FEC216198DDBu, 0x722DFE729B9FF152u, 0x7262BF07A143F6D3u,
        0x72976EC98994F488u, 0x72CD4A7BEBFA31AAu, 0x73024E8D737C5F0Au, 0x7336E230D05B76CDu, 0x736C9ABD04725480u,
        0x73A1E0B622C774D0u, 0x73D658E3AB795204u, 0x740BEF1C9657A685u, 0x74417571DDF6C813u, 0x7475D2CE55747A18u,
        0x74AB4781EAD1989Eu, 0x74E10CB132C2FF63u, 0x75154FDD7F73BF3Bu, 0x754AA3D4DF50AF0Au, 0x7580A6650B926D66u,
        0x75B4CFFE4E7708C0u, 0x75EA03FDE214CAF0u, 0x7620427EAD4CFED6u, 0x7654531E58A03E8Bu, 0x768967E5EEC84E2Eu,
        0x76BFC1DF6A7A61BAu, 0x76F3D92BA28C7D14u, 0x7728CF768B2F9C59u, 0x775F03542DFB8370u, 0x779362149CBD3226u,
        0x77C83A99C3EC7EAFu, 0x77FE494034E79E5Bu, 0x7832EDC82110C2F9u, 0x7867A93A2954F3B7u, 0x789D9388B3AA30A5u,
        0x78D27C35704A5E67u, 0x79071B42CC5CF601u, 0x793CE2137F743381u, 0x79720D4C2FA8A030u, 0x79A6909F3B92C83Du,
        0x79DC34C70A777A4Cu, 0x7A11A0FC668AAC6Fu, 0x7A46093B802D578Bu, 0x7A7B8B8A6038AD6Eu, 0x7AB137367C236C65u,
        0x7AE585041B2C477Eu, 0x7B1AE64521F7595Eu, 0x7B50CFEB353A97DAu, 0x7B8503E602893DD1u, 0x7BBA44DF832B8D45u,
        0x7BF06B0BB1FB384Bu, 0x7C2485CE9E7A065Eu, 0x7C59A742461887F6u, 0x7C9008896BCF54F9u, 0x7CC40AABC6C32A38u,
        0x7CF90D56B873F4C6u, 0x7D2F50AC6690F1F8u, 0x7D63926BC01A973Bu, 0x7D987706B0213D09u, 0x7DCE94C85C298C4Cu,
        0x7E031CFD3999F7AFu, 0x7E37E43C8800759Bu, 0x7E6DDD4BAA009302u, 0x7EA2AA4F4A405BE1u, 0x7ED754E31CD072D9u,
        0x7F0D2A1BE4048F90u, 0x7F423A516E82D9BAu, 0x7F76C8E5CA239028u, 0x7FAC7B1F3CAC7433u, 0x7FE1CCF385EBC89Fu,
        0x7FEFFFFFFFFFFFFFu};
};

template <class _Floating>
[[nodiscard]] inline to_chars_result _Floating_to_chars_general_precision(
    char* _First, char* const _Last, const _Floating _Value, int _Precision) noexcept {

    using _Traits    = _Floating_type_traits<_Floating>;
    using _Uint_type = typename _Traits::_Uint_type;

    const _Uint_type _Uint_value = _Bit_cast<_Uint_type>(_Value);

    if (_Uint_value == 0) { 
        if (_First == _Last) {
            return {_Last, errc::value_too_large};
        }

        *_First++ = '0';

        return {_First, errc{}};
    }

    
    if (_Precision < 0) {
        _Precision = 6;
    } else if (_Precision == 0) {
        _Precision = 1;
    } else if (_Precision < 1'000'000) {
        
    } else {
        
        
        _Precision = 1'000'000;
    }

    
    using _Tables = _General_precision_tables<_Floating>;

    const _Uint_type* _Table_begin;
    const _Uint_type* _Table_end;

    if (_Precision <= _Tables::_Max_special_P) {
        _Table_begin = _Tables::_Special_X_table + (_Precision - 1) * (_Precision + 10) / 2;
        _Table_end   = _Table_begin + _Precision + 5;
    } else {
        _Table_begin = _Tables::_Ordinary_X_table;
        _Table_end   = _Table_begin + (::std:: min)(_Precision, _Tables::_Max_P) + 5;
    }

    
    const _Uint_type* const _Table_lower_bound = [=] {
        if constexpr (!is_same_v<_Floating, float>) {
            if (_Precision > 155) { 
                return ::std:: lower_bound(_Table_begin, _Table_end, _Uint_value, less{});
            }
        }

        return ::std:: find_if(_Table_begin, _Table_end, [=](const _Uint_type _Elem) { return _Uint_value <= _Elem; });
    }();

    const ptrdiff_t _Table_index     = _Table_lower_bound - _Table_begin;
    const int _Scientific_exponent_X = static_cast<int>(_Table_index - 5);
    const bool _Use_fixed_notation   = _Precision > _Scientific_exponent_X && _Scientific_exponent_X >= -4;

    
    constexpr int _Max_output_length =
        is_same_v<_Floating, float> ? 117 : 773; 
    constexpr int _Max_fixed_precision =
        is_same_v<_Floating, float> ? 37 : 66; 
    constexpr int _Max_scientific_precision =
        is_same_v<_Floating, float> ? 111 : 766; 

    
    char _Buffer[_Max_output_length];
    const char* const _Significand_first = _Buffer; 
    const char* _Significand_last        = nullptr;
    const char* _Exponent_first          = nullptr; 
    const char* _Exponent_last           = nullptr;
    int _Effective_precision; 

    
    if (_Use_fixed_notation) {
        _Effective_precision = (::std:: min)(_Precision - (_Scientific_exponent_X + 1), _Max_fixed_precision);
        const to_chars_result _Buf_result =
            _Floating_to_chars_fixed_precision(_Buffer, ::std:: end(_Buffer), _Value, _Effective_precision);
        ;
        _Significand_last = _Buf_result.ptr;
    } else {
        _Effective_precision = (::std:: min)(_Precision - 1, _Max_scientific_precision);
        const to_chars_result _Buf_result =
            _Floating_to_chars_scientific_precision(_Buffer, ::std:: end(_Buffer), _Value, _Effective_precision);
        ;
        _Significand_last = ::std:: find(_Buffer, _Buf_result.ptr, 'e');
        _Exponent_first   = _Significand_last;
        _Exponent_last    = _Buf_result.ptr;
    }

    
    if (_Effective_precision > 0) {
        while (_Significand_last[-1] == '0') { 
            --_Significand_last;
        }

        if (_Significand_last[-1] == '.') {
            --_Significand_last;
        }
    }

    
    const ptrdiff_t _Significand_distance = _Significand_last - _Significand_first;
    if (_Last - _First < _Significand_distance) {
        return {_Last, errc::value_too_large};
    }
    :: memcpy(_First, _Significand_first, static_cast<size_t>(_Significand_distance));
    _First += _Significand_distance;

    
    if (!_Use_fixed_notation) {
        const ptrdiff_t _Exponent_distance = _Exponent_last - _Exponent_first;
        if (_Last - _First < _Exponent_distance) {
            return {_Last, errc::value_too_large};
        }
        :: memcpy(_First, _Exponent_first, static_cast<size_t>(_Exponent_distance));
        _First += _Exponent_distance;
    }

    return {_First, errc{}};
}

enum class _Floating_to_chars_overload { _Plain, _Format_only, _Format_precision };

template <_Floating_to_chars_overload _Overload, class _Floating>
[[nodiscard]] to_chars_result _Floating_to_chars(
    char* _First, char* const _Last, _Floating _Value, const chars_format _Fmt, const int _Precision) noexcept {
    _Adl_verify_range(_First, _Last);

    if constexpr (_Overload == _Floating_to_chars_overload::_Plain) {
        ; 
    } else {
        ;
#line 2930 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\charconv"
    }

    using _Traits    = _Floating_type_traits<_Floating>;
    using _Uint_type = typename _Traits::_Uint_type;

    _Uint_type _Uint_value = _Bit_cast<_Uint_type>(_Value);

    const bool _Was_negative = (_Uint_value & _Traits::_Shifted_sign_mask) != 0;

    if (_Was_negative) { 
        if (_First == _Last) {
            return {_Last, errc::value_too_large};
        }

        *_First++ = '-';

        _Uint_value &= ~_Traits::_Shifted_sign_mask;
        _Value = _Bit_cast<_Floating>(_Uint_value);
    }

    if ((_Uint_value & _Traits::_Shifted_exponent_mask) == _Traits::_Shifted_exponent_mask) {
        
        const char* _Str;
        size_t _Len;

        const _Uint_type _Mantissa = _Uint_value & _Traits::_Denormal_mantissa_mask;

        if (_Mantissa == 0) {
            _Str = "inf";
            _Len = 3;
        } else if (_Was_negative && _Mantissa == _Traits::_Special_nan_mantissa_mask) {
            
            
            _Str = "nan(ind)";
            _Len = 8;
        } else if ((_Mantissa & _Traits::_Special_nan_mantissa_mask) != 0) {
            _Str = "nan";
            _Len = 3;
        } else {
            _Str = "nan(snan)";
            _Len = 9;
        }

        if (_Last - _First < static_cast<ptrdiff_t>(_Len)) {
            return {_Last, errc::value_too_large};
        }

        :: memcpy(_First, _Str, _Len);

        return {_First + _Len, errc{}};
    }

    if constexpr (_Overload == _Floating_to_chars_overload::_Plain) {
        return _Floating_to_chars_ryu(_First, _Last, _Value, chars_format{});
    } else if constexpr (_Overload == _Floating_to_chars_overload::_Format_only) {
        if (_Fmt == chars_format::hex) {
            return _Floating_to_chars_hex_shortest(_First, _Last, _Value);
        }

        return _Floating_to_chars_ryu(_First, _Last, _Value, _Fmt);
    } else if constexpr (_Overload == _Floating_to_chars_overload::_Format_precision) {
        switch (_Fmt) {
        case chars_format::scientific:
            return _Floating_to_chars_scientific_precision(_First, _Last, _Value, _Precision);
        case chars_format::fixed:
            return _Floating_to_chars_fixed_precision(_First, _Last, _Value, _Precision);
        case chars_format::general:
            return _Floating_to_chars_general_precision(_First, _Last, _Value, _Precision);
        case chars_format::hex:
        default: 
            return _Floating_to_chars_hex_precision(_First, _Last, _Value, _Precision);
        }
    }
}

inline to_chars_result to_chars(char* const _First, char* const _Last, const float _Value) noexcept  {
    return _Floating_to_chars<_Floating_to_chars_overload::_Plain>(_First, _Last, _Value, chars_format{}, 0);
}
inline to_chars_result to_chars(char* const _First, char* const _Last, const double _Value) noexcept
 {
    return _Floating_to_chars<_Floating_to_chars_overload::_Plain>(_First, _Last, _Value, chars_format{}, 0);
}
inline to_chars_result to_chars(char* const _First, char* const _Last, const long double _Value) noexcept
 {
    return _Floating_to_chars<_Floating_to_chars_overload::_Plain>(
        _First, _Last, static_cast<double>(_Value), chars_format{}, 0);
}
inline to_chars_result to_chars(
    char* const _First, char* const _Last, const float _Value, const chars_format _Fmt) noexcept  {
    return _Floating_to_chars<_Floating_to_chars_overload::_Format_only>(_First, _Last, _Value, _Fmt, 0);
}
inline to_chars_result to_chars(
    char* const _First, char* const _Last, const double _Value, const chars_format _Fmt) noexcept  {
    return _Floating_to_chars<_Floating_to_chars_overload::_Format_only>(_First, _Last, _Value, _Fmt, 0);
}
inline to_chars_result to_chars(char* const _First, char* const _Last, const long double _Value,
    const chars_format _Fmt) noexcept  {
    return _Floating_to_chars<_Floating_to_chars_overload::_Format_only>(
        _First, _Last, static_cast<double>(_Value), _Fmt, 0);
}
inline to_chars_result to_chars(char* const _First, char* const _Last, const float _Value, const chars_format _Fmt,
    const int _Precision) noexcept  {
    return _Floating_to_chars<_Floating_to_chars_overload::_Format_precision>(_First, _Last, _Value, _Fmt, _Precision);
}
inline to_chars_result to_chars(char* const _First, char* const _Last, const double _Value, const chars_format _Fmt,
    const int _Precision) noexcept  {
    return _Floating_to_chars<_Floating_to_chars_overload::_Format_precision>(_First, _Last, _Value, _Fmt, _Precision);
}
inline to_chars_result to_chars(char* const _First, char* const _Last, const long double _Value,
    const chars_format _Fmt, const int _Precision) noexcept  {
    return _Floating_to_chars<_Floating_to_chars_overload::_Format_precision>(
        _First, _Last, static_cast<double>(_Value), _Fmt, _Precision);
}

}


#pragma warning(pop)
#pragma pack(pop)
#line 3051 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\charconv"
#line 3052 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\charconv"
#line 3053 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\charconv"
#line 48 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\format"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\locale"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocbuf"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
__pragma(warning(push)) __pragma(warning(disable : 4996))
template <class _Codecvt, class _Elem = wchar_t, class _Traits = char_traits<_Elem>>
class [[deprecated( "warning STL4017: " "std::wbuffer_convert, std::wstring_convert, and the <codecvt> header (containing std::codecvt_mode, " "std::codecvt_utf8, std::codecvt_utf16, and std::codecvt_utf8_utf16) are deprecated in C++17. " "(The std::codecvt class template is NOT deprecated.) " "The C++ Standard doesn't provide equivalent non-deprecated functionality; " "consider using MultiByteToWideChar() and WideCharToMultiByte() from <Windows.h> instead. " "You can define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] wbuffer_convert
    : public basic_streambuf<_Elem, _Traits> { 
    enum _Mode { _Unused, _Wrote, _Need, _Got, _Eof };
    enum { _STRING_INC = 8 };

public:
    using _Mysb        = streambuf;
    using _Byte_traits = char_traits<char>;

    using int_type   = typename _Traits::int_type;
    using pos_type   = typename _Traits::pos_type;
    using off_type   = typename _Traits::off_type;
    using state_type = typename _Codecvt::state_type;

    wbuffer_convert() : _State(), _Pcvt(new _Codecvt), _Mystrbuf(nullptr), _Status(_Unused), _Nback(0) {
        
        _Loc = locale(_Loc, _Pcvt);
    }

    explicit wbuffer_convert(_Mysb* _Strbuf)
        : _State(), _Pcvt(new _Codecvt), _Mystrbuf(_Strbuf), _Status(_Unused), _Nback(0) {
        
        _Loc = locale(_Loc, _Pcvt);
    }

    wbuffer_convert(_Mysb* _Strbuf, const _Codecvt* _Pcvt_arg)
        : _State(), _Pcvt(_Pcvt_arg), _Mystrbuf(_Strbuf), _Status(_Unused), _Nback(0) {
        
        _Loc = locale(_Loc, _Pcvt);
    }

    wbuffer_convert(_Mysb* _Strbuf, const _Codecvt* _Pcvt_arg, state_type _State_arg)
        : _State(_State_arg), _Pcvt(_Pcvt_arg), _Mystrbuf(_Strbuf), _Status(_Unused), _Nback(0) {
        
        _Loc = locale(_Loc, _Pcvt);
    }

    ~wbuffer_convert() noexcept override {
        while (_Status == _Wrote) { 
            if (_Str.size() < _STRING_INC) {
                _Str.assign(_STRING_INC, '\0');
            }

            char* _Buf = &_Str[0];
            char* _Dest;
            switch (_Pcvt->unshift(_State, _Buf, _Buf + _Str.size(), _Dest)) { 
            case _Codecvt::ok:
                _Status = _Unused; 

            case _Codecvt::partial: 
                { 
                    ptrdiff_t _Count = _Dest - _Buf;
                    if (0 < _Count
                        && _Byte_traits::eq_int_type(
                            _Byte_traits::eof(), static_cast<_Byte_traits::int_type>(_Mystrbuf->sputn(_Buf, _Count)))) {
                        return; 
                    }

                    if (_Status == _Wrote && _Count == 0) {
                        _Str.append(_STRING_INC, '\0'); 
                    }

                    break;
                }

            case _Codecvt::noconv:
                return; 

            default:
                return; 
            }
        }
    }

    [[nodiscard]] _Mysb* rdbuf() const {
        return _Mystrbuf;
    }

    _Mysb* rdbuf(_Mysb* _Strbuf) { 
        _Mysb* _Oldstrbuf = _Mystrbuf;
        _Mystrbuf         = _Strbuf;
        return _Oldstrbuf;
    }

    [[nodiscard]] state_type state() const {
        return _State;
    }

    wbuffer_convert(const wbuffer_convert&) = delete;
    wbuffer_convert& operator=(const wbuffer_convert&) = delete;

protected:
    int_type overflow(int_type _Meta = _Traits::eof()) override { 
        if (_Traits::eq_int_type(_Traits::eof(), _Meta)) {
            return _Traits::not_eof(_Meta); 
        } else if (!_Mystrbuf || 0 < _Nback || (_Status != _Unused && _Status != _Wrote)) {
            return _Traits::eof(); 
        } else { 
            const _Elem _Ch = _Traits::to_char_type(_Meta);

            if (_Str.size() < _STRING_INC) {
                _Str.assign(_STRING_INC, '\0');
            }

            for (_Status = _Wrote;;) {
                char* _Buf = &_Str[0];
                const _Elem* _Src;
                char* _Dest;

                
                switch (_Pcvt->out(_State, &_Ch, &_Ch + 1, _Src, _Buf, _Buf + _Str.size(), _Dest)) {
                case _Codecvt::partial:
                case _Codecvt::ok:
                    { 
                        ptrdiff_t _Count = _Dest - _Buf;
                        if (0 < _Count
                            && _Byte_traits::eq_int_type(_Byte_traits::eof(),
                                static_cast<_Byte_traits::int_type>(_Mystrbuf->sputn(_Buf, _Count)))) {
                            return _Traits::eof(); 
                        }

                        if (_Src != &_Ch) {
                            return _Meta; 
                        }

                        if (0 >= _Count) {
                            if (_Str.size() >= 4 * _STRING_INC) {
                                return _Traits::eof(); 
                            }

                            _Str.append(_STRING_INC, '\0'); 
                        }

                        break;
                    }

                case _Codecvt::noconv:
                    if (_Traits::eq_int_type(
                            _Traits::eof(), static_cast<int_type>(_Mystrbuf->sputn(reinterpret_cast<const char*>(&_Ch),
                                                static_cast<streamsize>(sizeof(_Elem)))))) {
                        return _Traits::eof();
                    }

                    return _Meta; 

                default:
                    return _Traits::eof(); 
                }
            }
        }
    }

    int_type pbackfail(int_type _Meta = _Traits::eof()) override { 
        if (sizeof(_Myback) / sizeof(_Myback[0]) <= _Nback || _Status == _Wrote) {
            return _Traits::eof(); 
        } else { 
            if (!_Traits::eq_int_type(_Traits::eof(), _Meta)) {
                _Myback[_Nback] = _Traits::to_char_type(_Meta);
            }

            ++_Nback;
            if (_Status == _Unused) {
                _Status = _Got;
            }

            return _Meta;
        }
    }

    int_type underflow() override { 
        int_type _Meta;

        if (0 >= _Nback) {
            if (_Traits::eq_int_type(_Traits::eof(), _Meta = _Get_elem())) {
                return _Meta; 
            }

            _Myback[_Nback++] = _Traits::to_char_type(_Meta);
        }

        return _Traits::to_int_type(_Myback[_Nback - 1]);
    }

#pragma warning(push)
#pragma warning(disable : 6385) 
                                
    int_type uflow() override { 
        int_type _Meta;

        if (0 >= _Nback) {
            if (_Traits::eq_int_type(_Traits::eof(), _Meta = _Get_elem())) {
                return _Meta; 
            }

            _Myback[_Nback++] = _Traits::to_char_type(_Meta);
        }

        return _Traits::to_int_type(_Myback[--_Nback]);
    }
#pragma warning(pop)

    pos_type seekoff(off_type, ios_base::seekdir,
        ios_base::openmode = static_cast<ios_base::openmode>(ios_base::in | ios_base::out)) override {
        return pos_type(-1); 
    }

    pos_type seekpos(
        pos_type, ios_base::openmode = static_cast<ios_base::openmode>(ios_base::in | ios_base::out)) override {
        return pos_type(-1); 
    }

private:
    int_type _Get_elem() { 
        if (_Mystrbuf && _Status != _Wrote) { 
            if (_Status != _Eof) {
                if (_Str.empty()) {
                    _Status = _Need;
                } else {
                    _Status = _Got;
                }
            }

            while (_Status != _Eof) { 
                char* _Buf = &_Str[0];
                _Elem _Ch;
                _Elem* _Dest;
                const char* _Src;
                int _Meta;

                if (_Status == _Need) {
                    if (_Byte_traits::eq_int_type(_Byte_traits::eof(), _Meta = _Mystrbuf->sbumpc())) {
                        _Status = _Eof;
                    } else {
                        _Str.push_back(_Byte_traits::to_char_type(_Meta));
                    }
                }

                
                switch (_Pcvt->in(_State, _Buf, _Buf + _Str.size(), _Src, &_Ch, &_Ch + 1, _Dest)) {
                case _Codecvt::partial:
                case _Codecvt::ok:
                    _Str.erase(0, static_cast<size_t>(_Src - _Buf)); 
                    if (_Dest != &_Ch) {
                        return _Traits::to_int_type(_Ch);
                    }

                    break;

                case _Codecvt::noconv:
                    if (_Str.size() < sizeof(_Elem)) {
                        break; 
                    }

                    :: memcpy(&_Ch, _Buf, sizeof(_Elem)); 
                    _Str.erase(0, sizeof(_Elem));
                    return _Traits::to_int_type(_Ch); 

                default:
                    _Status = _Eof; 
                    break;
                }
            }
        }

        return _Traits::eof();
    }

    state_type _State; 
    const _Codecvt* _Pcvt; 
    _Mysb* _Mystrbuf; 
    _Mode _Status; 
    size_t _Nback; 
    _Elem _Myback[8]; 
    string _Str; 
    locale _Loc; 
};

template <class _Codecvt, class _Elem = wchar_t, class _Walloc = allocator<_Elem>, class _Balloc = allocator<char>>
class [[deprecated( "warning STL4017: " "std::wbuffer_convert, std::wstring_convert, and the <codecvt> header (containing std::codecvt_mode, " "std::codecvt_utf8, std::codecvt_utf16, and std::codecvt_utf8_utf16) are deprecated in C++17. " "(The std::codecvt class template is NOT deprecated.) " "The C++ Standard doesn't provide equivalent non-deprecated functionality; " "consider using MultiByteToWideChar() and WideCharToMultiByte() from <Windows.h> instead. " "You can define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] wstring_convert { 
    enum { _BUF_INC = 8, _BUF_MAX = 16 };
    void _Init(const _Codecvt* _Pcvt_arg = new _Codecvt) { 
        _State = state_type{};
        _Pcvt  = _Pcvt_arg;
        _Loc   = locale(_Loc, _Pcvt);
        _Nconv = 0;
    }

public:
    using byte_string = basic_string<char, char_traits<char>, _Balloc>;
    using wide_string = basic_string<_Elem, char_traits<_Elem>, _Walloc>;
    using state_type  = typename _Codecvt::state_type;
    using int_type    = typename wide_string::traits_type::int_type;

    wstring_convert() : _Has_state(false), _Has_berr(false), _Has_werr(false) { 
        _Init();
    }

    explicit wstring_convert(const _Codecvt* _Pcvt_arg)
        : _Has_state(false), _Has_berr(false), _Has_werr(false) { 
        _Init(_Pcvt_arg);
    }

    wstring_convert(const _Codecvt* _Pcvt_arg, state_type _State_arg)
        : _Has_state(true), _Has_berr(false), _Has_werr(false) { 
        _Init(_Pcvt_arg);
        _State = _State_arg;
    }

    explicit wstring_convert(const byte_string& _Berr_arg)
        : _Berr(_Berr_arg), _Has_state(false), _Has_berr(true), _Has_werr(false) { 
        _Init();
    }

    wstring_convert(const byte_string& _Berr_arg, const wide_string& _Werr_arg)
        : _Berr(_Berr_arg), _Werr(_Werr_arg), _Has_state(false), _Has_berr(true),
          _Has_werr(true) { 
        _Init();
    }

    virtual ~wstring_convert() noexcept {}

    [[nodiscard]] size_t converted() const noexcept { 
        return _Nconv;
    }

    [[nodiscard]] state_type state() const {
        return _State;
    }

    [[nodiscard]] wide_string from_bytes(char _Byte) { 
        return from_bytes(&_Byte, &_Byte + 1);
    }

    [[nodiscard]] wide_string from_bytes(const char* _Ptr) { 
        return from_bytes(_Ptr, _Ptr + :: strlen(_Ptr));
    }

    [[nodiscard]] wide_string from_bytes(const byte_string& _Bstr) { 
        const char* _Ptr = _Bstr.c_str();
        return from_bytes(_Ptr, _Ptr + _Bstr.size());
    }

    [[nodiscard]] wide_string from_bytes(
        const char* _First, const char* _Last) { 
        wide_string _Wbuf;
        wide_string _Wstr;
        const char* _First_sav = _First;

        if (!_Has_state) {
            _State = state_type{}; 
        }

        _Wbuf.append(_BUF_INC, _Elem{});
        for (_Nconv = 0; _First != _Last; _Nconv = static_cast<size_t>(_First - _First_sav)) {
            
            _Elem* _Dest = &_Wbuf[0];
            _Elem* _Dnext;

            
            switch (_Pcvt->in(_State, _First, _Last, _First, _Dest, _Dest + _Wbuf.size(), _Dnext)) {
            case _Codecvt::partial:
            case _Codecvt::ok:
                if (_Dest < _Dnext) {
                    _Wstr.append(_Dest, static_cast<size_t>(_Dnext - _Dest));
                } else if (_Wbuf.size() < _BUF_MAX) {
                    _Wbuf.append(_BUF_INC, _Elem{});
                } else if (_Has_werr) {
                    return _Werr;
                } else {
                    _Throw_range_error("bad conversion");
                }

                break;

            case _Codecvt::noconv:
                for (; _First != _Last; ++_First) {
                    _Wstr.push_back(static_cast<_Elem>(static_cast<unsigned char>(*_First)));
                }

                break; 

            default:
                if (_Has_werr) {
                    return _Werr;
                } else {
                    _Throw_range_error("bad conversion");
                }
            }
        }
        return _Wstr;
    }

    [[nodiscard]] byte_string to_bytes(_Elem _Char) { 
        return to_bytes(&_Char, &_Char + 1);
    }

    [[nodiscard]] byte_string to_bytes(const _Elem* _Wptr) { 
        const _Elem* _Next = _Wptr;
        while (*_Next != 0) {
            ++_Next;
        }

        return to_bytes(_Wptr, _Next);
    }

    [[nodiscard]] byte_string to_bytes(const wide_string& _Wstr) { 
        const _Elem* _Wptr = _Wstr.c_str();
        return to_bytes(_Wptr, _Wptr + _Wstr.size());
    }

    [[nodiscard]] byte_string to_bytes(
        const _Elem* _First, const _Elem* _Last) { 
        byte_string _Bbuf;
        byte_string _Bstr;
        const _Elem* _First_sav = _First;

        if (!_Has_state) {
            _State = state_type{}; 
        }

        _Bbuf.append(_BUF_INC, '\0');
        for (_Nconv = 0; _First != _Last; _Nconv = static_cast<size_t>(_First - _First_sav)) {
            
            char* _Dest = &_Bbuf[0];
            char* _Dnext;

            
            switch (_Pcvt->out(_State, _First, _Last, _First, _Dest, _Dest + _Bbuf.size(), _Dnext)) {
            case _Codecvt::partial:
            case _Codecvt::ok:
                if (_Dest < _Dnext) {
                    _Bstr.append(_Dest, static_cast<size_t>(_Dnext - _Dest));
                } else if (_Bbuf.size() < _BUF_MAX) {
                    _Bbuf.append(_BUF_INC, '\0');
                } else if (_Has_berr) {
                    return _Berr;
                } else {
                    _Throw_range_error("bad conversion");
                }

                break;

            case _Codecvt::noconv:
                for (; _First != _Last; ++_First) {
                    _Bstr.push_back(static_cast<char>(static_cast<int_type>(*_First)));
                }

                break; 

            default:
                if (_Has_berr) {
                    return _Berr;
                } else {
                    _Throw_range_error("bad conversion");
                }
            }
        }
        return _Bstr;
    }

    wstring_convert(const wstring_convert&) = delete;
    wstring_convert& operator=(const wstring_convert&) = delete;

private:
    const _Codecvt* _Pcvt; 
    locale _Loc; 
    byte_string _Berr;
    wide_string _Werr;
    state_type _State; 
    bool _Has_state;
    bool _Has_berr;
    bool _Has_werr;
    size_t _Nconv;
};
__pragma(warning(pop))
}


#pragma warning(pop)
#pragma pack(pop)
#line 504 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocbuf"
#line 505 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocbuf"
#line 12 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\locale"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocmes"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
struct messages_base : locale::facet { 
    using catalog = int;

    explicit messages_base(size_t _Refs = 0) : locale::facet(_Refs) {}
};

template <class _Elem>
class messages : public messages_base { 
public:
    static_assert(!0 || _Is_any_of_v<_Elem, char, wchar_t, unsigned short>,
        "Unsupported facet specialization; see N4800 27.3.1.1.1 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this diagnostic.");

    using char_type   = _Elem;
    using string_type = basic_string<_Elem, char_traits<_Elem>, allocator<_Elem>>;

    catalog open(const string& _Catname, const locale& _Loc) const { 
        return do_open(_Catname, _Loc);
    }

    string_type get(catalog _Catval, int _Set, int _Message,
        const string_type& _Dflt) const { 
        return do_get(_Catval, _Set, _Message, _Dflt);
    }

    void close(catalog _Catval) const { 
        do_close(_Catval);
    }

      static locale::id id; 

    explicit messages(size_t _Refs = 0) : messages_base(_Refs) { 
        { _Locinfo _Lobj;
        _Init(_Lobj);
        }
    }

    messages(const _Locinfo& _Lobj, size_t _Refs = 0) : messages_base(_Refs) {
        _Init(_Lobj);
    }

    static size_t _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
        
        if (_Ppf && !*_Ppf) {
            *_Ppf = new messages<_Elem>(_Locinfo(_Ploc->c_str()));
        }

        return 6;
    }

protected:
    messages(const char* _Locname, size_t _Refs = 0) : messages_base(_Refs) {
        { _Locinfo _Lobj(_Locname);
        _Init(_Lobj);
        }
    }

     ~messages() noexcept override {}

    void _Init(const _Locinfo&) {} 

    virtual catalog  do_open(const string&, const locale&) const { 
        return -1;
    }

    virtual string_type  do_get(catalog, int, int,
        const string_type& _Dflt) const { 
        return _Dflt;
    }

    virtual void  do_close(catalog) const {} 
};


template <class _Elem>
 locale::id messages<_Elem>::id;


template <class _Elem>
class messages_byname : public messages<_Elem> { 
public:
    static_assert(!0 || _Is_any_of_v<_Elem, char, wchar_t>, "Unsupported facet specialization; see N4800 27.3.1.1.1 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this diagnostic.");

    explicit messages_byname(const char* _Locname, size_t _Refs = 0)
        : messages<_Elem>(_Locname, _Refs) {} 

    explicit messages_byname(const string& _Str, size_t _Refs = 0)
        : messages<_Elem>(_Str.c_str(), _Refs) {} 

protected:
     ~messages_byname() noexcept override {}
};


#line 131 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocmes"
}


#pragma warning(pop)
#pragma pack(pop)
#line 137 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocmes"
#line 138 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocmes"
#line 13 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\locale"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocmon"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
struct money_base : locale::facet { 
    enum { 
        symbol = '$',
        sign   = '+',
        space  = ' ',
        value  = 'v',
        none   = 'x'
    };
    using part = int;

    struct pattern { 
        char field[4];
    };

    money_base(size_t _Refs = 0) : locale::facet(_Refs) {}
};

template <class _Elem>
class _Mpunct : public money_base { 
public:
    friend _Tidy_guard<_Mpunct>;

public:
    using char_type   = _Elem;
    using string_type = basic_string<_Elem, char_traits<_Elem>, allocator<_Elem>>;

    _Elem decimal_point() const {
        return do_decimal_point();
    }

    _Elem thousands_sep() const {
        return do_thousands_sep();
    }

    string grouping() const {
        return do_grouping();
    }

    string_type curr_symbol() const {
        return do_curr_symbol();
    }

    string_type positive_sign() const {
        return do_positive_sign();
    }

    string_type negative_sign() const {
        return do_negative_sign();
    }

    int frac_digits() const {
        return do_frac_digits();
    }

    pattern pos_format() const {
        return do_pos_format();
    }

    pattern neg_format() const {
        return do_neg_format();
    }

    explicit _Mpunct(size_t _Refs, bool _Intl)
        : money_base(_Refs), _International(_Intl) { 
        { _Locinfo _Lobj;
        _Init(_Lobj);
        }
    }

    _Mpunct(const _Locinfo& _Lobj, size_t _Refs, bool _Intl, bool _Isdef = false)
        : money_base(_Refs), _International(_Intl) {
        _Init(_Lobj, _Isdef);
    }

protected:
    _Mpunct(const char* _Locname, size_t _Refs, bool _Intl, bool _Isdef = false)
        : money_base(_Refs), _International(_Intl) {
        { _Locinfo _Lobj(_Locname);
        _Init(_Lobj, _Isdef);
        }
    }

     ~_Mpunct() noexcept override {
        _Tidy();
    }

    template <class _Elem2>
    void _Getvals(_Elem2, const lconv* _Ptr) { 
        _Currencysign = _Maklocstr(
            _International ? _Ptr->int_curr_symbol : _Ptr->currency_symbol, static_cast<_Elem2*>(nullptr), _Cvt);
        _Plussign = _Maklocstr(4 < static_cast<unsigned int>(_Ptr->p_sign_posn) ? "" : _Ptr->positive_sign,
            static_cast<_Elem2*>(nullptr), _Cvt);
        _Minussign = _Maklocstr(4 < static_cast<unsigned int>(_Ptr->n_sign_posn) ? "-" : _Ptr->negative_sign,
            static_cast<_Elem2*>(nullptr), _Cvt);
        _Decimalpoint = _Maklocchr(_Ptr->mon_decimal_point[0], static_cast<_Elem2*>(nullptr), _Cvt);
        _Kseparator   = _Maklocchr(_Ptr->mon_thousands_sep[0], static_cast<_Elem2*>(nullptr), _Cvt);
    }

    void _Getvals(wchar_t, const lconv* _Ptr) { 
        _Currencysign = reinterpret_cast<const _Elem*>(
            _Maklocwcs(_International ? _Ptr->_W_int_curr_symbol : _Ptr->_W_currency_symbol));
        _Plussign = reinterpret_cast<const _Elem*>(
            _Maklocwcs(4 < static_cast<unsigned int>(_Ptr->p_sign_posn) ? L"" : _Ptr->_W_positive_sign));
        _Minussign = reinterpret_cast<const _Elem*>(
            _Maklocwcs(4 < static_cast<unsigned int>(_Ptr->n_sign_posn) ? L"-" : _Ptr->_W_negative_sign));
        _Decimalpoint = static_cast<_Elem>(_Ptr->_W_mon_decimal_point[0]);
        _Kseparator   = static_cast<_Elem>(_Ptr->_W_mon_thousands_sep[0]);
    }

    void _Init(const _Locinfo& _Lobj, bool _Isdef = false) { 
        _Cvt              = _Lobj._Getcvt();
        const lconv* _Ptr = _Lobj._Getlconv();

        _Grouping     = nullptr;
        _Currencysign = nullptr;
        _Plussign     = nullptr;
        _Minussign    = nullptr;

        _Tidy_guard<_Mpunct> _Guard{this};
        _Grouping = _Maklocstr(_Ptr->mon_grouping, static_cast<char*>(nullptr), _Cvt);
        _Getvals(_Elem{}, _Ptr);
        _Guard._Target = nullptr;

        _Fracdigits = _International ? _Ptr->int_frac_digits : _Ptr->frac_digits;
        if (_Fracdigits < 0 || 127 <= _Fracdigits) {
            _Fracdigits = 0;
        }

        _Makpat(_Plusformat, static_cast<unsigned int>(_Ptr->p_sep_by_space),
            static_cast<unsigned int>(_Ptr->p_cs_precedes), static_cast<unsigned int>(_Ptr->p_sign_posn));
        _Makpat(_Minusformat, static_cast<unsigned int>(_Ptr->n_sep_by_space),
            static_cast<unsigned int>(_Ptr->n_cs_precedes), static_cast<unsigned int>(_Ptr->n_sign_posn));

        if (_Isdef) { 
            :: memcpy(&_Plusformat, "$+xv", 4);
            :: memcpy(&_Minusformat, "$+xv", 4);
        }
    }

    virtual _Elem  do_decimal_point() const {
        return _Decimalpoint;
    }

    virtual _Elem  do_thousands_sep() const {
        return _Kseparator;
    }

    virtual string  do_grouping() const {
        return string(_Grouping);
    }

    virtual string_type  do_curr_symbol() const {
        return string_type(_Currencysign);
    }

    virtual string_type  do_positive_sign() const {
        return string_type(_Plussign);
    }

    virtual string_type  do_negative_sign() const {
        return string_type(_Minussign);
    }

    virtual int  do_frac_digits() const {
        return _Fracdigits;
    }

    virtual pattern  do_pos_format() const {
        return _Plusformat;
    }

    virtual pattern  do_neg_format() const {
        return _Minusformat;
    }

private:
    void _Makpat(pattern& _Pattern, unsigned int _Sepbyspace, unsigned int _Symbolprecedes,
        unsigned int _Signposition) { 

        const char* _Ptr;

        if (_International || 2 < _Sepbyspace || 1 < _Symbolprecedes || 4 < _Signposition) {
            
            _Ptr = "$+xv";
        } else {
            
            _Ptr =
                "+v$x" "+v$x" "v$+x" "v+$x" "v$+x"
                "+$vx" "+$vx" "$v+x" "+$vx" "$+vx"
                "+v $" "+v $" "v $+" "v +$" "v $+"
                "+$ v" "+$ v" "$ v+" "+$ v" "$+ v"
                "+xv$" "+ v$" "v$ +" "v+ $" "v$ +"
                "+x$v" "+ $v" "$v +" "+ $v" "$ +v";
            
            _Ptr += _Signposition * 4 
                  + _Symbolprecedes * 20 
                  + _Sepbyspace * 40; 
        }

        :: memcpy(_Pattern.field, _Ptr, sizeof(_Pattern.field));
    }

    void _Tidy() noexcept { 
        :: free(const_cast<char*>(_Grouping));
        :: free(const_cast<_Elem*>(_Currencysign));
        :: free(const_cast<_Elem*>(_Plussign));
        :: free(const_cast<_Elem*>(_Minussign));
    }

    const char* _Grouping; 
    _Elem _Decimalpoint; 
    _Elem _Kseparator; 
    const _Elem* _Currencysign; 
    const _Elem* _Plussign; 
    const _Elem* _Minussign; 
    int _Fracdigits; 
    pattern _Plusformat; 
    pattern _Minusformat; 
    bool _International; 

    _Locinfo::_Cvtvec _Cvt; 
};

template <class _Elem, bool _Intl = false>
class moneypunct : public _Mpunct<_Elem> { 
public:
    static_assert(!0 || _Is_any_of_v<_Elem, char, wchar_t, unsigned short>,
        "Unsupported facet specialization; see N4800 27.3.1.1.1 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this diagnostic.");

      static const bool intl; 
      static locale::id id; 

    explicit moneypunct(size_t _Refs = 0) : _Mpunct<_Elem>(_Refs, _Intl) {} 

    moneypunct(const _Locinfo& _Lobj, size_t _Refs = 0, bool _Isdef = false)
        : _Mpunct<_Elem>(_Lobj, _Refs, _Intl, _Isdef) {}

    static size_t _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
        
        if (_Ppf && !*_Ppf) {
            *_Ppf = new moneypunct<_Elem, _Intl>(_Locinfo(_Ploc->c_str()), 0, true);
        }

        return 3;
    }

protected:
    moneypunct(const char* _Locname, size_t _Refs = 0) : _Mpunct<_Elem>(_Locname, _Refs, _Intl) {}

     ~moneypunct() noexcept override {}
};


template <class _Elem, bool _Intl>
 const bool moneypunct<_Elem, _Intl>::intl = _Intl;

template <class _Elem, bool _Intl>
 locale::id moneypunct<_Elem, _Intl>::id;


template <class _Elem, bool _Intl = false>
class moneypunct_byname : public moneypunct<_Elem, _Intl> { 
public:
    static_assert(!0 || _Is_any_of_v<_Elem, char, wchar_t>, "Unsupported facet specialization; see N4800 27.3.1.1.1 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this diagnostic.");

    explicit moneypunct_byname(const char* _Locname, size_t _Refs = 0)
        : moneypunct<_Elem, _Intl>(_Locname, _Refs) {} 

    explicit moneypunct_byname(const string& _Str, size_t _Refs = 0)
        : moneypunct<_Elem, _Intl>(_Str.c_str(), _Refs) {} 

protected:
     ~moneypunct_byname() noexcept override {}
};

template <class _Elem, class _InIt = istreambuf_iterator<_Elem, char_traits<_Elem>>>
class money_get : public locale::facet { 
    using _Mypunct0 = moneypunct<_Elem, false>;
    using _Mypunct1 = moneypunct<_Elem, true>;

public:
    static_assert(!0 || _Is_any_of_v<_Elem, char, wchar_t, unsigned short>,
        "Unsupported facet specialization; see N4800 27.3.1.1.1 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this diagnostic.");

    using char_type   = _Elem;
    using iter_type   = _InIt;
    using string_type = basic_string<_Elem, char_traits<_Elem>, allocator<_Elem>>;

    _InIt get(_InIt _First, _InIt _Last, bool _Intl, ios_base& _Iosbase, ios_base::iostate& _State,
        long double& _Val) const { 
        return do_get(_First, _Last, _Intl, _Iosbase, _State, _Val);
    }

    _InIt get(_InIt _First, _InIt _Last, bool _Intl, ios_base& _Iosbase, ios_base::iostate& _State,
        string_type& _Val) const { 
        return do_get(_First, _Last, _Intl, _Iosbase, _State, _Val);
    }

      static locale::id id; 

    explicit money_get(size_t _Refs = 0) : locale::facet(_Refs) { 
        { _Locinfo _Lobj;
        _Init(_Lobj);
        }
    }

    money_get(const _Locinfo& _Lobj, size_t _Refs = 0) : locale::facet(_Refs) {
        _Init(_Lobj);
    }

    static size_t _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
        
        if (_Ppf && !*_Ppf) {
            *_Ppf = new money_get<_Elem, _InIt>(_Locinfo(_Ploc->c_str()));
        }

        return 3;
    }

protected:
     ~money_get() noexcept override {}

    void _Init(const _Locinfo&) {} 

    virtual _InIt  do_get(_InIt _First, _InIt _Last, bool _Intl, ios_base& _Iosbase,
        ios_base::iostate& _State,
        long double& _Val) const { 
        _Elem _Atoms[sizeof("0123456789-")];
        string _Str = _Getmfld(_First, _Last, _Intl, _Iosbase, _Atoms);

        if (_First == _Last) {
            _State |= ios_base::eofbit;
        }

        if (_Str.empty()) {
            _State |= ios_base::failbit; 
        } else { 
            const char* _Eb = _Str.c_str();
            char* _Ep;
            int _Errno             = 0;
            const long double _Ans = _Stodx_v2(_Eb, &_Ep, 0, &_Errno); 

            if (_Ep == _Eb || _Errno != 0) {
                _State |= ios_base::failbit;
            } else {
                _Val = _Ans; 
            }
        }
        return _First;
    }

    virtual _InIt  do_get(_InIt _First, _InIt _Last, bool _Intl, ios_base& _Iosbase,
        ios_base::iostate& _State,
        string_type& _Val) const { 
        _Elem _Atoms[sizeof("0123456789-")];
        string _Str = _Getmfld(_First, _Last, _Intl, _Iosbase, _Atoms);
        size_t _Len = _Str.size();

        if (_First == _Last) {
            _State |= ios_base::eofbit;
        }

        if (_Len == 0) {
            _State |= ios_base::failbit; 
        } else { 
            size_t _Idx = 0;
            _Val.resize(_Len);
            if (_Str[0] == '-') {
                _Val[_Idx++] = _Atoms[10];
            }

            for (; _Idx < _Len; ++_Idx) {
                _Val[_Idx] = _Atoms[_Str[_Idx] - '0']; 
            }
        }
        return _First;
    }

private:
    string _Getmfld(_InIt& _First, _InIt& _Last, bool _Intl, ios_base& _Iosbase,
        _Elem (&_Atoms)[12]) const { 
        _Adl_verify_range(_First, _Last);
        const _Mpunct<_Elem>* _Ppunct_fac;
        if (_Intl) {
            _Ppunct_fac = ::std:: addressof(::std:: use_facet<_Mypunct1>(_Iosbase.getloc())); 
        } else {
            _Ppunct_fac = ::std:: addressof(::std:: use_facet<_Mypunct0>(_Iosbase.getloc())); 
        }

        bool _Bad = false;
        bool _Neg = false;
        string_type _Sign;
        const money_base::pattern _Pattern = _Ppunct_fac->neg_format();
        string _Val;
        size_t _Idx;
        static constexpr char _Src[]   = "0123456789-";
        const ctype<_Elem>& _Ctype_fac = ::std:: use_facet<ctype<_Elem>>(_Iosbase.getloc());
        _Ctype_fac.widen(::std:: begin(_Src), ::std:: end(_Src), _Atoms);

        for (size_t _Off = 0; !_Bad && _Off < 4; ++_Off) {
            switch (_Pattern.field[_Off]) { 
            case money_base::symbol:
                { 
                    string_type _Symbol = _Ppunct_fac->curr_symbol();
                    typename string_type::const_iterator _Source;

                    if ((!(_Iosbase.flags() & ios_base::showbase) && _First != _Last && *_First != *_Symbol.c_str())
                        || (_Off == 3 && _Sign.size() <= 1
                            && (_First == _Last || *_First != *_Symbol.c_str()))) { 
                                                                                    
                                                                                    
                        _Symbol.erase();
                    }

                    _Source = _Symbol.begin();
                    while (_First != _Last && _Source != _Symbol.end() && *_First == *_Source) {
                        
                        ++_Source;
                        ++_First;
                    }

                    if (_Source != _Symbol.end()) {
                        _Bad = true; 
                    }
                    break;
                }

            case money_base::sign: 
                if (_First != _Last) {
                    if (0 < _Ppunct_fac->positive_sign().size()
                        && _Ppunct_fac->positive_sign()[0] == *_First) { 
                        ++_First;
                        _Sign = _Ppunct_fac->positive_sign();
                    } else if (0 < _Ppunct_fac->negative_sign().size()
                               && _Ppunct_fac->negative_sign()[0] == *_First) { 
                        ++_First;
                        _Sign = _Ppunct_fac->negative_sign();
                        _Neg  = true;
                    } else if (0 != _Ppunct_fac->positive_sign().size() && 0 == _Ppunct_fac->negative_sign().size()) {
                        _Neg = true;
                    }
                }

                break; 

            case money_base::value:
                { 
                    int _Fracdigseen        = 0;
                    int _Fracdigits         = _Ppunct_fac->frac_digits();
                    const string _Grouping  = _Ppunct_fac->grouping();
                    const _Elem _Kseparator = _Grouping.empty() ? _Elem{} : _Ppunct_fac->thousands_sep();

                    if (_Kseparator == _Elem{} || 127 <= static_cast<unsigned char>(*_Grouping.c_str())) {
                        for (; _First != _Last && (_Idx = _Find_elem(_Atoms, *_First)) < 10; ++_First) {
                            _Val += _Src[_Idx]; 
                        }
                    } else { 
                        string _Groups;
                        _Groups.push_back('\0');
                        size_t _Group = 0;

                        for (; _First != _Last; ++_First) {
                            if ((_Idx = _Find_elem(_Atoms, *_First)) < 10) { 
                                _Val += _Src[_Idx];
                                if (_Groups[_Group] != 127) {
                                    ++_Groups[_Group];
                                }
                            } else if (_Groups[_Group] == '\0' || *_First != _Kseparator) {
                                break; 
                            } else { 
                                _Groups.push_back('\0');
                                ++_Group;
                            }
                        }

                        if (_Group != 0) { 
                            if ('\0' < _Groups[_Group]) {
                                ++_Group; 
                            } else {
                                _Bad = true; 
                            }
                        }

                        for (const char* _Pg = _Grouping.c_str(); !_Bad && 0 < _Group;) {
                            if (*_Pg == 127) {
                                break; 
                            }

                            if ((0 < --_Group && *_Pg != _Groups[_Group]) || (0 == _Group && *_Pg < _Groups[_Group])) {
                                _Bad = true; 
                            } else if ('\0' < _Pg[1]) {
                                ++_Pg; 
                            }
                        }

                        if (_Bad) {
                            break; 
                        }
                    }

                    const _Elem _Point = _Ppunct_fac->decimal_point();
                    if (_First != _Last && _Point != _Elem{}
                        && *_First == _Point) { 
                        while (++_First != _Last && _Fracdigseen < _Fracdigits
                               && (_Idx = _Find_elem(_Atoms, *_First)) < 10) {
                            _Val += _Src[_Idx];
                            ++_Fracdigseen;
                        }

                        if (_Fracdigseen < _Fracdigits) {
                            _Bad = true; 
                        }
                    }

                    if (_Val.empty()) {
                        _Bad = true; 
                    } else {
                        for (; _Fracdigseen < _Fracdigits; ++_Fracdigseen) {
                            _Val += '0'; 
                        }
                    }

                    break;
                }

            case money_base::space:
            case money_base::none:
                { 
                    if (_Off == 3) {
                        break; 
                    }

                    bool _Seen = false;

                    for (; _First != _Last && _Ctype_fac.is(ctype_base::space, *_First); ++_First) {
                        _Seen = true; 
                    }

                    if (_Pattern.field[_Off] == money_base::space && !_Seen) {
                        _Bad = true; 
                    }
                } 
            } 
        }

        if (!_Bad && 1 < _Sign.size()) { 
            auto _Source = _Sign.begin();

            while (++_Source != _Sign.end() && _First != _Last && *_First == *_Source) {
                ++_First;
            }

            if (_Source != _Sign.end()) {
                _Bad = true; 
            }
        }

        if (_Bad) {
            _Val.erase(); 
        } else if (_Neg) {
            _Val.insert(0, 1, '-'); 
        }

        return _Val;
    }
};


template <class _Elem, class _InIt>
 locale::id money_get<_Elem, _InIt>::id;


template <class _Elem, class _OutIt = ostreambuf_iterator<_Elem, char_traits<_Elem>>>
class money_put : public locale::facet { 
    using _Mypunct0 = moneypunct<_Elem, false>;
    using _Mypunct1 = moneypunct<_Elem, true>;

public:
    static_assert(!0 || _Is_any_of_v<_Elem, char, wchar_t, unsigned short>,
        "Unsupported facet specialization; see N4800 27.3.1.1.1 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this diagnostic.");

    using char_type   = _Elem;
    using iter_type   = _OutIt;
    using string_type = basic_string<_Elem, char_traits<_Elem>, allocator<_Elem>>;

    _OutIt put(_OutIt _Dest, bool _Intl, ios_base& _Iosbase, _Elem _Fill,
        long double _Val) const { 
        return do_put(_Dest, _Intl, _Iosbase, _Fill, _Val);
    }

    _OutIt put(_OutIt _Dest, bool _Intl, ios_base& _Iosbase, _Elem _Fill,
        const string_type& _Val) const { 
        return do_put(_Dest, _Intl, _Iosbase, _Fill, _Val);
    }

      static locale::id id; 

    explicit money_put(size_t _Refs = 0) : locale::facet(_Refs) { 
        { _Locinfo _Lobj;
        _Init(_Lobj);
        }
    }

    money_put(const _Locinfo& _Lobj, size_t _Refs = 0) : locale::facet(_Refs) {
        _Init(_Lobj);
    }

    static size_t _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
        
        if (_Ppf && !*_Ppf) {
            *_Ppf = new money_put<_Elem, _OutIt>(_Locinfo(_Ploc->c_str()));
        }

        return 3;
    }

protected:
     ~money_put() noexcept override {}

    void _Init(const _Locinfo&) {} 

    virtual _OutIt  do_put(_OutIt _Dest, bool _Intl, ios_base& _Iosbase, _Elem _Fill,
        long double _Val) const { 
        bool _Negative = false;
        if (_Val < 0) {
            _Negative = true;
            _Val      = -_Val;
        }

        size_t _Exp;
        for (_Exp = 0; 1e35 <= _Val && _Exp < 5000; _Exp += 10) {
            _Val /= 1e10; 
        }

        char _Buf[40];

        
        const int _Count = :: sprintf_s(_Buf, sizeof(_Buf), "%.0Lf", _Val);

        if (_Count < 0) {
            return _Dest; 
        }

        const ctype<_Elem>& _Ctype_fac = ::std:: use_facet<ctype<_Elem>>(_Iosbase.getloc());
        const _Elem _Elem0             = _Ctype_fac.widen('0');

        string_type _Val2(static_cast<size_t>(_Count), _Elem{});
        _Ctype_fac.widen(_Buf, _Buf + _Count, &_Val2[0]);
        _Val2.append(_Exp, _Elem0); 
        return _Putmfld(_Dest, _Intl, _Iosbase, _Fill, _Negative, _Val2, _Elem0);
    }

    virtual _OutIt  do_put(_OutIt _Dest, bool _Intl, ios_base& _Iosbase, _Elem _Fill,
        const string_type& _Val) const { 
        static constexpr char _Src[] = "0123456789-";
        _Elem _Atoms[sizeof(_Src)];
        const ctype<_Elem>& _Ctype_fac = ::std:: use_facet<ctype<_Elem>>(_Iosbase.getloc());
        _Ctype_fac.widen(::std:: begin(_Src), ::std:: end(_Src), _Atoms);

        bool _Negative = false;
        size_t _Idx0   = 0;
        if (!_Val.empty() && _Val[0] == _Atoms[10]) { 
            _Negative = true;
            ++_Idx0;
        }

        size_t _Size = _Val.size();
        size_t _Idx  = _Idx0;
        for (; _Idx < _Size && _Find_elem(_Atoms, _Val[_Idx]) < 10; ++_Idx) { 
        }

        string_type _Val2(&_Val[_Idx0], _Idx - _Idx0);
        if (_Val2.empty()) { 
            _Val2.push_back(_Atoms[0]);
        }

        return _Putmfld(_Dest, _Intl, _Iosbase, _Fill, _Negative, _Val2, _Atoms[0]);
    }

private:
    _OutIt _Putmfld(
        _OutIt _Dest, bool _Intl, ios_base& _Iosbase, _Elem _Fill, bool _Neg, string_type _Val, _Elem _Elem0) const {
        
        const _Mpunct<_Elem>* _Ppunct_fac;
        if (_Intl) {
            _Ppunct_fac = ::std:: addressof(::std:: use_facet<_Mypunct1>(_Iosbase.getloc())); 
        } else {
            _Ppunct_fac = ::std:: addressof(::std:: use_facet<_Mypunct0>(_Iosbase.getloc())); 
        }

        const string _Grouping = _Ppunct_fac->grouping();
        int _Ifracdigits       = _Ppunct_fac->frac_digits();
        const auto _Fracdigits = static_cast<unsigned int>(_Ifracdigits < 0 ? -_Ifracdigits : _Ifracdigits);

        if (_Val.size() <= _Fracdigits) {
            _Val.insert(0, _Fracdigits - _Val.size() + 1, _Elem0);
        } else if (*_Grouping.c_str() != 127 && '\0' < *_Grouping.c_str()) {
            
            const _Elem _Kseparator = _Ppunct_fac->thousands_sep();
            const char* _Pg         = _Grouping.c_str();
            size_t _Off             = _Val.size() - _Fracdigits; 

            while (*_Pg != 127 && '\0' < *_Pg && static_cast<size_t>(*_Pg) < _Off) {
                
                _Val.insert(_Off -= *_Pg, 1, _Kseparator);
                if ('\0' < _Pg[1]) {
                    ++_Pg; 
                }
            }
        }

        money_base::pattern _Pattern;
        string_type _Sign;
        if (_Neg) { 
            _Pattern = _Ppunct_fac->neg_format();
            _Sign    = _Ppunct_fac->negative_sign();
        } else { 
            _Pattern = _Ppunct_fac->pos_format();
            _Sign    = _Ppunct_fac->positive_sign();
        }

        string_type _Symbol;
        if (_Iosbase.flags() & ios_base::showbase) {
            _Symbol = _Ppunct_fac->curr_symbol(); 
        }

        bool _Intern = false;
        size_t _Fillcount;
        size_t _Off;
        for (_Fillcount = 0, _Off = 0; _Off < 4; ++_Off) {
            switch (_Pattern.field[_Off]) { 
            case money_base::symbol: 
                _Fillcount += _Symbol.size();
                break;

            case money_base::sign: 
                _Fillcount += _Sign.size();
                break;

            case money_base::value: 
                _Fillcount += _Val.size() + (0 < _Fracdigits ? 1 : 0)
                            + (_Val.size() <= _Fracdigits ? _Fracdigits - _Val.size() + 1 : 0);
                break;

            case money_base::space: 
                ++_Fillcount; 
                

            case money_base::none: 
                if (_Off != 3) {
                    _Intern = true; 
                }

                break;
            }
        }

        if (_Iosbase.width() <= 0 || static_cast<size_t>(_Iosbase.width()) <= _Fillcount) {
            _Fillcount = 0;
        } else {
            _Fillcount = static_cast<size_t>(_Iosbase.width()) - _Fillcount;
        }

        ios_base::fmtflags _Afl = _Iosbase.flags() & ios_base::adjustfield;
        if (_Afl != ios_base::left && (_Afl != ios_base::internal || !_Intern)) { 
            _Dest      = _Rep(_Dest, _Fill, _Fillcount);
            _Fillcount = 0;
        }

        for (_Off = 0; _Off < 4; ++_Off) {
            switch (_Pattern.field[_Off]) { 
            case money_base::symbol: 
                _Dest = _Put(_Dest, _Symbol.begin(), _Symbol.size());
                break;

            case money_base::sign: 
                if (0 < _Sign.size()) {
                    _Dest = _Put(_Dest, _Sign.begin(), 1);
                }

                break;

            case money_base::value: 
                if (_Fracdigits == 0) {
                    _Dest = _Put(_Dest, _Val.begin(), _Val.size()); 
                } else if (_Val.size() <= _Fracdigits) { 
                    *_Dest++ = _Elem0;
                    *_Dest++ = _Ppunct_fac->decimal_point();
                    _Dest    = _Rep(_Dest, _Elem0, _Fracdigits - _Val.size()); 
                    _Dest    = _Put(_Dest, _Val.begin(), _Val.size());
                } else { 
                    _Dest    = _Put(_Dest, _Val.begin(), _Val.size() - _Fracdigits); 
                    *_Dest++ = _Ppunct_fac->decimal_point();
                    _Dest =
                        _Put(_Dest, _Val.end() - static_cast<ptrdiff_t>(_Fracdigits), _Fracdigits); 
                }
                break;

            case money_base::space: 
                _Dest = _Rep(_Dest, _Fill, 1);
                

            case money_base::none: 
                if (_Afl == ios_base::internal) { 
                    _Dest      = _Rep(_Dest, _Fill, _Fillcount);
                    _Fillcount = 0;
                }
            }
        }

        if (1 < _Sign.size()) {
            _Dest = _Put(_Dest, _Sign.begin() + 1, _Sign.size() - 1); 
        }

        _Iosbase.width(0);
        return _Rep(_Dest, _Fill, _Fillcount); 
    }

    static _OutIt _Put(_OutIt _Dest, typename string_type::const_iterator _Source, size_t _Count) {
        
        for (; 0 < _Count; --_Count, (void) ++_Dest, ++_Source) {
            *_Dest = *_Source;
        }

        return _Dest;
    }

    static _OutIt _Rep(_OutIt _Dest, _Elem _Ch, size_t _Count) { 
        for (; 0 < _Count; --_Count, (void) ++_Dest) {
            *_Dest = _Ch;
        }

        return _Dest;
    }
};


template <class _Elem, class _OutIt>
 locale::id money_put<_Elem, _OutIt>::id;


#line 909 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocmon"


}


#pragma warning(pop)
#pragma pack(pop)
#line 921 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocmon"
#line 922 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xlocmon"
#line 14 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\locale"


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
template <class _Elem>
class collate : public locale::facet { 
public:
    static_assert(!0 || _Is_any_of_v<_Elem, char, wchar_t, unsigned short>,
        "Unsupported facet specialization; see N4800 27.3.1.1.1 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this diagnostic.");

    using char_type   = _Elem;
    using string_type = basic_string<_Elem, char_traits<_Elem>, allocator<_Elem>>;

    [[nodiscard]] int compare(const _Elem* _First1, const _Elem* _Last1, const _Elem* _First2,
        const _Elem* _Last2) const { 
        return do_compare(_First1, _Last1, _First2, _Last2);
    }

    [[nodiscard]] string_type transform(
        const _Elem* _First, const _Elem* _Last) const { 
        return do_transform(_First, _Last);
    }

    [[nodiscard]] long hash(const _Elem* _First, const _Elem* _Last) const { 
        return do_hash(_First, _Last);
    }

      static locale::id id; 

    explicit collate(size_t _Refs = 0) : locale::facet(_Refs) { 
        { _Locinfo _Lobj;
        _Init(_Lobj);
        }
    }

    collate(const _Locinfo& _Lobj, size_t _Refs = 0) : locale::facet(_Refs) {
        _Init(_Lobj);
    }

    static size_t _Getcat(const locale::facet** _Ppf = nullptr, const locale* _Ploc = nullptr) {
        if (_Ppf && !*_Ppf) {
            *_Ppf = new collate<_Elem>(_Locinfo(_Ploc->name().c_str()));
        }

        return 1;
    }

protected:
     ~collate() noexcept override {
        :: free(_Coll._LocaleName);
    }

    collate(const char* _Locname, size_t _Refs = 0) : locale::facet(_Refs) {
        { _Locinfo _Lobj(_Locname);
        _Init(_Lobj);
        }
    }

    void _Init(const _Locinfo& _Lobj) { 
        _Coll = _Lobj._Getcoll();
    }

    [[nodiscard]] virtual int  do_compare(const _Elem* _First1, const _Elem* _Last1,
        const _Elem* _First2,
        const _Elem* _Last2) const { 
        _Adl_verify_range(_First1, _Last1);
        _Adl_verify_range(_First2, _Last2);
        int _Ans = _LStrcoll(_First1, _Last1, _First2, _Last2, &_Coll);
        return _Ans < 0 ? -1 : _Ans == 0 ? 0 : +1;
    }

    [[nodiscard]] virtual string_type  do_transform(const _Elem* _First,
        const _Elem* _Last) const { 
        _Adl_verify_range(_First, _Last);
        size_t _Count;
        string_type _Str;

        for (_Count = static_cast<size_t>(_Last - _First); 0 < _Count;) {
            
            _Str.resize(_Count);
            if ((_Count = _LStrxfrm(&_Str[0], &_Str[0] + _Str.size(), _First, _Last, &_Coll)) <= _Str.size()) {
                break;
            }
        }
        _Str.resize(_Count);
        return _Str;
    }

    [[nodiscard]] virtual long  do_hash(
        const _Elem* _First, const _Elem* _Last) const { 
        _Adl_verify_range(_First, _Last);
        return static_cast<long>(_Hash_array_representation(_First, static_cast<size_t>(_Last - _First)));
    }

private:
    _Locinfo::_Collvec _Coll; 
};


template <class _Elem>
 locale::id collate<_Elem>::id;


#line 139 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\locale"


template <class _Elem>
class collate_byname : public collate<_Elem> { 
public:
    static_assert(!0 || _Is_any_of_v<_Elem, char, wchar_t>, "Unsupported facet specialization; see N4800 27.3.1.1.1 [locale.category]. " "Either use a Standard specialization or define _ENFORCE_FACET_SPECIALIZATIONS=0 " "to suppress this diagnostic.");

    explicit collate_byname(const char* _Locname, size_t _Refs = 0)
        : collate<_Elem>(_Locname, _Refs) {} 

    explicit collate_byname(const string& _Str, size_t _Refs = 0)
        : collate<_Elem>(_Locinfo(_Str.c_str()), _Refs) {} 

protected:
     ~collate_byname() noexcept override {}
};

template <class _Facet>
[[nodiscard]] bool has_facet(const locale& _Loc) noexcept {
    { ::std:: _Lockit _Lock(0); 
    size_t _Id = _Facet::id;
    return _Loc._Getfacet(_Id) || _Facet::_Getcat() != static_cast<size_t>(-1);
    }
}

template <class _Elem>
[[nodiscard]] bool(isalnum)(_Elem _Ch, const locale& _Loc) {
    return ::std:: use_facet<ctype<_Elem>>(_Loc).is(ctype_base::alnum, _Ch);
}

template <class _Elem>
[[nodiscard]] bool(isalpha)(_Elem _Ch, const locale& _Loc) {
    return ::std:: use_facet<ctype<_Elem>>(_Loc).is(ctype_base::alpha, _Ch);
}

template <class _Elem>
[[nodiscard]] bool(isblank)(_Elem _Ch, const locale& _Loc) {
    return ::std:: use_facet<ctype<_Elem>>(_Loc).is(ctype_base::blank, _Ch);
}

template <class _Elem>
[[nodiscard]] bool(iscntrl)(_Elem _Ch, const locale& _Loc) {
    return ::std:: use_facet<ctype<_Elem>>(_Loc).is(ctype_base::cntrl, _Ch);
}

template <class _Elem>
[[nodiscard]] bool(isdigit)(_Elem _Ch, const locale& _Loc) {
    return ::std:: use_facet<ctype<_Elem>>(_Loc).is(ctype_base::digit, _Ch);
}

template <class _Elem>
[[nodiscard]] bool(isgraph)(_Elem _Ch, const locale& _Loc) {
    return ::std:: use_facet<ctype<_Elem>>(_Loc).is(ctype_base::graph, _Ch);
}

template <class _Elem>
[[nodiscard]] bool(islower)(_Elem _Ch, const locale& _Loc) {
    return ::std:: use_facet<ctype<_Elem>>(_Loc).is(ctype_base::lower, _Ch);
}

template <class _Elem>
[[nodiscard]] bool(isprint)(_Elem _Ch, const locale& _Loc) {
    return ::std:: use_facet<ctype<_Elem>>(_Loc).is(ctype_base::print, _Ch);
}

template <class _Elem>
[[nodiscard]] bool(ispunct)(_Elem _Ch, const locale& _Loc) {
    return ::std:: use_facet<ctype<_Elem>>(_Loc).is(ctype_base::punct, _Ch);
}

template <class _Elem>
[[nodiscard]] bool(isspace)(_Elem _Ch, const locale& _Loc) {
    return ::std:: use_facet<ctype<_Elem>>(_Loc).is(ctype_base::space, _Ch);
}

template <class _Elem>
[[nodiscard]] bool(isupper)(_Elem _Ch, const locale& _Loc) {
    return ::std:: use_facet<ctype<_Elem>>(_Loc).is(ctype_base::upper, _Ch);
}

template <class _Elem>
[[nodiscard]] bool(isxdigit)(_Elem _Ch, const locale& _Loc) {
    return ::std:: use_facet<ctype<_Elem>>(_Loc).is(ctype_base::xdigit, _Ch);
}

template <class _Elem>
[[nodiscard]] _Elem(tolower)(_Elem _Ch, const locale& _Loc) {
    return ::std:: use_facet<ctype<_Elem>>(_Loc).tolower(_Ch);
}

template <class _Elem>
[[nodiscard]] _Elem(toupper)(_Elem _Ch, const locale& _Loc) {
    return ::std:: use_facet<ctype<_Elem>>(_Loc).toupper(_Ch);
}
}


#pragma warning(pop)
#pragma pack(pop)
#line 242 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\locale"
#line 243 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\locale"
#line 53 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\format"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\string_view"


#pragma once


#line 15 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\string_view"

#line 17 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\string_view"
#line 18 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\string_view"
#line 19 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\string_view"
#line 56 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\format"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xfilesystem_abi.h"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


inline constexpr size_t __std_fs_max_path      = 260; 
inline constexpr size_t __std_fs_temp_path_max = __std_fs_max_path + 1;

enum class __std_win_error : unsigned long {
    _Success                   = 0, 
    _Invalid_function          = 1, 
    _File_not_found            = 2, 
    _Path_not_found            = 3, 
    _Access_denied             = 5, 
    _Not_enough_memory         = 8, 
    _No_more_files             = 18, 
    _Sharing_violation         = 32, 
    _Not_supported             = 50, 
    _Error_bad_netpath         = 53, 
    _File_exists               = 80, 
    _Invalid_parameter         = 87, 
    _Insufficient_buffer       = 122, 
    _Invalid_name              = 123, 
    _Directory_not_empty       = 145, 
    _Already_exists            = 183, 
    _Filename_exceeds_range    = 206, 
    _Directory_name_is_invalid = 267, 
    _Max                       = ~0UL 
};

#pragma warning(push)
#pragma warning(disable : 4061) 
[[nodiscard]] inline bool __std_is_file_not_found(const __std_win_error _Error) noexcept {
    switch (_Error) {
    case __std_win_error::_File_not_found:
    case __std_win_error::_Path_not_found:
    case __std_win_error::_Error_bad_netpath:
    case __std_win_error::_Invalid_name:
        return true;
    default:
        return false;
    }
}
#pragma warning(pop)

enum class __std_fs_dir_handle : intptr_t { _Invalid = -1 };

enum class __std_fs_file_attr : unsigned long {
    _Readonly      = 0x00000001, 
    _Hidden        = 0x00000002, 
    _System        = 0x00000004, 
    _Directory     = 0x00000010, 
    _Archive       = 0x00000020, 
    _Device        = 0x00000040, 
    _Normal        = 0x00000080, 
    _Temporary     = 0x00000100, 
    _Sparse_file   = 0x00000200, 
    _Reparse_point = 0x00000400, 

    _Invalid = 0xFFFFFFFF, 
};
[[nodiscard]] constexpr __std_fs_file_attr operator&(__std_fs_file_attr _Left, __std_fs_file_attr _Right) noexcept { using _IntTy = ::std:: underlying_type_t<__std_fs_file_attr>; return static_cast<__std_fs_file_attr>(static_cast<_IntTy>(_Left) & static_cast<_IntTy>(_Right)); } [[nodiscard]] constexpr __std_fs_file_attr operator|(__std_fs_file_attr _Left, __std_fs_file_attr _Right) noexcept { using _IntTy = ::std:: underlying_type_t<__std_fs_file_attr>; return static_cast<__std_fs_file_attr>(static_cast<_IntTy>(_Left) | static_cast<_IntTy>(_Right)); } [[nodiscard]] constexpr __std_fs_file_attr operator^(__std_fs_file_attr _Left, __std_fs_file_attr _Right) noexcept { using _IntTy = ::std:: underlying_type_t<__std_fs_file_attr>; return static_cast<__std_fs_file_attr>(static_cast<_IntTy>(_Left) ^ static_cast<_IntTy>(_Right)); } constexpr __std_fs_file_attr& operator&=(__std_fs_file_attr& _Left, __std_fs_file_attr _Right) noexcept { return _Left = _Left & _Right; } constexpr __std_fs_file_attr& operator|=(__std_fs_file_attr& _Left, __std_fs_file_attr _Right) noexcept { return _Left = _Left | _Right; } constexpr __std_fs_file_attr& operator^=(__std_fs_file_attr& _Left, __std_fs_file_attr _Right) noexcept { return _Left = _Left ^ _Right; } [[nodiscard]] constexpr __std_fs_file_attr operator~(__std_fs_file_attr _Left) noexcept { using _IntTy = ::std:: underlying_type_t<__std_fs_file_attr>; return static_cast<__std_fs_file_attr>(~static_cast<_IntTy>(_Left)); } [[nodiscard]] constexpr bool _Bitmask_includes( __std_fs_file_attr _Left, __std_fs_file_attr _Elements) noexcept { return (_Left & _Elements) != __std_fs_file_attr{}; } [[nodiscard]] constexpr bool _Bitmask_includes_all( __std_fs_file_attr _Left, __std_fs_file_attr _Elements) noexcept { return (_Left & _Elements) == _Elements; }

enum class __std_fs_reparse_tag : unsigned long {
    _None        = 0,
    _Mount_point = (0xA0000003L), 
    _Symlink     = (0xA000000CL), 
};

struct __std_fs_filetime { 
    unsigned long _Low; 
    unsigned long _High; 
}; 

struct __std_fs_find_data { 
    __std_fs_file_attr _Attributes; 
    __std_fs_filetime _Creation_time; 
    __std_fs_filetime _Last_access_time; 
    __std_fs_filetime _Last_write_time; 
    unsigned long _File_size_high; 
    unsigned long _File_size_low; 

    
    __std_fs_reparse_tag _Reparse_point_tag; 
    unsigned long _Reserved1; 
    wchar_t _File_name[__std_fs_max_path]; 
    wchar_t _Short_file_name[14]; 
}; 

enum class __std_fs_stats_flags : unsigned long {
    _None = 0,

    _Follow_symlinks = 0x01, 
    _Attributes      = 0x02, 
    _Reparse_tag     = 0x04, 
    _File_size       = 0x08, 
    _Link_count      = 0x10, 
    _Last_write_time = 0x20, 

    _All_data = _Attributes | _Reparse_tag | _File_size | _Link_count | _Last_write_time
};

[[nodiscard]] constexpr __std_fs_stats_flags operator&(__std_fs_stats_flags _Left, __std_fs_stats_flags _Right) noexcept { using _IntTy = ::std:: underlying_type_t<__std_fs_stats_flags>; return static_cast<__std_fs_stats_flags>(static_cast<_IntTy>(_Left) & static_cast<_IntTy>(_Right)); } [[nodiscard]] constexpr __std_fs_stats_flags operator|(__std_fs_stats_flags _Left, __std_fs_stats_flags _Right) noexcept { using _IntTy = ::std:: underlying_type_t<__std_fs_stats_flags>; return static_cast<__std_fs_stats_flags>(static_cast<_IntTy>(_Left) | static_cast<_IntTy>(_Right)); } [[nodiscard]] constexpr __std_fs_stats_flags operator^(__std_fs_stats_flags _Left, __std_fs_stats_flags _Right) noexcept { using _IntTy = ::std:: underlying_type_t<__std_fs_stats_flags>; return static_cast<__std_fs_stats_flags>(static_cast<_IntTy>(_Left) ^ static_cast<_IntTy>(_Right)); } constexpr __std_fs_stats_flags& operator&=(__std_fs_stats_flags& _Left, __std_fs_stats_flags _Right) noexcept { return _Left = _Left & _Right; } constexpr __std_fs_stats_flags& operator|=(__std_fs_stats_flags& _Left, __std_fs_stats_flags _Right) noexcept { return _Left = _Left | _Right; } constexpr __std_fs_stats_flags& operator^=(__std_fs_stats_flags& _Left, __std_fs_stats_flags _Right) noexcept { return _Left = _Left ^ _Right; } [[nodiscard]] constexpr __std_fs_stats_flags operator~(__std_fs_stats_flags _Left) noexcept { using _IntTy = ::std:: underlying_type_t<__std_fs_stats_flags>; return static_cast<__std_fs_stats_flags>(~static_cast<_IntTy>(_Left)); } [[nodiscard]] constexpr bool _Bitmask_includes( __std_fs_stats_flags _Left, __std_fs_stats_flags _Elements) noexcept { return (_Left & _Elements) != __std_fs_stats_flags{}; } [[nodiscard]] constexpr bool _Bitmask_includes_all( __std_fs_stats_flags _Left, __std_fs_stats_flags _Elements) noexcept { return (_Left & _Elements) == _Elements; }

struct __std_fs_stats {
    long long _Last_write_time;
    unsigned long long _File_size;
    __std_fs_file_attr _Attributes;
    __std_fs_reparse_tag _Reparse_point_tag;
    unsigned long _Link_count;
    __std_fs_stats_flags _Available; 

    [[nodiscard]] __std_fs_file_attr _Symlink_hint_attributes() const noexcept {
        if (_Bitmask_includes(_Available, __std_fs_stats_flags::_Attributes)) {
            return _Attributes;
        }

        return __std_fs_file_attr::_Invalid;
    }
};

struct __std_fs_reparse_data_buffer { 
    unsigned long _Reparse_tag;
    unsigned short _Reparse_data_length;
    unsigned short _Reserved;
    union {
        struct {
            unsigned short _Substitute_name_offset;
            unsigned short _Substitute_name_length;
            unsigned short _Print_name_offset;
            unsigned short _Print_name_length;
            unsigned long _Flags;
            wchar_t _Path_buffer[1];
        } _Symbolic_link_reparse_buffer;
        struct {
            unsigned short _Substitute_name_offset;
            unsigned short _Substitute_name_length;
            unsigned short _Print_name_offset;
            unsigned short _Print_name_length;
            wchar_t _Path_buffer[1];
        } _Mount_point_reparse_buffer;
        struct {
            unsigned char _Data_buffer[1];
        } _Generic_reparse_buffer;
    };
};

struct __std_ulong_and_error {
    unsigned long _Size;
    __std_win_error _Error;
};

enum class __std_fs_volume_name_kind : unsigned long {
    _Dos  = 0, 
    _Guid = 1, 
    _Nt   = 2, 
    _None = 4 
};

enum class __std_access_rights : unsigned long {
    _Delete                = 0x00010000, 
    _File_read_attributes  = 0x0080, 
    _File_write_attributes = 0x0100, 

    
    _File_generic_write = 0x00120116,
};

[[nodiscard]] constexpr __std_access_rights operator&(__std_access_rights _Left, __std_access_rights _Right) noexcept { using _IntTy = ::std:: underlying_type_t<__std_access_rights>; return static_cast<__std_access_rights>(static_cast<_IntTy>(_Left) & static_cast<_IntTy>(_Right)); } [[nodiscard]] constexpr __std_access_rights operator|(__std_access_rights _Left, __std_access_rights _Right) noexcept { using _IntTy = ::std:: underlying_type_t<__std_access_rights>; return static_cast<__std_access_rights>(static_cast<_IntTy>(_Left) | static_cast<_IntTy>(_Right)); } [[nodiscard]] constexpr __std_access_rights operator^(__std_access_rights _Left, __std_access_rights _Right) noexcept { using _IntTy = ::std:: underlying_type_t<__std_access_rights>; return static_cast<__std_access_rights>(static_cast<_IntTy>(_Left) ^ static_cast<_IntTy>(_Right)); } constexpr __std_access_rights& operator&=(__std_access_rights& _Left, __std_access_rights _Right) noexcept { return _Left = _Left & _Right; } constexpr __std_access_rights& operator|=(__std_access_rights& _Left, __std_access_rights _Right) noexcept { return _Left = _Left | _Right; } constexpr __std_access_rights& operator^=(__std_access_rights& _Left, __std_access_rights _Right) noexcept { return _Left = _Left ^ _Right; } [[nodiscard]] constexpr __std_access_rights operator~(__std_access_rights _Left) noexcept { using _IntTy = ::std:: underlying_type_t<__std_access_rights>; return static_cast<__std_access_rights>(~static_cast<_IntTy>(_Left)); } [[nodiscard]] constexpr bool _Bitmask_includes( __std_access_rights _Left, __std_access_rights _Elements) noexcept { return (_Left & _Elements) != __std_access_rights{}; } [[nodiscard]] constexpr bool _Bitmask_includes_all( __std_access_rights _Left, __std_access_rights _Elements) noexcept { return (_Left & _Elements) == _Elements; }

enum class __std_fs_file_flags : unsigned long {
    _None               = 0,
    _Backup_semantics   = 0x02000000, 
    _Open_reparse_point = 0x00200000, 
};

[[nodiscard]] constexpr __std_fs_file_flags operator&(__std_fs_file_flags _Left, __std_fs_file_flags _Right) noexcept { using _IntTy = ::std:: underlying_type_t<__std_fs_file_flags>; return static_cast<__std_fs_file_flags>(static_cast<_IntTy>(_Left) & static_cast<_IntTy>(_Right)); } [[nodiscard]] constexpr __std_fs_file_flags operator|(__std_fs_file_flags _Left, __std_fs_file_flags _Right) noexcept { using _IntTy = ::std:: underlying_type_t<__std_fs_file_flags>; return static_cast<__std_fs_file_flags>(static_cast<_IntTy>(_Left) | static_cast<_IntTy>(_Right)); } [[nodiscard]] constexpr __std_fs_file_flags operator^(__std_fs_file_flags _Left, __std_fs_file_flags _Right) noexcept { using _IntTy = ::std:: underlying_type_t<__std_fs_file_flags>; return static_cast<__std_fs_file_flags>(static_cast<_IntTy>(_Left) ^ static_cast<_IntTy>(_Right)); } constexpr __std_fs_file_flags& operator&=(__std_fs_file_flags& _Left, __std_fs_file_flags _Right) noexcept { return _Left = _Left & _Right; } constexpr __std_fs_file_flags& operator|=(__std_fs_file_flags& _Left, __std_fs_file_flags _Right) noexcept { return _Left = _Left | _Right; } constexpr __std_fs_file_flags& operator^=(__std_fs_file_flags& _Left, __std_fs_file_flags _Right) noexcept { return _Left = _Left ^ _Right; } [[nodiscard]] constexpr __std_fs_file_flags operator~(__std_fs_file_flags _Left) noexcept { using _IntTy = ::std:: underlying_type_t<__std_fs_file_flags>; return static_cast<__std_fs_file_flags>(~static_cast<_IntTy>(_Left)); } [[nodiscard]] constexpr bool _Bitmask_includes( __std_fs_file_flags _Left, __std_fs_file_flags _Elements) noexcept { return (_Left & _Elements) != __std_fs_file_flags{}; } [[nodiscard]] constexpr bool _Bitmask_includes_all( __std_fs_file_flags _Left, __std_fs_file_flags _Elements) noexcept { return (_Left & _Elements) == _Elements; }

enum class __std_fs_file_handle : intptr_t { _Invalid = -1 };

enum class __std_code_page : unsigned int { _Acp = 0, _Utf8 = 65001 };

struct __std_fs_convert_result {
    int _Len;
    __std_win_error _Err;
};

struct __std_fs_file_id { 
    unsigned long long _Volume_serial_number; 
    unsigned char _Id[16]; 
}; 

enum class __std_fs_copy_options {
    _None = 0x0,

    _Existing_mask      = 0xF,
    _Skip_existing      = 0x1,
    _Overwrite_existing = 0x2,
    _Update_existing    = 0x4,
};

[[nodiscard]] constexpr __std_fs_copy_options operator&(__std_fs_copy_options _Left, __std_fs_copy_options _Right) noexcept { using _IntTy = ::std:: underlying_type_t<__std_fs_copy_options>; return static_cast<__std_fs_copy_options>(static_cast<_IntTy>(_Left) & static_cast<_IntTy>(_Right)); } [[nodiscard]] constexpr __std_fs_copy_options operator|(__std_fs_copy_options _Left, __std_fs_copy_options _Right) noexcept { using _IntTy = ::std:: underlying_type_t<__std_fs_copy_options>; return static_cast<__std_fs_copy_options>(static_cast<_IntTy>(_Left) | static_cast<_IntTy>(_Right)); } [[nodiscard]] constexpr __std_fs_copy_options operator^(__std_fs_copy_options _Left, __std_fs_copy_options _Right) noexcept { using _IntTy = ::std:: underlying_type_t<__std_fs_copy_options>; return static_cast<__std_fs_copy_options>(static_cast<_IntTy>(_Left) ^ static_cast<_IntTy>(_Right)); } constexpr __std_fs_copy_options& operator&=(__std_fs_copy_options& _Left, __std_fs_copy_options _Right) noexcept { return _Left = _Left & _Right; } constexpr __std_fs_copy_options& operator|=(__std_fs_copy_options& _Left, __std_fs_copy_options _Right) noexcept { return _Left = _Left | _Right; } constexpr __std_fs_copy_options& operator^=(__std_fs_copy_options& _Left, __std_fs_copy_options _Right) noexcept { return _Left = _Left ^ _Right; } [[nodiscard]] constexpr __std_fs_copy_options operator~(__std_fs_copy_options _Left) noexcept { using _IntTy = ::std:: underlying_type_t<__std_fs_copy_options>; return static_cast<__std_fs_copy_options>(~static_cast<_IntTy>(_Left)); } [[nodiscard]] constexpr bool _Bitmask_includes( __std_fs_copy_options _Left, __std_fs_copy_options _Elements) noexcept { return (_Left & _Elements) != __std_fs_copy_options{}; } [[nodiscard]] constexpr bool _Bitmask_includes_all( __std_fs_copy_options _Left, __std_fs_copy_options _Elements) noexcept { return (_Left & _Elements) == _Elements; }

extern "C" {
[[nodiscard]] __std_ulong_and_error __stdcall __std_fs_get_full_path_name(  const wchar_t* _Source,
      unsigned long _Target_size,   wchar_t* _Target) noexcept;

[[nodiscard]] __std_win_error __stdcall __std_fs_open_handle(  __std_fs_file_handle* _Handle,
      const wchar_t* _File_name,   __std_access_rights _Desired_access,
      __std_fs_file_flags _Flags) noexcept;

void __stdcall __std_fs_close_handle(__std_fs_file_handle _Handle) noexcept;

[[nodiscard]]   __std_win_error
    __stdcall __std_fs_get_file_attributes_by_handle(
          __std_fs_file_handle _Handle,   unsigned long* _File_attributes) noexcept;

[[nodiscard]] __std_ulong_and_error __stdcall __std_fs_get_final_path_name_by_handle(  __std_fs_file_handle _Handle,
      wchar_t* _Target,   unsigned long _Target_size,
      __std_fs_volume_name_kind _Flags) noexcept;

struct __std_fs_copy_file_result {
    bool _Copied;
    __std_win_error _Error;
};

[[nodiscard]] __std_fs_copy_file_result __stdcall __std_fs_copy_file(
      const wchar_t* _Source,   const wchar_t* _Target,   __std_fs_copy_options _Options) noexcept;

[[nodiscard]] __std_win_error __stdcall __std_fs_directory_iterator_open(  const wchar_t* _Path_spec,
      __std_fs_dir_handle* _Handle,   __std_fs_find_data* _Results) noexcept;

void __stdcall __std_fs_directory_iterator_close(  __std_fs_dir_handle _Handle) noexcept;

[[nodiscard]]   __std_win_error
    __stdcall __std_fs_get_stats(  const wchar_t* _Path, __std_fs_stats* _Stats,   __std_fs_stats_flags _Flags,
          __std_fs_file_attr _Symlink_attribute_hint = __std_fs_file_attr::_Invalid) noexcept;

[[nodiscard]] __std_win_error __stdcall __std_fs_directory_iterator_advance(
      __std_fs_dir_handle _Handle,   __std_fs_find_data* _Results) noexcept;

[[nodiscard]] __std_code_page __stdcall __std_fs_code_page() noexcept;

[[nodiscard]] __std_fs_convert_result __stdcall __std_fs_convert_narrow_to_wide(  __std_code_page _Code_page,
      const char* _Input_str,   int _Input_len,
      wchar_t* _Output_str,   int _Output_len) noexcept;

[[nodiscard]] __std_fs_convert_result __stdcall __std_fs_convert_wide_to_narrow(  __std_code_page _Code_page,
      const wchar_t* _Input_str,   int _Input_len,
      char* _Output_str,   int _Output_len) noexcept;

[[nodiscard]] __std_fs_convert_result __stdcall __std_fs_convert_wide_to_narrow_replace_chars(
      __std_code_page _Code_page,   const wchar_t* _Input_str,   int _Input_len,
      char* _Output_str,   int _Output_len) noexcept;

[[nodiscard]]   __std_win_error
    __stdcall __std_fs_get_file_id(  __std_fs_file_id* _Id,   const wchar_t* _Path) noexcept;

[[nodiscard]] __std_win_error __stdcall __std_fs_set_last_write_time(
      long long _Last_write_filetime,   const wchar_t* _Path) noexcept;

[[nodiscard]] __std_win_error __stdcall __std_fs_change_permissions(
      const wchar_t* _Path,   bool _Follow_symlinks,   bool _Readonly) noexcept;

[[nodiscard]]   __std_ulong_and_error
    __stdcall __std_fs_get_temp_path(  wchar_t* _Target) noexcept;

[[nodiscard]]   __std_ulong_and_error
    __stdcall __std_fs_get_current_path(
          unsigned long _Target_size,   wchar_t* _Target) noexcept;

[[nodiscard]] __std_win_error __stdcall __std_fs_set_current_path(  const wchar_t* _Target) noexcept;

[[nodiscard]] __std_win_error __stdcall __std_fs_create_directory_symbolic_link(
      const wchar_t* _Symlink_file_name,   const wchar_t* _Target_file_name) noexcept;

[[nodiscard]] __std_win_error __stdcall __std_fs_create_hard_link(
      const wchar_t* _File_name,   const wchar_t* _Existing_file_name) noexcept;

[[nodiscard]] __std_win_error __stdcall __std_fs_create_symbolic_link(
      const wchar_t* _Symlink_file_name,   const wchar_t* _Target_file_name) noexcept;

[[nodiscard]] __std_win_error __stdcall __std_fs_read_reparse_data_buffer(  __std_fs_file_handle _Handle,
      void* _Buffer,   unsigned long _Buffer_size) noexcept;

[[nodiscard]]   __std_win_error
    __stdcall __std_fs_read_name_from_reparse_data_buffer(
          __std_fs_reparse_data_buffer* _Handle,   wchar_t** _Offset,   unsigned short* _Length) noexcept;

struct __std_fs_create_directory_result {
    bool _Created;
    __std_win_error _Error;
};

[[nodiscard]] __std_fs_create_directory_result __stdcall __std_fs_create_directory(
      const wchar_t* _New_directory) noexcept;

struct __std_fs_remove_result {
    bool _Removed;
    __std_win_error _Error;
};

[[nodiscard]] __std_fs_remove_result __stdcall __std_fs_remove(  const wchar_t* _Target) noexcept;

[[nodiscard]] __std_win_error __stdcall __std_fs_rename(
      const wchar_t* _Source,   const wchar_t* _Target) noexcept;

[[nodiscard]] __std_win_error __stdcall __std_fs_resize_file(  const wchar_t* _Target, uintmax_t _New_size) noexcept;

[[nodiscard]] __std_win_error __stdcall __std_fs_space(  const wchar_t* _Target,   uintmax_t* _Available,
      uintmax_t* _Total_bytes,   uintmax_t* _Free_bytes) noexcept;
}

namespace std {
struct _Fs_file {
    __std_fs_file_handle _Raw;

    explicit _Fs_file(void* const _Handle) : _Raw{reinterpret_cast<intptr_t>(_Handle)} {}

    _Fs_file(const wchar_t* const _File_name, const __std_access_rights _Desired_access,
        const __std_fs_file_flags _Flags, __std_win_error* const _Err) {
        *_Err = __std_fs_open_handle(&_Raw, _File_name, _Desired_access, _Flags);
    }

    _Fs_file(const _Fs_file&) = delete;
    _Fs_file& operator=(const _Fs_file&) = delete;

    ~_Fs_file() {
        __std_fs_close_handle(_Raw);
    }

    [[nodiscard]] void* _Get() const {
        return reinterpret_cast<void*>(_Raw);
    }
};

struct _Is_slash_oper { 
    [[nodiscard]] constexpr bool operator()(
        const wchar_t _Ch) const { 
        return _Ch == L'\\' || _Ch == L'/';
    }
};

inline constexpr _Is_slash_oper _Is_slash{};
}


#pragma warning(pop)
#pragma pack(pop)

#line 379 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xfilesystem_abi.h"
#line 380 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xfilesystem_abi.h"
#line 57 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\format"


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


extern "C" [[nodiscard]] __std_win_error __stdcall __std_get_cvt(__std_code_page _Codepage, _Cvtvec* _Pcvt) noexcept;

namespace std {

template <class, class>
class vector;

class format_error : public runtime_error {
    using runtime_error::runtime_error;
};

enum class _Fmt_align : uint8_t { _None, _Left, _Right, _Center };

enum class _Fmt_sign : uint8_t { _None, _Plus, _Minus, _Space };

enum class _Basic_format_arg_type : uint8_t {
    _None,
    _Int_type,
    _UInt_type,
    _Long_long_type,
    _ULong_long_type,
    _Bool_type,
    _Char_type,
    _Float_type,
    _Double_type,
    _Long_double_type,
    _Pointer_type,
    _CString_type,
    _String_type,
    _Custom_type,
};
static_assert(static_cast<int>(_Basic_format_arg_type::_Custom_type) < 16, "must fit in 4-bit bitfield");

[[nodiscard]] constexpr bool _Is_integral_fmt_type(_Basic_format_arg_type _Ty) {
    return _Ty > _Basic_format_arg_type::_None && _Ty <= _Basic_format_arg_type::_Char_type;
}
[[nodiscard]] constexpr bool _Is_arithmetic_fmt_type(_Basic_format_arg_type _Ty) {
    return _Ty > _Basic_format_arg_type::_None && _Ty <= _Basic_format_arg_type::_Long_double_type;
}

struct _Auto_id_tag {};


template <class _Ty, class _CharT>
concept _Parse_arg_id_callbacks = requires(_Ty _At) {
    { _At._On_auto_id() } -> same_as<void>;
    { _At._On_manual_id(size_t{}) } -> same_as<void>;
};

template <class _Ty, class _CharT>
concept _Parse_replacement_field_callbacks = requires(_Ty _At, const _CharT* _First, const _CharT* _Last) {
    { _At._Parse_context };
    { _At._On_text(_First, _Last) } -> same_as<void>;
    { _At._On_replacement_field(size_t{}, static_cast<const _CharT*>(nullptr)) } -> same_as<void>;
    { _At._On_format_specs(size_t{}, _First, _Last) } -> same_as<const _CharT*>;
};

template <class _Ty, class _CharT>
concept _Parse_align_callbacks = requires(_Ty _At, basic_string_view<_CharT> _Sv, _Fmt_align _Aln) {
    { _At._On_fill(_Sv) } -> same_as<void>;
    { _At._On_align(_Aln) } -> same_as<void>;
};

template <class _Ty, class _CharT>
concept _Parse_width_callbacks = requires(_Ty _At) {
    { _At._On_width(int{}) } -> same_as<void>;
};

template <class _Ty, class _CharT>
concept _Parse_precision_callbacks = requires(_Ty _At) {
    { _At._On_precision(int{}) } -> same_as<void>;
};

template <class _Ty, class _CharT>
concept _Width_adapter_callbacks = requires(_Ty _At) {
    { _At._On_dynamic_width(_Auto_id_tag{}) } -> same_as<void>;
    { _At._On_dynamic_width(size_t{}) } -> same_as<void>;
};

template <class _Ty, class _CharT>
concept _Precision_adapter_callbacks = requires(_Ty _At) {
    { _At._On_dynamic_precision(_Auto_id_tag{}) } -> same_as<void>;
    { _At._On_dynamic_precision(size_t{}) } -> same_as<void>;
};

template <class _Ty, class _CharT>
concept _Parse_spec_callbacks = _Parse_align_callbacks<_Ty, _CharT>
                                && _Parse_width_callbacks<_Ty, _CharT>
                                && _Parse_precision_callbacks<_Ty, _CharT>
                                && _Width_adapter_callbacks<_Ty, _CharT>
                                && _Precision_adapter_callbacks<_Ty, _CharT>
                                && requires(_Ty _At, basic_string_view<_CharT> _Sv, _Fmt_align _Aln, _Fmt_sign _Sgn) {
                                    { _At._On_sign(_Sgn) } -> same_as<void>;
                                    { _At._On_hash() } -> same_as<void>;
                                    { _At._On_zero() } -> same_as<void>;
                                    { _At._On_localized() } -> same_as<void>;
                                    { _At._On_type(_CharT{}) } -> same_as<void>;
};


template <class _Ty, class _CharT>
concept _CharT_or_bool = same_as<_Ty, _CharT> || same_as<_Ty, bool>;

template <class _CharT>
concept _Format_supported_charT = _Is_any_of_v<_CharT, char, wchar_t>;

template <class _Ty, class _Context>
concept _Has_formatter = requires(_Ty& _Val, _Context& _Ctx) {
    ::std:: declval<typename _Context::template formatter_type<remove_cvref_t<_Ty>>>().format(_Val, _Ctx);
};

template <class _Ty, class _Context>
concept _Has_const_formatter = _Has_formatter<const remove_reference_t<_Ty>, _Context>;

template <class _Ty, class _CharT = char>
struct formatter;

inline void _You_see_this_error_because_arg_id_is_out_of_range() noexcept {}

template <class _CharT>
class basic_format_parse_context {
public:
    using char_type      = _CharT;
    using const_iterator = typename basic_string_view<_CharT>::const_iterator;
    using iterator       = const_iterator;

    constexpr explicit basic_format_parse_context(
        const basic_string_view<_CharT> _Fmt, const size_t _Num_args_ = 0) noexcept
        : _Format_string(_Fmt), _Num_args(_Num_args_) {}

    basic_format_parse_context(const basic_format_parse_context&) = delete;
    basic_format_parse_context& operator=(const basic_format_parse_context&) = delete;

    [[nodiscard]] constexpr const_iterator begin() const noexcept {
        return _Format_string.begin();
    }
    [[nodiscard]] constexpr const_iterator end() const noexcept {
        return _Format_string.end();
    }
    [[nodiscard]] constexpr const _CharT* _Unchecked_begin() const noexcept {
        return _Format_string._Unchecked_begin();
    }
    [[nodiscard]] constexpr const _CharT* _Unchecked_end() const noexcept {
        return _Format_string._Unchecked_end();
    }

    constexpr void advance_to(const const_iterator _It) {
        _Adl_verify_range(_It, _Format_string.end());
        _Adl_verify_range(_Format_string.begin(), _It);
        const auto _Diff = static_cast<size_t>(_It._Unwrapped() - _Format_string._Unchecked_begin());
        _Format_string.remove_prefix(_Diff);
    }

    
    [[nodiscard]] constexpr size_t next_arg_id() {
        if (_Next_arg_id < 0) {
            throw format_error("Can not switch from manual to automatic indexing");
        }

        if (::std:: is_constant_evaluated()) {
            if (static_cast<size_t>(_Next_arg_id) >= _Num_args) {
                _You_see_this_error_because_arg_id_is_out_of_range();
            }
        }

        return static_cast<size_t>(_Next_arg_id++);
    }

    constexpr void check_arg_id(const size_t _Id) {
        if (::std:: is_constant_evaluated()) {
            if (_Id >= _Num_args) {
                _You_see_this_error_because_arg_id_is_out_of_range();
            }
        }

        if (_Next_arg_id > 0) {
            throw format_error("Can not switch from automatic to manual indexing");
        }
        _Next_arg_id = -1;
    }

private:
    basic_string_view<_CharT> _Format_string;
    size_t _Num_args;
    
    
    ptrdiff_t _Next_arg_id = 0;
};

using format_parse_context  = basic_format_parse_context<char>;
using wformat_parse_context = basic_format_parse_context<wchar_t>;

template <class _Context>
class basic_format_arg {
public:
    using _CharType = typename _Context::char_type;

    class handle {
    private:
        const void* _Ptr;
        void(__cdecl* _Format)(basic_format_parse_context<_CharType>& _Parse_ctx, _Context& _Format_ctx, const void*);
        friend basic_format_arg;

    public:
        template <class _Ty>
        explicit handle(_Ty&& _Val) noexcept
            : _Ptr(::std:: addressof(_Val)),
              _Format([](basic_format_parse_context<_CharType>& _Parse_ctx, _Context& _Format_ctx, const void* _Ptr) {
                  using _Value_type = remove_cvref_t<_Ty>;
                  typename _Context::template formatter_type<_Value_type> _Formatter;
                  using _Qualified_type =
                      conditional_t<_Has_const_formatter<_Value_type, _Context>, const _Value_type, _Value_type>;
                  _Parse_ctx.advance_to(_Formatter.parse(_Parse_ctx));
                  _Format_ctx.advance_to(_Formatter.format(
                      *const_cast<_Qualified_type*>(static_cast<const _Value_type*>(_Ptr)), _Format_ctx));
              }) {
            static_assert(_Has_const_formatter<_Ty, _Context> || !is_const_v<remove_reference_t<_Ty>>);
        }

        void format(basic_format_parse_context<_CharType>& _Parse_ctx, _Context& _Format_ctx) const {
            _Format(_Parse_ctx, _Format_ctx, _Ptr);
        }
    };

    
    basic_format_arg() noexcept : _Active_state(_Basic_format_arg_type::_None), _No_state() {}

    explicit basic_format_arg(const int _Val) noexcept
        : _Active_state(_Basic_format_arg_type::_Int_type), _Int_state(_Val) {}
    explicit basic_format_arg(const unsigned int _Val) noexcept
        : _Active_state(_Basic_format_arg_type::_UInt_type), _UInt_state(_Val) {}
    explicit basic_format_arg(const long long _Val) noexcept
        : _Active_state(_Basic_format_arg_type::_Long_long_type), _Long_long_state(_Val) {}
    explicit basic_format_arg(const unsigned long long _Val) noexcept
        : _Active_state(_Basic_format_arg_type::_ULong_long_type), _ULong_long_state(_Val) {}
    explicit basic_format_arg(const bool _Val) noexcept
        : _Active_state(_Basic_format_arg_type::_Bool_type), _Bool_state(_Val) {}
    explicit basic_format_arg(const _CharType _Val) noexcept
        : _Active_state(_Basic_format_arg_type::_Char_type), _Char_state(_Val) {}
    explicit basic_format_arg(const float _Val) noexcept
        : _Active_state(_Basic_format_arg_type::_Float_type), _Float_state(_Val) {}
    explicit basic_format_arg(const double _Val) noexcept
        : _Active_state(_Basic_format_arg_type::_Double_type), _Double_state(_Val) {}
    explicit basic_format_arg(const long double _Val) noexcept
        : _Active_state(_Basic_format_arg_type::_Long_double_type), _Long_double_state(_Val) {}
    explicit basic_format_arg(const void* _Val) noexcept
        : _Active_state(_Basic_format_arg_type::_Pointer_type), _Pointer_state(_Val) {}
    explicit basic_format_arg(const _CharType* _Val) noexcept
        : _Active_state(_Basic_format_arg_type::_CString_type), _CString_state(_Val) {}
    explicit basic_format_arg(const basic_string_view<_CharType> _Val) noexcept
        : _Active_state(_Basic_format_arg_type::_String_type), _String_state(_Val) {}
    explicit basic_format_arg(const handle _Val) noexcept
        : _Active_state(_Basic_format_arg_type::_Custom_type), _Custom_state(_Val) {}

    explicit operator bool() const noexcept {
        return _Active_state != _Basic_format_arg_type::_None;
    }

    _Basic_format_arg_type _Active_state = _Basic_format_arg_type::_None;
    union {
        monostate _No_state = monostate{};
        int _Int_state;
        unsigned int _UInt_state;
        long long _Long_long_state;
        unsigned long long _ULong_long_state;
        bool _Bool_state;
        _CharType _Char_state;
        float _Float_state;
        double _Double_state;
        long double _Long_double_state;
        const void* _Pointer_state;
        const _CharType* _CString_state;
        basic_string_view<_CharType> _String_state;
        handle _Custom_state;
    };
};

template <class _Visitor, class _Context>
decltype(auto) visit_format_arg(_Visitor&& _Vis, basic_format_arg<_Context> _Arg) {
    switch (_Arg._Active_state) {
    case _Basic_format_arg_type::_None:
        return ::std:: forward<_Visitor>(_Vis)(_Arg._No_state);
    case _Basic_format_arg_type::_Int_type:
        return ::std:: forward<_Visitor>(_Vis)(_Arg._Int_state);
    case _Basic_format_arg_type::_UInt_type:
        return ::std:: forward<_Visitor>(_Vis)(_Arg._UInt_state);
    case _Basic_format_arg_type::_Long_long_type:
        return ::std:: forward<_Visitor>(_Vis)(_Arg._Long_long_state);
    case _Basic_format_arg_type::_ULong_long_type:
        return ::std:: forward<_Visitor>(_Vis)(_Arg._ULong_long_state);
    case _Basic_format_arg_type::_Bool_type:
        return ::std:: forward<_Visitor>(_Vis)(_Arg._Bool_state);
    case _Basic_format_arg_type::_Char_type:
        return ::std:: forward<_Visitor>(_Vis)(_Arg._Char_state);
    case _Basic_format_arg_type::_Float_type:
        return ::std:: forward<_Visitor>(_Vis)(_Arg._Float_state);
    case _Basic_format_arg_type::_Double_type:
        return ::std:: forward<_Visitor>(_Vis)(_Arg._Double_state);
    case _Basic_format_arg_type::_Long_double_type:
        return ::std:: forward<_Visitor>(_Vis)(_Arg._Long_double_state);
    case _Basic_format_arg_type::_Pointer_type:
        return ::std:: forward<_Visitor>(_Vis)(_Arg._Pointer_state);
    case _Basic_format_arg_type::_CString_type:
        return ::std:: forward<_Visitor>(_Vis)(_Arg._CString_state);
    case _Basic_format_arg_type::_String_type:
        return ::std:: forward<_Visitor>(_Vis)(_Arg._String_state);
    case _Basic_format_arg_type::_Custom_type:
        return ::std:: forward<_Visitor>(_Vis)(_Arg._Custom_state);
    default:
        do { if (false) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
        return ::std:: forward<_Visitor>(_Vis)(0);
    }
}


template <class _CharT>
[[nodiscard]] constexpr const _CharT* _Parse_nonnegative_integer(
    const _CharT* _First, const _CharT* _Last, unsigned int& _Value) {
    ;

    constexpr auto _Max_int = static_cast<unsigned int>((numeric_limits<int>::max)());
    constexpr auto _Big_int = _Max_int / 10u;

    _Value = 0;

    do {
        if (_Value > _Big_int) {
            _Value = _Max_int + 1;
            break;
        }
        _Value = _Value * 10 + static_cast<unsigned int>(*_First - '0');
        ++_First;
    } while (_First != _Last && '0' <= *_First && *_First <= '9');

    if (_Value > _Max_int) {
        throw format_error("Number is too big");
    }

    return _First;
}

template <class _CharT>
[[nodiscard]] constexpr const _CharT* _Parse_nonnegative_integer(const _CharT* _First, const _CharT* _Last, int& _Value) {
    unsigned int _Val_unsigned = 0;

    _First = _Parse_nonnegative_integer(_First, _Last, _Val_unsigned);
    
    _Value = static_cast<int>(_Val_unsigned);
    return _First;
}

template <class _CharT, _Parse_arg_id_callbacks<_CharT> _Callbacks_type>
[[nodiscard]] constexpr const _CharT* _Parse_arg_id(
    const _CharT* _First, const _CharT* _Last, _Callbacks_type&& _Callbacks) {
    ;
    _CharT _Ch = *_First;
    
    if (_Ch == '}' || _Ch == ':') {
        _Callbacks._On_auto_id();
        return _First;
    }

    if (_Ch >= '0' && _Ch <= '9') {
        unsigned int _Index = 0;
        
        
        if (_Ch == '0') {
            ++_First;
        } else {
            _First = _Parse_nonnegative_integer(_First, _Last, _Index);
        }

        
        if (_First == _Last || (*_First != '}' && *_First != ':')) {
            throw format_error("Invalid format string.");
        }

        _Callbacks._On_manual_id(_Index);
        return _First;
    }
    
    throw format_error("Invalid format string.");
}

[[nodiscard]] constexpr bool _Is_execution_charset_self_synchronizing() {

    
    switch (1252) {
    
    case 874: 
    case 1250: 
    case 1251: 
    case 1252: 
    case 1253: 
    case 1254: 
    case 1255: 
    case 1256: 
    case 1257: 
    case 1258: 
    case 65001: 
        return true;
    default:
        return false;
    }


#line 487 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\format"
}

inline constexpr char16_t _Width_estimate_low_intervals[] = { 
    0x1100u, 0x1160u, 0x2329u, 0x232Bu, 0x2E80u, 0x303Fu, 0x3040u, 0xA4D0u, 0xAC00u, 0xD7A4u, 0xF900u, 0xFB00u, 0xFE10u,
    0xFE1Au, 0xFE30u, 0xFE70u, 0xFF00u, 0xFF61u, 0xFFE0u, 0xFFE7u};

inline constexpr char32_t _Width_estimate_high_intervals[] = { 
    0x1F300u, 0x1F650u, 0x1F900u, 0x1FA00u, 0x20000u, 0x2FFFEu, 0x30000u, 0x3FFFEu};

template <auto& _Bounds>
[[nodiscard]] constexpr int _Unicode_width_estimate(const char32_t _Ch) noexcept {
    
    int _Result = 1;
    for (const auto& _Bound : _Bounds) {
        if (_Ch < _Bound) {
            return _Result;
        }
        _Result ^= 0b11u; 
    }

    return 1;
}

template <class _CharT, bool _Statically_Utf8 = _Is_execution_charset_self_synchronizing()>
class _Fmt_codec;

template <bool _Statically_Utf8>
class _Fmt_codec_base {};

template <>
class _Fmt_codec_base<false> {
protected:
    _Cvtvec _Cvt;

    [[nodiscard]] int _Double_byte_encoding_code_units_in_next_character(
        const char* const _First, const char* const _Last) const {
        
        
        wchar_t _Wide;
        mbstate_t _St{};
        const auto _Len   = static_cast<size_t>(_Last - _First);
        const int _Result = _Mbrtowc(&_Wide, _First, _Len, &_St, &_Cvt);
        if (_Result > 0) {
            return _Result;
        } else if (_Result < 0) { 
            return -1;
        } else { 
            return 1;
        }
    }

    _Fmt_codec_base() {

        constexpr __std_code_page _Format_codepage{1252};


#line 546 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\format"
        [[maybe_unused]] const __std_win_error _Result = __std_get_cvt(_Format_codepage, &_Cvt);
        ;
    }
};

template <bool _Statically_Utf8>
class _Fmt_codec<char, _Statically_Utf8> : private _Fmt_codec_base<_Statically_Utf8> {
private:
    [[nodiscard]] static constexpr int _Utf8_code_units_in_next_character(
        const char* const _First, const char* const _Last) noexcept {
        
        
        const auto _Ch = static_cast<unsigned char>(*_First);
        if (_Ch < 0b1000'0000u) {
            return 1;
        }

        const auto _Len = static_cast<size_t>(_Last - _First);

        if (_Ch < 0b1110'0000u) {
            
            return (_Ch >= 0b1100'0000u && _Len >= 2) ? 2 : -1;
        }

        if (_Ch < 0b1111'0000u) {
            
            return (_Len >= 3) ? 3 : -1;
        }

        
        return (_Len >= 4) ? 4 : -1;
    }

    [[nodiscard]] static constexpr int _Estimate_utf8_character_width(const char* const _Ptr, const int _Units) noexcept {
        
        
        auto _Ch = static_cast<char32_t>(*_Ptr);
        switch (_Units) {
        default:
        case 1:
        case 2:
            return 1;
        case 3:
            _Ch &= 0b1111u;
            break;
        case 4:
            _Ch &= 0b111u;
            break;
        }

        for (int _Idx = 1; _Idx < _Units; ++_Idx) {
            _Ch = _Ch << 6 | (_Ptr[_Idx] & 0b11'1111u);
        }

        if (_Units == 3) {
            return _Unicode_width_estimate<_Width_estimate_low_intervals>(_Ch);
        }

        return _Unicode_width_estimate<_Width_estimate_high_intervals>(_Ch);
    }

public:
    [[nodiscard]] constexpr int _Units_in_next_character(
        const char* const _First, const char* const _Last) const noexcept {
        
        
        ;

        if constexpr (_Statically_Utf8) {
            return _Utf8_code_units_in_next_character(_First, _Last);
        } else {
            switch (this->_Cvt._Mbcurmax) {
            default:
                ;
                [[fallthrough]];
            case 1:
                return 1; 

            case 2:
                return this->_Double_byte_encoding_code_units_in_next_character(_First, _Last);

            case 4: 
                return _Utf8_code_units_in_next_character(_First, _Last);
            }
        }
    }

    [[nodiscard]] constexpr const char* _Find_encoded(const char* _First, const char* const _Last, const char _Val) const {
        
        
        if constexpr (_Statically_Utf8) {
            return _Find_unchecked(_First, _Last, _Val);
        } else {
            if (this->_Cvt._Mbcurmax == 1 || this->_Cvt._Mbcurmax == 4) {
                
                return _Find_unchecked(_First, _Last, _Val);
            }

            while (_First != _Last && *_First != _Val) {
                const int _Units = _Units_in_next_character(_First, _Last);
                if (_Units < 0) {
                    throw format_error("Invalid encoded character in format string.");
                }
                _First += _Units;
            }

            return _First;
        }
    }

    [[nodiscard]] constexpr int _Estimate_width(const char* const _Ptr, const int _Units) const {
        
        
        if constexpr (_Statically_Utf8) {
            return _Estimate_utf8_character_width(_Ptr, _Units);
        } else {
            if (this->_Cvt._Mbcurmax != 4) {
                
                return _Units;
            }

            
            return _Estimate_utf8_character_width(_Ptr, _Units);
        }
    }
};

template <bool _Statically_Utf8>
class _Fmt_codec<wchar_t, _Statically_Utf8> {
public:
    [[nodiscard]] constexpr int _Units_in_next_character(
        const wchar_t* _First, const wchar_t* const _Last) const noexcept {
        
        
        ;

        if (*_First < 0xD800u || *_First >= 0xE000u) {
            return 1;
        }

        if (*_First >= 0xDC00u) { 
            return -1;
        }

        if (++_First == _Last || *_First < 0xDC00u || *_First >= 0xE000u) { 
            return -1;
        }

        return 2; 
    }

    [[nodiscard]] constexpr const wchar_t* _Find_encoded(
        const wchar_t* const _First, const wchar_t* const _Last, const wchar_t _Val) const {
        return _Find_unchecked(_First, _Last, _Val);
    }

    [[nodiscard]] constexpr int _Estimate_width(const wchar_t* const _Ptr, const int _Units) const {
        
        
        auto _Ch = static_cast<char32_t>(*_Ptr);
        if (_Units == 1) {
            return _Unicode_width_estimate<_Width_estimate_low_intervals>(_Ch);
        }

        
        _Ch = (_Ch - 0xD800u) << 10;
        _Ch += static_cast<char32_t>(_Ptr[1]) - 0xDC00u;
        _Ch += 0x10000u;
        return _Unicode_width_estimate<_Width_estimate_high_intervals>(_Ch);
    }
};

template <class _CharT, _Parse_align_callbacks<_CharT> _Callbacks_type>
[[nodiscard]] constexpr const _CharT* _Parse_align(
    const _CharT* _First, const _CharT* _Last, _Callbacks_type&& _Callbacks) {
    
    ;
    auto _Parsed_align = _Fmt_align::_None;

    const int _Units = _Fmt_codec<_CharT>{}._Units_in_next_character(_First, _Last);
    if (_Units < 0) { 
        throw format_error("Invalid format string.");
    }
    auto _Align_pt = _First + _Units;

    if (_Align_pt == _Last) {
        _Align_pt = _First;
    }

    for (;;) {
        switch (*_Align_pt) {
        case '<':
            _Parsed_align = _Fmt_align::_Left;
            break;
        case '>':
            _Parsed_align = _Fmt_align::_Right;
            break;
        case '^':
            _Parsed_align = _Fmt_align::_Center;
            break;
        }

        if (_Parsed_align != _Fmt_align::_None) {
            if (_Align_pt != _First) {
                if (*_First == '{') {
                    throw format_error("invalid fill character '{'");
                }
                _Callbacks._On_fill({_First, static_cast<size_t>(_Align_pt - _First)});
                _First = _Align_pt + 1;
            } else {
                ++_First;
            }
            _Callbacks._On_align(_Parsed_align);
            break;
        } else if (_Align_pt == _First) {
            break;
        }
        _Align_pt = _First;
    }

    return _First;
}


template <class _CharT, _Width_adapter_callbacks<_CharT> _Callbacks_type>
struct _Width_adapter {
    _Callbacks_type& _Callbacks;

    constexpr explicit _Width_adapter(_Callbacks_type& _Handler) : _Callbacks(_Handler) {}

    constexpr void _On_auto_id() {
        _Callbacks._On_dynamic_width(_Auto_id_tag{});
    }
    constexpr void _On_manual_id(const size_t _Id) {
        _Callbacks._On_dynamic_width(_Id);
    }
};


template <class _CharT, _Precision_adapter_callbacks<_CharT> _Callbacks_type>
struct _Precision_adapter {
    _Callbacks_type& _Callbacks;

    constexpr explicit _Precision_adapter(_Callbacks_type& _Handler) : _Callbacks(_Handler) {}

    constexpr void _On_auto_id() {
        _Callbacks._On_dynamic_precision(_Auto_id_tag{});
    }
    constexpr void _On_manual_id(const size_t _Id) {
        _Callbacks._On_dynamic_precision(_Id);
    }
};


template <class _CharT>
struct _Id_adapter {
    basic_format_parse_context<_CharT>& _Parse_context;
    size_t _Arg_id = static_cast<size_t>(-1);

    constexpr void _On_auto_id() {
        _Arg_id = _Parse_context.next_arg_id();
        ;
    }
    constexpr void _On_manual_id(const size_t _Id) {
        _Parse_context.check_arg_id(_Id);
        _Arg_id = _Id;
        ;
    }
};

template <class _CharT, _Parse_width_callbacks<_CharT> _Callbacks_type>
[[nodiscard]] constexpr const _CharT* _Parse_width(
    const _CharT* _First, const _CharT* _Last, _Callbacks_type&& _Callbacks) {
    ;
    if ('1' <= *_First && *_First <= '9') {
        int _Value = 0;
        _First     = _Parse_nonnegative_integer(_First, _Last, _Value);
        _Callbacks._On_width(_Value);
    } else if (*_First == '{') {
        ++_First;
        if (_First != _Last) {
            _First = _Parse_arg_id(_First, _Last, _Width_adapter<_CharT, _Callbacks_type>{_Callbacks});
        }

        if (_First == _Last || *_First != '}') {
            throw format_error("Invalid format string.");
        }
        ++_First;
    }
    return _First;
}

template <class _CharT, _Parse_precision_callbacks<_CharT> _Callbacks_type>
[[nodiscard]] constexpr const _CharT* _Parse_precision(
    const _CharT* _First, const _CharT* _Last, _Callbacks_type&& _Callbacks) {
    ++_First;
    _CharT _Ch = '\0';
    if (_First != _Last) {
        _Ch = *_First;
    }

    if ('0' <= _Ch && _Ch <= '9') {
        int _Precision = 0;
        _First         = _Parse_nonnegative_integer(_First, _Last, _Precision);
        _Callbacks._On_precision(_Precision);
    } else if (_Ch == '{') {
        ++_First;
        if (_First != _Last) {
            _First = _Parse_arg_id(_First, _Last, _Precision_adapter<_CharT, _Callbacks_type>{_Callbacks});
        }

        if (_First == _Last || *_First != '}') {
            throw format_error("Invalid format string.");
        }
        ++_First;
    } else {
        throw format_error("Missing precision specifier.");
    }

    return _First;
}

template <class _CharT, _Parse_spec_callbacks<_CharT> _Callbacks_type>
[[nodiscard]] constexpr const _CharT* _Parse_format_specs(
    const _CharT* _First, const _CharT* _Last, _Callbacks_type&& _Callbacks) {
    if (_First == _Last || *_First == '}') {
        return _First;
    }

    _First = _Parse_align(_First, _Last, _Callbacks);
    if (_First == _Last) {
        return _First;
    }

    switch (*_First) {
    case '+':
        _Callbacks._On_sign(_Fmt_sign::_Plus);
        ++_First;
        break;
    case '-':
        _Callbacks._On_sign(_Fmt_sign::_Minus);
        ++_First;
        break;
    case ' ':
        _Callbacks._On_sign(_Fmt_sign::_Space);
        ++_First;
        break;
    default:
        break;
    }

    if (_First == _Last) {
        return _First;
    }

    if (*_First == '#') {
        _Callbacks._On_hash();
        if (++_First == _Last) {
            return _First;
        }
    }

    if (*_First == '0') {
        _Callbacks._On_zero();
        if (++_First == _Last) {
            return _First;
        }
    }

    _First = _Parse_width(_First, _Last, _Callbacks);
    if (_First == _Last) {
        return _First;
    }

    if (*_First == '.') {
        _First = _Parse_precision(_First, _Last, _Callbacks);
        if (_First == _Last) {
            return _First;
        }
    }

    if (*_First == 'L') {
        _Callbacks._On_localized();
        if (++_First == _Last) {
            return _First;
        }
    }

    
    if (*_First != '}') {
        _Callbacks._On_type(*_First);
        ++_First;
    } else {
        
        
        _Callbacks._On_type(static_cast<_CharT>('\0'));
    }

    return _First;
}

template <class _CharT, _Parse_replacement_field_callbacks<_CharT> _HandlerT>
[[nodiscard]] constexpr const _CharT* _Parse_replacement_field(
    const _CharT* _First, const _CharT* _Last, _HandlerT&& _Handler) {
    ++_First;
    if (_First == _Last) {
        throw format_error("Invalid format string.");
    }

    if (*_First == '}') {
        
        _Handler._On_replacement_field(_Handler._Parse_context.next_arg_id(), _First);
    } else if (*_First == '{') {
        
        _Handler._On_text(_First, _First + 1);
    } else {
        _Id_adapter<_CharT> _Adapter{_Handler._Parse_context};
        _First     = _Parse_arg_id(_First, _Last, _Adapter);
        _CharT _Ch = _CharT{};
        if (_First != _Last) {
            _Ch = *_First;
        }

        if (_Ch == '}') {
            _Handler._On_replacement_field(_Adapter._Arg_id, _First);
        } else if (_Ch == ':') {
            _First = _Handler._On_format_specs(_Adapter._Arg_id, _First + 1, _Last);
            if (_First == _Last || *_First != '}') {
                throw format_error("Unknown format specifier.");
            }
        } else {
            throw format_error("Missing '}' in format string.");
        }
    }

    return _First + 1;
}

template <class _CharT, _Parse_replacement_field_callbacks<_CharT> _HandlerT>
constexpr void _Parse_format_string(basic_string_view<_CharT> _Format_str, _HandlerT&& _Handler) {
    auto _First = _Format_str.data();
    auto _Last  = _First + _Format_str.size();
    const _Fmt_codec<_CharT> _Codec;

    while (_First != _Last) {
        const _CharT* _OpeningCurl = _First;
        if (*_First != '{') {
            _OpeningCurl = _Codec._Find_encoded(_First, _Last, _CharT{'{'});

            for (;;) {
                const _CharT* _ClosingCurl = _Codec._Find_encoded(_First, _OpeningCurl, _CharT{'}'});

                
                if (_ClosingCurl == _OpeningCurl) {
                    _Handler._On_text(_First, _OpeningCurl);
                    break;
                }
                
                
                ++_ClosingCurl;
                if (_ClosingCurl == _OpeningCurl || *_ClosingCurl != '}') {
                    throw format_error("Unmatched '}' in format string.");
                }
                
                _Handler._On_text(_First, _ClosingCurl);

                
                _First = _ClosingCurl + 1;
            }

            
            if (_OpeningCurl == _Last) {
                return;
            }
        }
        
        _First = _Parse_replacement_field(_OpeningCurl, _Last, _Handler);
    }
}

template <class _CharT>
struct _Basic_format_specs {
    int _Width            = 0;
    int _Precision        = -1;
    char _Type            = '\0';
    _Fmt_align _Alignment = _Fmt_align::_None;
    _Fmt_sign _Sgn        = _Fmt_sign::_None;
    bool _Alt             = false;
    bool _Localized       = false;
    bool _Leading_zero    = false;
    uint8_t _Fill_length  = 1;
    
    _CharT _Fill[4 / sizeof(_CharT)] = {_CharT{' '}};
};


template <class _CharT>
struct _Dynamic_format_specs : _Basic_format_specs<_CharT> {
    int _Dynamic_width_index     = -1;
    int _Dynamic_precision_index = -1;
};


template <class _CharT>
class _Specs_setter {
public:
    constexpr explicit _Specs_setter(_Basic_format_specs<_CharT>& _Specs_) : _Specs(_Specs_) {}

    constexpr void _On_align(const _Fmt_align _Aln) {
        _Specs._Alignment = _Aln;
    }

    constexpr void _On_fill(const basic_string_view<_CharT> _Sv) {
        if (_Sv.size() > ::std:: size(_Specs._Fill)) {
            throw format_error("Invalid fill (too long).");
        }

        const auto _Pos = ::std:: _Copy_unchecked(_Sv._Unchecked_begin(), _Sv._Unchecked_end(), _Specs._Fill);
        ::std:: fill(_Pos, ::std:: end(_Specs._Fill), _CharT{});
        _Specs._Fill_length = static_cast<uint8_t>(_Sv.size());
    }

    constexpr void _On_sign(const _Fmt_sign _Sgn) {
        _Specs._Sgn = _Sgn;
    }

    constexpr void _On_hash() {
        _Specs._Alt = true;
    }

    constexpr void _On_zero() {
        _Specs._Leading_zero = true;
    }

    constexpr void _On_width(const int _Width) {
        _Specs._Width = _Width;
    }

    constexpr void _On_precision(const int _Precision) {
        _Specs._Precision = _Precision;
    }

    constexpr void _On_localized() {
        _Specs._Localized = true;
    }

    constexpr void _On_type(const _CharT _Type) {
        _Specs._Type = static_cast<char>(_Type);
    }

protected:
    _Basic_format_specs<_CharT>& _Specs;
};

template <class _Context>
[[nodiscard]] constexpr basic_format_arg<_Context> _Get_arg(const _Context& _Ctx, const size_t _Arg_id) {
    
    
    auto _Arg = _Ctx.arg(_Arg_id);
    if (!_Arg) {
        throw format_error("Argument not found.");
    }

    return _Arg;
}


class _Width_checker {
public:
    template <class _Ty>
    [[nodiscard]] constexpr unsigned long long operator()(const _Ty _Value) const {
        if constexpr (is_integral_v<_Ty>) {
            bool _Positive;
            if constexpr (same_as<_Ty, bool>) { 
                _Positive = _Value != 0;
            } else {
                _Positive = _Value > 0;
            }

            if (!_Positive) {
                throw format_error("width is not positive.");
            }
            return static_cast<unsigned long long>(_Value);
        } else {
            throw format_error("Width is not an integer.");
        }
    }
};


class _Precision_checker {
public:
    template <class _Ty>
    [[nodiscard]] constexpr unsigned long long operator()(const _Ty _Value) const {
        if constexpr (is_integral_v<_Ty>) {
            if constexpr (is_signed_v<_Ty>) {
                if (_Value < 0) {
                    throw format_error("Negative precision.");
                }
            }
            return static_cast<unsigned long long>(_Value);
        } else {
            throw format_error("Precision is not an integer.");
        }
    }
};


template <class _Handler, class _FormatArg>
[[nodiscard]] constexpr int _Get_dynamic_specs(const _FormatArg _Arg) {
    ;
    const unsigned long long _Val = ::std:: visit_format_arg(_Handler{}, _Arg);
    if (_Val > static_cast<unsigned long long>((numeric_limits<int>::max)())) {
        throw format_error("Number is too big.");
    }

    return static_cast<int>(_Val);
}


template <class _ParseContext, class _Context>
class _Specs_handler : public _Specs_setter<typename _Context::char_type> {
public:
    using _CharT = typename _Context::char_type;

    constexpr _Specs_handler(_Basic_format_specs<_CharT>& _Specs_, _ParseContext& _Parse_ctx_, _Context& _Ctx_)
        : _Specs_setter<_CharT>(_Specs_), _Parse_ctx(_Parse_ctx_), _Ctx(_Ctx_) {}

    template <class _Id>
    constexpr void _On_dynamic_width(const _Id _Arg_id) {
        this->_Specs._Width = _Get_dynamic_specs<_Width_checker>(_Get_arg(_Arg_id));
    }

    template <class _Id>
    constexpr void _On_dynamic_precision(const _Id _Arg_id) {
        this->_Specs._Precision = _Get_dynamic_specs<_Precision_checker>(_Get_arg(_Arg_id));
    }

private:
    _ParseContext& _Parse_ctx;
    _Context& _Ctx;

    [[nodiscard]] constexpr basic_format_arg<_Context> _Get_arg(_Auto_id_tag) {
        return ::std:: _Get_arg(_Ctx, _Parse_ctx.next_arg_id());
    }

    [[nodiscard]] constexpr basic_format_arg<_Context> _Get_arg(const size_t _Arg_id) {
        _Parse_ctx.check_arg_id(_Arg_id);
        return ::std:: _Get_arg(_Ctx, _Arg_id);
    }
};

template <class _ParseContext>
class _Dynamic_specs_handler : public _Specs_setter<typename _ParseContext::char_type> {
public:
    using _CharT = typename _ParseContext::char_type;

    constexpr _Dynamic_specs_handler(_Dynamic_format_specs<_CharT>& _Specs_, _ParseContext& _Parse_ctx_)
        : _Specs_setter<_CharT>(_Specs_), _Dynamic_specs(_Specs_), _Parse_ctx(_Parse_ctx_) {}

    constexpr void _On_dynamic_width(const size_t _Arg_id) {
        _Parse_ctx.check_arg_id(_Arg_id);
        _Dynamic_specs._Dynamic_width_index = _Verify_dynamic_arg_index_in_range(_Arg_id);
    }

    constexpr void _On_dynamic_width(const _Auto_id_tag) {
        _Dynamic_specs._Dynamic_width_index = _Verify_dynamic_arg_index_in_range(_Parse_ctx.next_arg_id());
    }

    constexpr void _On_dynamic_precision(const size_t _Arg_id) {
        _Parse_ctx.check_arg_id(_Arg_id);
        _Dynamic_specs._Dynamic_precision_index = _Verify_dynamic_arg_index_in_range(_Arg_id);
    }

    constexpr void _On_dynamic_precision(const _Auto_id_tag) {
        _Dynamic_specs._Dynamic_precision_index = _Verify_dynamic_arg_index_in_range(_Parse_ctx.next_arg_id());
    }

private:
    _Dynamic_format_specs<_CharT>& _Dynamic_specs;
    _ParseContext& _Parse_ctx;

    [[nodiscard]] static constexpr int _Verify_dynamic_arg_index_in_range(const size_t _Idx) {
        if (_Idx > static_cast<size_t>((numeric_limits<int>::max)())) {
            throw format_error("Dynamic width or precision index too large.");
        }

        return static_cast<int>(_Idx);
    }
};


template <class _Handler>
class _Specs_checker : public _Handler {
private:
    _Basic_format_arg_type _Arg_type;
    
    
    bool _Need_arithmetic_presentation_type = false;

public:
    constexpr explicit _Specs_checker(const _Handler& _Handler_inst, const _Basic_format_arg_type _Arg_type_)
        : _Handler(_Handler_inst), _Arg_type(_Arg_type_) {}

    constexpr void _Require_numeric_argument() const {
        if (!_Is_arithmetic_fmt_type(_Arg_type)) {
            throw format_error("Format specifier requires numeric argument.");
        }
    }

    constexpr void _Check_precision() const {
        if (_Is_integral_fmt_type(_Arg_type) || _Arg_type == _Basic_format_arg_type::_Pointer_type) {
            throw format_error("Precision not allowed for this argument type.");
        }
    }

    
    constexpr void _On_localized() {
        _Require_numeric_argument();
        _Handler::_On_localized();
    }

    constexpr void _On_hash() {
        _Need_arithmetic_presentation_type = true;
        _Require_numeric_argument();
        _Handler::_On_hash();
    }

    constexpr void _On_sign(_Fmt_sign _Sgn) {
        _Need_arithmetic_presentation_type = true;
        _Require_numeric_argument();
        _Handler::_On_sign(_Sgn);
    }

    constexpr void _On_zero() {
        _Need_arithmetic_presentation_type = true;
        _Require_numeric_argument();
        _Handler::_On_zero();
    }

    constexpr void _On_precision(int _Precision) {
        _Check_precision();
        _Handler::_On_precision(_Precision);
    }

    template <class _Ty>
    constexpr void _On_dynamic_precision(const _Ty _Val) {
        _Check_precision();
        _Handler::_On_dynamic_precision(_Val);
    }

    template <class _CharT>
    constexpr void _On_type(_CharT _Type) {
        if (_Type < 0 || _Type > (numeric_limits<signed char>::max)()) {
            throw format_error("Invalid type specification.");
        }
        const char _Narrow_type = static_cast<char>(_Type);
        enum class _Presentation_type_category { _Default, _Integer, _Floating, _String, _Pointer, _Char };
        auto _Cat = _Presentation_type_category::_Default;
        switch (_Narrow_type) {
        case '\0':
            break;
        case 's':
            _Cat = _Presentation_type_category::_String;
            break;
        case 'c':
            _Cat = _Presentation_type_category::_Char;
            break;
        case 'd':
        case 'B':
        case 'b':
        case 'X':
        case 'x':
        case 'o':
            _Cat = _Presentation_type_category::_Integer;
            break;
        case 'A':
        case 'a':
        case 'E':
        case 'e':
        case 'F':
        case 'f':
        case 'G':
        case 'g':
            _Cat = _Presentation_type_category::_Floating;
            break;
        case 'p':
            _Cat = _Presentation_type_category::_Pointer;
            break;
        default:
            throw format_error("Invalid presentation type specifier");
        }

        switch (_Arg_type) {
        case _Basic_format_arg_type::_None:
            ;
            break;
        case _Basic_format_arg_type::_Bool_type:
            if (_Cat == _Presentation_type_category::_Default) {
                _Cat = _Presentation_type_category::_String;
            }
            
            if (_Cat != _Presentation_type_category::_String && _Cat != _Presentation_type_category::_Integer) {
                throw format_error("Invalid presentation type for bool");
            }
            break;
        case _Basic_format_arg_type::_Char_type:
            if (_Cat == _Presentation_type_category::_Default) {
                _Cat = _Presentation_type_category::_Char;
            }

            if (_Cat != _Presentation_type_category::_Char && _Cat != _Presentation_type_category::_Integer) {
                throw format_error("Invalid presentation type for char/wchar_t");
            }
            break;
        case _Basic_format_arg_type::_Int_type:
        case _Basic_format_arg_type::_UInt_type:
        case _Basic_format_arg_type::_Long_long_type:
        case _Basic_format_arg_type::_ULong_long_type:
            if (_Cat == _Presentation_type_category::_Default) {
                _Cat = _Presentation_type_category::_Integer;
            }

            if (_Cat != _Presentation_type_category::_Integer && _Cat != _Presentation_type_category::_Char) {
                throw format_error("Invalid presentation type for integer");
            }
            break;
        case _Basic_format_arg_type::_Float_type:
        case _Basic_format_arg_type::_Double_type:
        case _Basic_format_arg_type::_Long_double_type:
            if (_Cat == _Presentation_type_category::_Default) {
                _Cat = _Presentation_type_category::_Floating;
            }

            if (_Cat != _Presentation_type_category::_Floating) {
                throw format_error("Invalid presentation type for floating-point");
            }
            break;
        case _Basic_format_arg_type::_CString_type:
        case _Basic_format_arg_type::_String_type:
            if (_Cat == _Presentation_type_category::_Default) {
                _Cat = _Presentation_type_category::_String;
            }

            if (_Cat != _Presentation_type_category::_String) {
                throw format_error("Invalid presentation type for string");
            }
            break;
        case _Basic_format_arg_type::_Pointer_type:
            if (_Cat == _Presentation_type_category::_Default) {
                _Cat = _Presentation_type_category::_Pointer;
            }

            if (_Cat != _Presentation_type_category::_Pointer) {
                throw format_error("Invalid presentation type for pointer");
            }
            break;
        case _Basic_format_arg_type::_Custom_type:
            
            
            break;
        }

        if (_Need_arithmetic_presentation_type && _Cat != _Presentation_type_category::_Integer
            && _Cat != _Presentation_type_category::_Floating) {
            throw format_error("Modifier requires an integer presentation type for bool");
        }
        _Handler::_On_type(_Type);
    }
};

template <class _Context>
struct _Format_arg_traits {
    using _Char_type = typename _Context::char_type;

    
    template <_Has_formatter<_Context> _Ty>
    static auto _Phony_basic_format_arg_constructor(_Ty&&) {
        
        using _Td = remove_cvref_t<_Ty>;
        
        if constexpr (is_same_v<_Td, bool>) {
            return bool{};
        } else if constexpr (is_same_v<_Td, _Char_type>) {
            return _Char_type{};
        } else if constexpr (is_same_v<_Td, char> && is_same_v<_Char_type, wchar_t>) {
            return _Char_type{};
        } else if constexpr (signed_integral<_Td> && sizeof(_Td) <= sizeof(int)) {
            return int{};
        } else if constexpr (unsigned_integral<_Td> && sizeof(_Td) <= sizeof(unsigned int)) {
            return static_cast<unsigned int>(42);
        } else if constexpr (signed_integral<_Td> && sizeof(_Td) <= sizeof(long long)) {
            return static_cast<long long>(42);
        } else if constexpr (unsigned_integral<_Td> && sizeof(_Td) <= sizeof(unsigned long long)) {
            return static_cast<unsigned long long>(42);
        } else {
            return typename basic_format_arg<_Context>::handle{42};
        }
    }

    static auto _Phony_basic_format_arg_constructor(float) -> float; 
    static auto _Phony_basic_format_arg_constructor(double) -> double; 
    static auto _Phony_basic_format_arg_constructor(long double) -> long double; 

    static auto _Phony_basic_format_arg_constructor(const _Char_type*) -> const _Char_type*; 

    template <class _Traits>
    static auto _Phony_basic_format_arg_constructor(basic_string_view<_Char_type, _Traits>)
        -> basic_string_view<_Char_type>; 

    template <class _Traits, class _Alloc>
    static auto _Phony_basic_format_arg_constructor(const basic_string<_Char_type, _Traits, _Alloc>&)
        -> basic_string_view<_Char_type>; 

    static auto _Phony_basic_format_arg_constructor(nullptr_t) -> const void*; 

    
    template <class _Ty>
        requires is_void_v<_Ty>
    static auto _Phony_basic_format_arg_constructor(_Ty*) -> const void*; 
    

    template <class _Ty>
    using _Storage_type = decltype(_Phony_basic_format_arg_constructor(::std:: declval<_Ty&>()));

    template <class _Ty>
    static constexpr size_t _Storage_size = sizeof(_Storage_type<_Ty>);
};

struct _Format_arg_index {
    

    constexpr _Format_arg_index() = default;
    constexpr explicit _Format_arg_index(const size_t _Index_) noexcept : _Index(_Index_) {
        _Type(_Basic_format_arg_type::_None);
    }

    [[nodiscard]] constexpr _Basic_format_arg_type _Type() const noexcept {
        return static_cast<_Basic_format_arg_type>(_Type_);
    }

    constexpr void _Type(_Basic_format_arg_type _Val) noexcept {
        _Type_ = static_cast<size_t>(_Val);
    }

    size_t _Index : (sizeof(size_t) * 8 - 4);
    size_t _Type_ : 4;
};

template <class _Context>
class basic_format_args;

template <class _Context, class... _Args>
class _Format_arg_store {
private:
    using _CharType = typename _Context::char_type;
    using _Traits   = _Format_arg_traits<_Context>;

    friend basic_format_args<_Context>;

    static constexpr size_t _Num_args       = sizeof...(_Args);
    static constexpr size_t _Storage_length = (_Traits::template _Storage_size<_Args> + ...);

    
    _Format_arg_index _Index_array[_Num_args];
    unsigned char _Storage[_Storage_length];

    template <class _Ty>
    void _Store_impl(
        const size_t _Arg_index, const _Basic_format_arg_type _Arg_type, const type_identity_t<_Ty>& _Val) noexcept {
        ;

        const auto _Store_index = _Index_array[_Arg_index]._Index;

        :: memcpy(_Storage + _Store_index, ::std:: addressof(_Val), sizeof(_Ty));
        _Index_array[_Arg_index]._Type(_Arg_type);
        if (_Arg_index + 1 < _Num_args) {
            
#pragma warning(suppress : 6386) 
            _Index_array[_Arg_index + 1] = _Format_arg_index{_Store_index + sizeof(_Ty)};
        }
    }

    template <class _Ty>
    void _Store(const size_t _Arg_index, _Ty&& _Val) noexcept {
        using _Erased_type = typename _Traits::template _Storage_type<_Ty>;

        _Basic_format_arg_type _Arg_type;
        if constexpr (is_same_v<_Erased_type, bool>) {
            _Arg_type = _Basic_format_arg_type::_Bool_type;
        } else if constexpr (is_same_v<_Erased_type, _CharType>) {
            _Arg_type = _Basic_format_arg_type::_Char_type;
        } else if constexpr (is_same_v<_Erased_type, int>) {
            _Arg_type = _Basic_format_arg_type::_Int_type;
        } else if constexpr (is_same_v<_Erased_type, unsigned int>) {
            _Arg_type = _Basic_format_arg_type::_UInt_type;
        } else if constexpr (is_same_v<_Erased_type, long long>) {
            _Arg_type = _Basic_format_arg_type::_Long_long_type;
        } else if constexpr (is_same_v<_Erased_type, unsigned long long>) {
            _Arg_type = _Basic_format_arg_type::_ULong_long_type;
        } else if constexpr (is_same_v<_Erased_type, float>) {
            _Arg_type = _Basic_format_arg_type::_Float_type;
        } else if constexpr (is_same_v<_Erased_type, double>) {
            _Arg_type = _Basic_format_arg_type::_Double_type;
        } else if constexpr (is_same_v<_Erased_type, long double>) {
            _Arg_type = _Basic_format_arg_type::_Long_double_type;
        } else if constexpr (is_same_v<_Erased_type, const void*>) {
            _Arg_type = _Basic_format_arg_type::_Pointer_type;
        } else if constexpr (is_same_v<_Erased_type, const _CharType*>) {
            _Arg_type = _Basic_format_arg_type::_CString_type;
        } else if constexpr (is_same_v<_Erased_type, basic_string_view<_CharType>>) {
            _Arg_type = _Basic_format_arg_type::_String_type;
        } else {
            ;
            _Arg_type = _Basic_format_arg_type::_Custom_type;
        }

        _Store_impl<_Erased_type>(_Arg_index, _Arg_type, static_cast<_Erased_type>(_Val));
    }

public:
    _Format_arg_store(_Args&... _Vals) noexcept {
        _Index_array[0]   = {};
        size_t _Arg_index = 0;
        (_Store(_Arg_index++, _Vals), ...);
    }
};

template <class _Context>
class _Format_arg_store<_Context> {};

template <class _Context>
class basic_format_args {
public:
    basic_format_args() noexcept = default;

    basic_format_args(const _Format_arg_store<_Context>&) noexcept {}

    template <class... _Args>
    basic_format_args(const _Format_arg_store<_Context, _Args...>& _Store) noexcept
        : _Num_args(sizeof...(_Args)), _Index_array(_Store._Index_array) {}

    [[nodiscard]] basic_format_arg<_Context> get(const size_t _Index) const noexcept {
        if (_Index >= _Num_args) {
            return basic_format_arg<_Context>{};
        }

        using _CharType = typename _Context::char_type;
        
        const auto _Packed_index = _Index_array[_Index];
        const auto _Arg_storage =
            reinterpret_cast<const unsigned char*>(_Index_array + _Num_args) + _Packed_index._Index;

        switch (_Packed_index._Type()) {
        case _Basic_format_arg_type::_None:
        default:
            ;
            return basic_format_arg<_Context>{};
        case _Basic_format_arg_type::_Int_type:
            return basic_format_arg<_Context>{_Get_value_from_memory<int>(_Arg_storage)};
        case _Basic_format_arg_type::_UInt_type:
            return basic_format_arg<_Context>{_Get_value_from_memory<unsigned int>(_Arg_storage)};
        case _Basic_format_arg_type::_Long_long_type:
            return basic_format_arg<_Context>{_Get_value_from_memory<long long>(_Arg_storage)};
        case _Basic_format_arg_type::_ULong_long_type:
            return basic_format_arg<_Context>{_Get_value_from_memory<unsigned long long>(_Arg_storage)};
        case _Basic_format_arg_type::_Bool_type:
            return basic_format_arg<_Context>{_Get_value_from_memory<bool>(_Arg_storage)};
        case _Basic_format_arg_type::_Char_type:
            return basic_format_arg<_Context>{_Get_value_from_memory<_CharType>(_Arg_storage)};
        case _Basic_format_arg_type::_Float_type:
            return basic_format_arg<_Context>{_Get_value_from_memory<float>(_Arg_storage)};
        case _Basic_format_arg_type::_Double_type:
            return basic_format_arg<_Context>{_Get_value_from_memory<double>(_Arg_storage)};
        case _Basic_format_arg_type::_Long_double_type:
            return basic_format_arg<_Context>{_Get_value_from_memory<long double>(_Arg_storage)};
        case _Basic_format_arg_type::_Pointer_type:
            return basic_format_arg<_Context>{_Get_value_from_memory<const void*>(_Arg_storage)};
        case _Basic_format_arg_type::_CString_type:
            return basic_format_arg<_Context>{_Get_value_from_memory<const _CharType*>(_Arg_storage)};
        case _Basic_format_arg_type::_String_type:
            return basic_format_arg<_Context>{_Get_value_from_memory<basic_string_view<_CharType>>(_Arg_storage)};
        case _Basic_format_arg_type::_Custom_type:
            return basic_format_arg<_Context>{
                _Get_value_from_memory<typename basic_format_arg<_Context>::handle>(_Arg_storage)};
        }
    }

    [[nodiscard]] size_t _Estimate_required_capacity() const noexcept {
        using _CharT        = typename _Context::char_type;
        size_t _Result      = 0;
        const auto _Visitor = [&_Result]<class _ArgTy>(const _ArgTy _Arg) noexcept {
            if constexpr (is_same_v<_ArgTy, basic_string_view<_CharT>>) {
                _Result += _Arg.size();
            } else if constexpr (is_same_v<_ArgTy, const _CharT*>) {
                _Result += 32; 
            } else {
                _Result += 8; 
            }
        };
        for (size_t _Idx = 0; _Idx < _Num_args; ++_Idx) {
            ::std:: visit_format_arg(_Visitor, get(_Idx));
        }
        return _Result;
    }

private:
    template <class _Ty>
    [[nodiscard]] static auto _Get_value_from_memory(const unsigned char* const _Val) noexcept {
        auto& _Temp = *reinterpret_cast<const unsigned char(*)[sizeof(_Ty)]>(_Val);
        return _Bit_cast<_Ty>(_Temp);
    }

    size_t _Num_args                      = 0;
    const _Format_arg_index* _Index_array = nullptr;
};


class _Lazy_locale {
private:
    const locale* _Loc = nullptr;

public:
    _Lazy_locale() = default;

    explicit _Lazy_locale(const locale& _Loc_) : _Loc(&_Loc_) {}

    explicit _Lazy_locale(const locale&&) = delete;

    [[nodiscard]] locale _Get() const {
        if (_Loc) {
            return *_Loc;
        } else {
            return locale{};
        }
    }
};


template <class _Out, class _CharT>
    requires output_iterator<_Out, const _CharT&>
class basic_format_context {
    
private:
    _Out _OutputIt;
    basic_format_args<basic_format_context> _Args;
    _Lazy_locale _Loc;

public:
    using iterator  = _Out;
    using char_type = _CharT;

    template <class _Ty>
    using formatter_type = formatter<_Ty, _CharT>;

    constexpr basic_format_context(_Out _OutputIt_, basic_format_args<basic_format_context> _Ctx_args)
        : _OutputIt(::std:: move(_OutputIt_)), _Args(_Ctx_args) {}

    constexpr basic_format_context(
        _Out _OutputIt_, basic_format_args<basic_format_context> _Ctx_args, const _Lazy_locale& _Loc_)
        : _OutputIt(::std:: move(_OutputIt_)), _Args(_Ctx_args), _Loc(_Loc_) {}

    [[nodiscard]] basic_format_arg<basic_format_context> arg(size_t _Id) const noexcept {
        return _Args.get(_Id);
    }
    [[nodiscard]] locale locale() {
        return _Loc._Get();
    }
    [[nodiscard]] iterator out() {
        return ::std:: move(_OutputIt);
    }
    void advance_to(iterator _It) {
        _OutputIt = ::std:: move(_It);
    }

    [[nodiscard]] const basic_format_args<basic_format_context>& _Get_args() const noexcept {
        return _Args;
    }
    [[nodiscard]] _Lazy_locale _Get_lazy_locale() const {
        return _Loc;
    }
};

template <class _Ty>
class _Fmt_buffer {
private:
    _Ty* _Ptr_        = nullptr;
    size_t _Size_     = 0;
    size_t _Capacity_ = 0;

protected:
    explicit _Fmt_buffer(const size_t _Size) noexcept : _Size_(_Size), _Capacity_(_Size) {}

    ~_Fmt_buffer() = default;

    _Fmt_buffer(_Ty* _Data, const size_t _Size, const size_t _Capacity) noexcept
        : _Ptr_(_Data), _Size_(_Size), _Capacity_(_Capacity) {}

    void _Set(_Ty* _Buf_data, const size_t _Buf_capacity) noexcept {
        _Ptr_      = _Buf_data;
        _Capacity_ = _Buf_capacity;
    }

    virtual void _Grow(size_t _Capacity) = 0;

public:
    using value_type = _Ty;

    _Fmt_buffer(const _Fmt_buffer&) = delete;
    void operator=(const _Fmt_buffer&) = delete;

    [[nodiscard]] _Ty* begin() noexcept {
        return _Ptr_;
    }

    [[nodiscard]] _Ty* end() noexcept {
        return _Ptr_ + _Size_;
    }

    [[nodiscard]] size_t _Size() const noexcept {
        return _Size_;
    }

    [[nodiscard]] size_t _Capacity() const noexcept {
        return _Capacity_;
    }

    void _Clear() noexcept {
        _Size_ = 0;
    }

    void _Try_resize(const size_t _Count) {
        _Try_reserve(_Count);
        _Size_ = _Count <= _Capacity_ ? _Count : _Capacity_;
    }

    void _Try_reserve(const size_t _New_capacity) {
        if (_New_capacity > _Capacity_) {
            _Grow(_New_capacity);
        }
    }

    void push_back(const _Ty _Value) {
        _Try_reserve(_Size_ + 1);
        _Ptr_[_Size_++] = _Value;
    }
};

struct _Fmt_buffer_traits {
    explicit _Fmt_buffer_traits(ptrdiff_t) {}

    [[nodiscard]] size_t _Count() const noexcept {
        return 0;
    }

    [[nodiscard]] size_t _Limit(const size_t _Size) noexcept {
        return _Size;
    }
};

class _Fmt_fixed_buffer_traits {
private:
    ptrdiff_t _Count_ = 0;
    ptrdiff_t _Limit_;

public:
    explicit _Fmt_fixed_buffer_traits(const ptrdiff_t _Limit) noexcept : _Limit_(_Limit) {}

    [[nodiscard]] size_t _Count() const noexcept {
        return static_cast<size_t>(_Count_);
    }

    [[nodiscard]] size_t _Limit(const size_t _Size) noexcept {
        size_t _Avail = static_cast<size_t>(_Limit_ > _Count_ ? _Limit_ - _Count_ : 0);
        _Count_ += _Size;
        return _Size < _Avail ? _Size : _Avail;
    }
};

inline constexpr size_t _Fmt_buffer_size = 256;

template <class _Iterator>
struct _Back_insert_iterator_container_type {
    using type = void;
};

template <class _Container>
struct _Back_insert_iterator_container_type<back_insert_iterator<_Container>> {
    using type = _Container;
};

template <class _Container>
struct _Back_insert_iterator_container_access : back_insert_iterator<_Container> {
    explicit _Back_insert_iterator_container_access(back_insert_iterator<_Container> _Iter)
        : back_insert_iterator<_Container>(_Iter) {}

    using back_insert_iterator<_Container>::container;
};

template <class _OutputIt, class _Ty, class _Traits = _Fmt_buffer_traits>
class _Fmt_iterator_buffer final : public _Traits, public _Fmt_buffer<_Ty> {
private:
    _OutputIt _Output;
    _Ty _Data[_Fmt_buffer_size];

    void _Grow(size_t) final {
        if (this->_Size() == _Fmt_buffer_size) {
            _Flush();
        }
    }

    void _Flush() {
        auto _Size = this->_Size();
        this->_Clear();
        const auto _End = _Data + this->_Limit(_Size);

        
        using _Container = typename _Back_insert_iterator_container_type<_OutputIt>::type;
        if constexpr (_Is_specialization_v<_Container, basic_string> || _Is_specialization_v<_Container, vector>) {
            auto& _Cont = *_Back_insert_iterator_container_access<_Container>{_Output}.container;
            _Cont.insert(_Cont.end(), _Data, _End);
        } else {
            _Output = ::std:: _Copy_unchecked(_Data, _End, ::std:: move(_Output));
        }
    }

public:
    explicit _Fmt_iterator_buffer(_OutputIt _Out, ptrdiff_t _Size = _Fmt_buffer_size)
        : _Traits(_Size), _Fmt_buffer<_Ty>(_Data, 0, _Fmt_buffer_size), _Output(::std:: move(_Out)) {}

    ~_Fmt_iterator_buffer() {
        if (this->_Size() != 0) {
            _Flush();
        }
    }

    [[nodiscard]] _OutputIt _Out() {
        _Flush();
        return ::std:: move(_Output);
    }

    [[nodiscard]] ptrdiff_t _Count() const noexcept {
        return static_cast<ptrdiff_t>(_Traits::_Count() + this->_Size());
    }
};

template <class _Ty>
class _Fmt_iterator_buffer<_Ty*, _Ty> final : public _Fmt_buffer<_Ty> {
private:
    void _Grow(size_t) final {}

public:
    explicit _Fmt_iterator_buffer(_Ty* _Out, ptrdiff_t = 0) : _Fmt_buffer<_Ty>(_Out, 0, ~size_t{}) {}

    [[nodiscard]] _Ty* _Out() noexcept {
        return this->end();
    }
};

template <class _Ty>
class _Fmt_counting_buffer final : public _Fmt_buffer<_Ty> {
private:
    _Ty _Data[_Fmt_buffer_size];
    size_t _Count_ = 0;

    void _Grow(size_t) final {
        if (this->_Size() != _Fmt_buffer_size) {
            return;
        }
        _Count_ += this->_Size();
        this->_Clear();
    }

public:
    _Fmt_counting_buffer() : _Fmt_buffer<_Ty>(_Data, 0, _Fmt_buffer_size) {}

    [[nodiscard]] size_t _Count() const noexcept {
        return _Count_ + this->_Size();
    }
};

using _Fmt_it  = back_insert_iterator<_Fmt_buffer<char>>;
using _Fmt_wit = back_insert_iterator<_Fmt_buffer<wchar_t>>;

using format_context  = basic_format_context<_Fmt_it, char>;
using wformat_context = basic_format_context<_Fmt_wit, wchar_t>;

template <class _CharT, class _OutputIt>
[[nodiscard]] _OutputIt _Fmt_write(_OutputIt _Out, monostate) {
    ;
    return _Out;
}


inline constexpr size_t _Format_min_buffer_length = 24;


template <class _CharT, class _OutputIt, class _Arithmetic>
    requires (is_arithmetic_v<_Arithmetic> && !_CharT_or_bool<_Arithmetic, _CharT>)
[[nodiscard]] _OutputIt _Fmt_write(_OutputIt _Out, _Arithmetic _Value);


template <class _CharT, class _OutputIt>
[[nodiscard]] _OutputIt _Fmt_write(_OutputIt _Out, bool _Value);

template <class _CharT, class _OutputIt>
[[nodiscard]] _OutputIt _Fmt_write(_OutputIt _Out, _CharT _Value);

template <class _CharT, class _OutputIt>
[[nodiscard]] _OutputIt _Fmt_write(_OutputIt _Out, const void* _Value);

template <class _CharT, class _OutputIt>
[[nodiscard]] _OutputIt _Fmt_write(_OutputIt _Out, const _CharT* _Value);

template <class _CharT, class _OutputIt>
[[nodiscard]] _OutputIt _Fmt_write(_OutputIt _Out, basic_string_view<_CharT> _Value);

template <class _CharT>
struct _Widen_char {
    [[nodiscard]] _CharT operator()(const char _Ch) const noexcept {
        return static_cast<_CharT>(_Ch);
    }
};


template <class _CharT, class _OutputIt, class _Arithmetic>
    requires (is_arithmetic_v<_Arithmetic> && !_CharT_or_bool<_Arithmetic, _CharT>)
[[nodiscard]] _OutputIt _Fmt_write(_OutputIt _Out, const _Arithmetic _Value) {
    
    
    char _Buffer[_Format_min_buffer_length];
    const auto [_End, _Ec] = ::std:: to_chars(_Buffer, ::std:: end(_Buffer), _Value);
    ;
    return ::std::ranges:: transform(_Buffer, _End, ::std:: move(_Out), _Widen_char<_CharT>{}).out;
}

template <class _CharT, class _OutputIt>
[[nodiscard]] _OutputIt _Fmt_write(_OutputIt _Out, const bool _Value) {
    if constexpr (is_same_v<_CharT, wchar_t>) {
        return _Fmt_write(::std:: move(_Out), _Value ? L"true" : L"false");
    } else {
        return _Fmt_write(::std:: move(_Out), _Value ? "true" : "false");
    }
}

template <class _CharT, class _OutputIt>
[[nodiscard]] _OutputIt _Fmt_write(_OutputIt _Out, const _CharT _Value) {
    *_Out++ = _Value;
    return _Out;
}

template <class _CharT, class _OutputIt>
[[nodiscard]] _OutputIt _Fmt_write(_OutputIt _Out, const void* const _Value) {
    
    char _Buffer[_Format_min_buffer_length];
    const auto [_End, _Ec] = ::std:: to_chars(_Buffer, ::std:: end(_Buffer), reinterpret_cast<uintptr_t>(_Value), 16);
    ;
    *_Out++ = '0';
    *_Out++ = 'x';
    return ::std::ranges:: transform(_Buffer, _End, ::std:: move(_Out), _Widen_char<_CharT>{}).out;
}

template <class _CharT, class _OutputIt>
[[nodiscard]] _OutputIt _Fmt_write(_OutputIt _Out, const _CharT* _Value) {
    if (!_Value) {
        throw format_error("String pointer is null.");
    }

    while (*_Value) {
        *_Out++ = *_Value++;
    }

    return _Out;
}

template <class _CharT, class _OutputIt>
[[nodiscard]] _OutputIt _Fmt_write(_OutputIt _Out, const basic_string_view<_CharT> _Value) {
    return ::std::ranges:: copy(_Value, ::std:: move(_Out)).out;
}

template <class _OutputIt, class _Specs_type, class _Func>
[[nodiscard]] _OutputIt _Write_aligned(
    _OutputIt _Out, const int _Width, const _Specs_type& _Specs, const _Fmt_align _Default_align, _Func&& _Fn) {
    int _Fill_left  = 0;
    int _Fill_right = 0;
    auto _Alignment = _Specs._Alignment;

    if (_Alignment == _Fmt_align::_None) {
        _Alignment = _Default_align;
    }

    if (_Width < _Specs._Width) {
        switch (_Alignment) {
        case _Fmt_align::_Left:
            _Fill_right = _Specs._Width - _Width;
            break;
        case _Fmt_align::_Right:
            _Fill_left = _Specs._Width - _Width;
            break;
        case _Fmt_align::_Center:
            _Fill_left  = (_Specs._Width - _Width) / 2;
            _Fill_right = _Specs._Width - _Width - _Fill_left;
            break;
        case _Fmt_align::_None:
            ;
            break;
        }
    }

    const basic_string_view _Fill_char{_Specs._Fill, _Specs._Fill_length};
    for (; _Fill_left > 0; --_Fill_left) {
        _Out = ::std::ranges:: copy(_Fill_char, ::std:: move(_Out)).out;
    }

    _Out = _Fn(::std:: move(_Out));

    for (; _Fill_right > 0; --_Fill_right) {
        _Out = ::std::ranges:: copy(_Fill_char, ::std:: move(_Out)).out;
    }

    return _Out;
}

template <integral _Integral>
[[nodiscard]] constexpr string_view _Get_integral_prefix(const char _Type, const _Integral _Value) noexcept {
    switch (_Type) {
    case 'b':
        return "0b"sv;
    case 'B':
        return "0B"sv;
    case 'x':
        return "0x"sv;
    case 'X':
        return "0X"sv;
    case 'o':
        if (_Value != _Integral{0}) {
            return "0"sv;
        }
        return {};
    default:
        return {};
    }
}

template <class _OutputIt>
[[nodiscard]] _OutputIt _Write_sign(_OutputIt _Out, const _Fmt_sign _Sgn, const bool _Is_negative) {
    if (_Is_negative) {
        *_Out++ = '-';
    } else {
        switch (_Sgn) {
        case _Fmt_sign::_Plus:
            *_Out++ = '+';
            break;
        case _Fmt_sign::_Space:
            *_Out++ = ' ';
            break;
        case _Fmt_sign::_None:
        case _Fmt_sign::_Minus:
            break;
        }
    }
    return _Out;
}

inline void _Buffer_to_uppercase(char* _First, const char* _Last) {
    for (; _First != _Last; ++_First) {
        *_First = static_cast<char>(:: toupper(*_First));
    }
}

template <class _Ty>
using _Make_standard_integer = conditional_t<is_signed_v<_Ty>, make_signed_t<_Ty>, make_unsigned_t<_Ty>>;

template <class _CharT, integral _Ty>
[[nodiscard]] constexpr bool _In_bounds(const _Ty _Value) {
    return ::std:: in_range<_Make_standard_integer<_CharT>>(static_cast<_Make_standard_integer<_Ty>>(_Value));
}

[[nodiscard]] inline int _Count_separators(size_t _Digits, const string_view _Groups) {
    if (_Groups.empty()) {
        return 0;
    }

    
    int _Separators = 0;
    auto _Group_it  = _Groups.begin();
    while (_Digits > static_cast<size_t>(*_Group_it)) {
        _Digits -= static_cast<size_t>(*_Group_it);
        ++_Separators;
        if (_Group_it + 1 != _Groups.end()) {
            ++_Group_it;
        }
    }

    return _Separators;
}

template <class _CharT, class _OutputIt>
[[nodiscard]] _OutputIt _Write_separated_integer(const char* _First, const char* const _Last, const string_view _Groups,
    const _CharT _Separator, int _Separators, _OutputIt _Out) {
    auto _Group_it = _Groups.begin();
    auto _Repeats  = 0;
    auto _Grouped  = 0;

    for (int _Section = 0; _Section < _Separators; ++_Section) {
        _Grouped += *_Group_it;
        if (_Group_it + 1 != _Groups.end()) {
            ++_Group_it;
        } else {
            ++_Repeats;
        }
    }
    _Out   = ::std::ranges:: transform(_First, _Last - _Grouped, ::std:: move(_Out), _Widen_char<_CharT>{}).out;
    _First = _Last - _Grouped;

    for (; _Separators > 0; --_Separators) {
        if (_Repeats > 0) {
            --_Repeats;
        } else {
            --_Group_it;
        }

        *_Out++ = _Separator;
        _Out    = ::std::ranges:: transform(_First, _First + *_Group_it, ::std:: move(_Out), _Widen_char<_CharT>{}).out;
        _First += *_Group_it;
    }
    ;
    return _Out;
}

template <class _CharT, class _OutputIt>
[[nodiscard]] _OutputIt _Fmt_write(_OutputIt _Out, monostate, const _Basic_format_specs<_CharT>&, _Lazy_locale) {
    ;
    return _Out;
}

template <class _CharT, class _OutputIt, integral _Integral>
[[nodiscard]] _OutputIt _Write_integral(
    _OutputIt _Out, _Integral _Value, _Basic_format_specs<_CharT> _Specs, _Lazy_locale _Locale);


template <class _CharT, class _OutputIt, integral _Integral>
    requires (!_CharT_or_bool<_Integral, _CharT>)
[[nodiscard]] _OutputIt _Fmt_write(
    _OutputIt _Out, _Integral _Value, const _Basic_format_specs<_CharT>& _Specs, _Lazy_locale _Locale);


template <class _CharT, class _OutputIt>
[[nodiscard]] _OutputIt _Fmt_write(_OutputIt _Out, bool _Value, _Basic_format_specs<_CharT> _Specs, _Lazy_locale _Locale);

template <class _CharT, class _OutputIt>
[[nodiscard]] _OutputIt _Fmt_write(
    _OutputIt _Out, _CharT _Value, _Basic_format_specs<_CharT> _Specs, _Lazy_locale _Locale);


template <class _CharT, class _OutputIt, floating_point _Float>
[[nodiscard]] _OutputIt _Fmt_write(
    _OutputIt _Out, _Float _Value, const _Basic_format_specs<_CharT>& _Specs, _Lazy_locale _Locale);

template <class _CharT, class _OutputIt>
[[nodiscard]] _OutputIt _Fmt_write(
    _OutputIt _Out, const void* _Value, const _Basic_format_specs<_CharT>& _Specs, _Lazy_locale);

template <class _CharT, class _OutputIt>
[[nodiscard]] _OutputIt _Fmt_write(
    _OutputIt _Out, const _CharT* _Value, const _Basic_format_specs<_CharT>& _Specs, _Lazy_locale _Locale);

template <class _CharT, class _OutputIt>
[[nodiscard]] _OutputIt _Fmt_write(
    _OutputIt _Out, basic_string_view<_CharT> _Value, const _Basic_format_specs<_CharT>& _Specs, _Lazy_locale);

template <class _CharT, class _OutputIt, integral _Integral>
[[nodiscard]] _OutputIt _Write_integral(
    _OutputIt _Out, const _Integral _Value, _Basic_format_specs<_CharT> _Specs, _Lazy_locale _Locale) {
    if (_Specs._Type == 'c') {
        if (!_In_bounds<_CharT>(_Value)) {
            throw format_error("integral cannot be stored in charT");
        }
        _Specs._Alt = false;
        return _Fmt_write(::std:: move(_Out), static_cast<_CharT>(_Value), _Specs, _Locale);
    }

    ;

    if (_Specs._Sgn == _Fmt_sign::_None) {
        _Specs._Sgn = _Fmt_sign::_Minus;
    }

    int _Base      = 10;
    bool _To_upper = false;

    switch (_Specs._Type) {
    case 'B':
        _To_upper = true;
        [[fallthrough]];
    case 'b':
        _Base = 2;
        break;
    case 'X':
        _To_upper = true;
        [[fallthrough]];
    case 'x':
        _Base = 16;
        break;
    case 'o':
        _Base = 8;
        break;
    }

    
    char _Buffer[65];
    const auto [_End, _Ec] = ::std:: to_chars(_Buffer, ::std:: end(_Buffer), _Value, _Base);
    ;

    auto _Buffer_start = _Buffer;
    auto _Width        = static_cast<int>(_End - _Buffer_start);

    if (_Value >= _Integral{0}) {
        if (_Specs._Sgn != _Fmt_sign::_Minus) {
            _Width += 1;
        }
    } else {
        
        _Buffer_start += 1;
    }

    if (_To_upper) {
        _Buffer_to_uppercase(_Buffer_start, _End);
    }

    string_view _Prefix;
    if (_Specs._Alt) {
        _Prefix = _Get_integral_prefix(_Specs._Type, _Value);
        _Width += static_cast<int>(_Prefix.size());
    }

    auto _Separators = 0;
    string _Groups;
    if (_Specs._Localized) {
        _Groups     = ::std:: use_facet<numpunct<_CharT>>(_Locale._Get()).grouping();
        _Separators = _Count_separators(static_cast<size_t>(_End - _Buffer_start), _Groups);
        
        _Width += _Separators;
    }

    const bool _Write_leading_zeroes = _Specs._Leading_zero && _Specs._Alignment == _Fmt_align::_None;
    auto _Writer                     = [&, _End = _End](_OutputIt _Out) {
#pragma warning(push)
#pragma warning(disable : 4296) 
        _Out = _Write_sign(::std:: move(_Out), _Specs._Sgn, _Value < _Integral{0});
#pragma warning(pop)
        _Out = ::std::ranges:: transform(_Prefix, ::std:: move(_Out), _Widen_char<_CharT>{}).out;
        if (_Write_leading_zeroes && _Width < _Specs._Width) {
            _Out = ::std::ranges:: fill_n(::std:: move(_Out), _Specs._Width - _Width, _CharT{'0'});
        }

        if (_Separators > 0) {
            return _Write_separated_integer(_Buffer_start, _End, _Groups,
                                    ::std:: use_facet<numpunct<_CharT>>(_Locale._Get()).thousands_sep(), 
                                    _Separators, ::std:: move(_Out));
        }
        return ::std::ranges:: transform(_Buffer_start, _End, ::std:: move(_Out), _Widen_char<_CharT>{}).out;
    };

    if (_Write_leading_zeroes) {
        return _Writer(::std:: move(_Out));
    }

    return _Write_aligned(::std:: move(_Out), _Width, _Specs, _Fmt_align::_Right, _Writer);
}


template <class _CharT, class _OutputIt, integral _Integral>
    requires (!_CharT_or_bool<_Integral, _CharT>)
[[nodiscard]] _OutputIt _Fmt_write(
    _OutputIt _Out, const _Integral _Value, const _Basic_format_specs<_CharT>& _Specs, _Lazy_locale _Locale) {
    
    return _Write_integral(::std:: move(_Out), _Value, _Specs, _Locale);
}

template <class _CharT, class _OutputIt>
[[nodiscard]] _OutputIt _Fmt_write(
    _OutputIt _Out, const bool _Value, _Basic_format_specs<_CharT> _Specs, _Lazy_locale _Locale) {
    if (_Specs._Type != '\0' && _Specs._Type != 's') {
        return _Write_integral(::std:: move(_Out), static_cast<unsigned char>(_Value), _Specs, _Locale);
    }

    ;

    if (_Specs._Localized) {
        _Specs._Localized  = false;
        const auto& _Facet = ::std:: use_facet<numpunct<_CharT>>(_Locale._Get());
        return _Fmt_write(::std:: move(_Out),
            _Value ? static_cast<basic_string_view<_CharT>>(_Facet.truename())
                   : static_cast<basic_string_view<_CharT>>(_Facet.falsename()),
            _Specs, _Locale);
    }

    if constexpr (is_same_v<_CharT, wchar_t>) {
        return _Fmt_write(::std:: move(_Out), _Value ? L"true" : L"false", _Specs, _Locale);
    } else {
        return _Fmt_write(::std:: move(_Out), _Value ? "true" : "false", _Specs, _Locale);
    }
}

template <class _CharT, class _OutputIt>
[[nodiscard]] _OutputIt _Fmt_write(
    _OutputIt _Out, const _CharT _Value, _Basic_format_specs<_CharT> _Specs, _Lazy_locale _Locale) {
    if (_Specs._Type != '\0' && _Specs._Type != 'c') {
        return _Write_integral(::std:: move(_Out), _Value, _Specs, _Locale);
    }

    ;

    return _Fmt_write(::std:: move(_Out), basic_string_view<_CharT>{&_Value, 1}, _Specs, _Locale);
}

template <class _CharT, class _OutputIt, floating_point _Float>
[[nodiscard]] _OutputIt _Fmt_write(
    _OutputIt _Out, const _Float _Value, const _Basic_format_specs<_CharT>& _Specs, _Lazy_locale _Locale) {
    auto _Sgn = _Specs._Sgn;
    if (_Sgn == _Fmt_sign::_None) {
        _Sgn = _Fmt_sign::_Minus;
    }

    auto _To_upper  = false;
    auto _Format    = chars_format::general;
    auto _Exponent  = '\0';
    auto _Precision = _Specs._Precision;

    switch (_Specs._Type) {
    case 'A':
        _To_upper = true;
        [[fallthrough]];
    case 'a':
        _Format   = chars_format::hex;
        _Exponent = 'p';
        break;
    case 'E':
        _To_upper = true;
        [[fallthrough]];
    case 'e':
        if (_Precision == -1) {
            _Precision = 6;
        }
        _Format   = chars_format::scientific;
        _Exponent = 'e';
        break;
    case 'F':
        _To_upper = true;
        [[fallthrough]];
    case 'f':
        if (_Precision == -1) {
            _Precision = 6;
        }
        _Format = chars_format::fixed;
        break;
    case 'G':
        _To_upper = true;
        [[fallthrough]];
    case 'g':
        if (_Precision == -1) {
            _Precision = 6;
        }
        _Format   = chars_format::general;
        _Exponent = 'e';
        break;
    }

    
    constexpr auto _Max_precision = 1074;
    constexpr auto _Buffer_size   = _Max_precision + 308 + 3;
    char _Buffer[_Buffer_size];
    to_chars_result _Result;

    auto _Extra_precision = 0;
    if (_Precision > _Max_precision) {
        _Extra_precision = _Precision - _Max_precision;
        _Precision       = _Max_precision;
    }

    if (_Precision == -1) {
        _Result = ::std:: to_chars(_Buffer, ::std:: end(_Buffer), _Value, _Format);
    } else {
        _Result = ::std:: to_chars(_Buffer, ::std:: end(_Buffer), _Value, _Format, _Precision);
    }

    ;

    auto _Buffer_start = _Buffer;
    auto _Width        = static_cast<int>(_Result.ptr - _Buffer_start);

    const auto _Is_negative = (::std:: signbit)(_Value);

    if (_Is_negative) {
        
        _Buffer_start += 1;
    } else {
        if (_Sgn != _Fmt_sign::_Minus) {
            _Width += 1;
        }
    }

    if (_To_upper) {
        _Buffer_to_uppercase(_Buffer_start, _Result.ptr);
        _Exponent = static_cast<char>(:: toupper(_Exponent));
    }

    const auto _Is_finite = (::std:: isfinite)(_Value);

    auto _Append_decimal   = false;
    auto _Exponent_start   = _Result.ptr;
    auto _Radix_point      = _Result.ptr;
    auto _Integral_end     = _Result.ptr;
    auto _Zeroes_to_append = 0;
    auto _Separators       = 0;
    string _Groups;

    if (_Is_finite) {
        if (_Specs._Alt || _Specs._Localized) {
            for (auto _It = _Buffer_start; _It < _Result.ptr; ++_It) {
                if (*_It == '.') {
                    _Radix_point = _It;
                } else if (*_It == _Exponent) {
                    _Exponent_start = _It;
                }
            }
            _Integral_end = (::std:: min)(_Radix_point, _Exponent_start);

            if (_Specs._Alt && _Radix_point == _Result.ptr) {
                
                ++_Width;
                _Append_decimal = true;
            }

            if (_Specs._Localized) {
                _Groups     = ::std:: use_facet<numpunct<_CharT>>(_Locale._Get()).grouping();
                _Separators = _Count_separators(static_cast<size_t>(_Integral_end - _Buffer_start), _Groups);
            }
        }

        switch (_Format) {
        case chars_format::hex:
        case chars_format::scientific:
            if (_Extra_precision != 0) {
                
                while (*--_Exponent_start != _Exponent) {
                }
            }
            [[fallthrough]];
        case chars_format::fixed:
            _Zeroes_to_append = _Extra_precision;
            break;
        case chars_format::general:
            if (_Specs._Alt) {
                auto _Digits = static_cast<int>(_Exponent_start - _Buffer_start);

                if (!_Append_decimal) {
                    --_Digits;
                }

                _Zeroes_to_append = _Extra_precision + _Precision - _Digits;

                
                if (_Exponent_start == _Result.ptr && ::std:: abs(_Value) < 1.0 && _Value != 0.0) {
                    for (auto _It = _Buffer_start; _It < _Result.ptr; ++_It) {
                        if (*_It == '0') {
                            ++_Zeroes_to_append;
                        } else if (*_It != '.') {
                            break;
                        }
                    }
                }
            }
            break;
        default:
            __assume(false);
        }
    }

    _Width += _Zeroes_to_append;

    const bool _Write_leading_zeroes = _Specs._Leading_zero && _Specs._Alignment == _Fmt_align::_None && _Is_finite;

    auto _Writer = [&](_OutputIt _Out) {
        _Out = _Write_sign(::std:: move(_Out), _Sgn, _Is_negative);

        if (_Write_leading_zeroes && _Width < _Specs._Width) {
            _Out = ::std::ranges:: fill_n(::std:: move(_Out), _Specs._Width - _Width, _CharT{'0'});
        }

        if (_Specs._Localized) {
            const auto& _Facet = ::std:: use_facet<numpunct<_CharT>>(_Locale._Get());

            _Out = _Write_separated_integer(
                _Buffer_start, _Integral_end, _Groups, _Facet.thousands_sep(), _Separators, ::std:: move(_Out));
            if (_Radix_point != _Result.ptr || _Append_decimal) {
                *_Out++         = _Facet.decimal_point();
                _Append_decimal = false;
            }
            _Buffer_start = _Integral_end;
            if (_Radix_point != _Result.ptr) {
                ++_Buffer_start;
            }
        }

        _Out = ::std::ranges:: transform(_Buffer_start, _Exponent_start, ::std:: move(_Out), _Widen_char<_CharT>{}).out;
        if (_Specs._Alt && _Append_decimal) {
            *_Out++ = '.';
        }

        for (; _Zeroes_to_append > 0; --_Zeroes_to_append) {
            *_Out++ = '0';
        }

        return ::std::ranges:: transform(_Exponent_start, _Result.ptr, ::std:: move(_Out), _Widen_char<_CharT>{}).out;
    };

    if (_Write_leading_zeroes) {
        return _Writer(::std:: move(_Out));
    }

    return _Write_aligned(::std:: move(_Out), _Width, _Specs, _Fmt_align::_Right, _Writer);
}

template <class _CharT, class _OutputIt>
[[nodiscard]] _OutputIt _Fmt_write(
    _OutputIt _Out, const void* const _Value, const _Basic_format_specs<_CharT>& _Specs, _Lazy_locale) {
    ;
    ;
    ;
    ;
    ;
    ;

    
    int _Width = 3;
    if (_Value != nullptr) {
        
        
        _Width = static_cast<int>(2 + (::std:: bit_width(reinterpret_cast<uintptr_t>(_Value)) + 3) / 4);
    }

    return _Write_aligned(::std:: move(_Out), _Width, _Specs, _Fmt_align::_Right,
        [=](_OutputIt _Out) { return _Fmt_write<_CharT>(::std:: move(_Out), _Value); });
}

template <class _CharT, class _OutputIt>
[[nodiscard]] _OutputIt _Fmt_write(
    _OutputIt _Out, const _CharT* _Value, const _Basic_format_specs<_CharT>& _Specs, _Lazy_locale _Locale) {
    return _Fmt_write(::std:: move(_Out), basic_string_view<_CharT>{_Value}, _Specs, _Locale);
}

template <class _CharT>
[[nodiscard]] const _CharT* _Measure_string_prefix(const basic_string_view<_CharT> _Value, int& _Width) {
    
    
    const int _Max_width = _Width;
    auto _Pos            = _Value.data();
    const auto _Last     = _Pos + _Value.size();
    int _Estimated_width = 0; 
    const _Fmt_codec<_CharT> _Codec;
    constexpr auto _Max_int = (numeric_limits<int>::max)();

    while (_Pos != _Last) {
        if (_Estimated_width == _Max_width && _Max_width >= 0) {
            
            break;
        }

        
        const int _Units           = _Codec._Units_in_next_character(_Pos, _Last);
        const int _Character_width = _Codec._Estimate_width(_Pos, _Units);

        if (_Max_int - _Character_width < _Estimated_width) { 
            
            if (_Max_width < 0) { 
                _Estimated_width = _Max_int;
                _Pos             = _Last;
            }
            break;
        }

        _Estimated_width += _Character_width;
        if (_Estimated_width > _Max_width && _Max_width >= 0) {
            
            _Estimated_width -= _Character_width;
            break;
        }

        _Pos += _Units;
    }

    _Width = _Estimated_width;
    return _Pos;
}

template <class _CharT, class _OutputIt>
[[nodiscard]] _OutputIt _Fmt_write(
    _OutputIt _Out, const basic_string_view<_CharT> _Value, const _Basic_format_specs<_CharT>& _Specs, _Lazy_locale) {
    ;
    ;
    ;
    ;

    if (_Specs._Precision < 0 && _Specs._Width <= 0) {
        return _Fmt_write(::std:: move(_Out), _Value);
    }

    int _Width          = _Specs._Precision;
    const _CharT* _Last = _Measure_string_prefix(_Value, _Width);

    return _Write_aligned(::std:: move(_Out), _Width, _Specs, _Fmt_align::_Left, [=](_OutputIt _Out) {
        return _Fmt_write(::std:: move(_Out), basic_string_view<_CharT>{_Value.data(), _Last});
    });
}


template <class _OutputIt, class _CharT>
struct _Default_arg_formatter {
    using _Context = basic_format_context<_OutputIt, _CharT>;

    _OutputIt _Out;
    basic_format_args<_Context> _Args;
    _Lazy_locale _Loc;

    template <class _Ty>
    _OutputIt operator()(_Ty _Val) && {
        return _Fmt_write<_CharT>(::std:: move(_Out), _Val);
    }

    _OutputIt operator()(typename basic_format_arg<_Context>::handle _Handle) && {
        basic_format_parse_context<_CharT> _Parse_ctx({});
        basic_format_context<_OutputIt, _CharT> _Format_ctx(::std:: move(_Out), _Args, _Loc);
        _Handle.format(_Parse_ctx, _Format_ctx);
        return _Format_ctx.out();
    }
};


template <class _OutputIt, class _CharT>
struct _Arg_formatter {
    using _Context = basic_format_context<_OutputIt, _CharT>;

    _Context* _Ctx                      = nullptr;
    _Basic_format_specs<_CharT>* _Specs = nullptr;

    _OutputIt operator()(typename basic_format_arg<_Context>::handle) {
        do { if (false) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
        ;
        return _Ctx->out();
    }

    template <class _Ty>
    _OutputIt operator()(_Ty _Val) {
        ;
        ;
        return _Fmt_write(_Ctx->out(), _Val, *_Specs, _Ctx->_Get_lazy_locale());
    }
};


template <class _Ty, class _ParseContext>
consteval typename _ParseContext::iterator _Compile_time_parse_format_specs(_ParseContext& _Pc) {
    using _CharT                = typename _ParseContext::char_type;
    using _Context              = basic_format_context<back_insert_iterator<_Fmt_buffer<_CharT>>, _CharT>;
    using _ArgTraits            = _Format_arg_traits<_Context>;
    using _FormattedTypeMapping = typename _ArgTraits::template _Storage_type<_Ty>;
    
    
    using _FormattedType = conditional_t<is_same_v<_FormattedTypeMapping, typename basic_format_arg<_Context>::handle>,
        _Ty, _FormattedTypeMapping>;
    formatter<_FormattedType, _CharT> _Formatter{};
    return _Formatter.parse(_Pc);
}


template <class _CharT, class... _Args>
struct _Format_checker {
    using _ParseContext = basic_format_parse_context<_CharT>;
    using _ParseFunc    = typename _ParseContext::iterator (*)(_ParseContext&);

    static constexpr size_t _Num_args = sizeof...(_Args);
    _ParseContext _Parse_context;
    _ParseFunc _Parse_funcs[_Num_args > 0 ? _Num_args : 1];

    consteval explicit _Format_checker(basic_string_view<_CharT> _Fmt) noexcept
        : _Parse_context(_Fmt, _Num_args), _Parse_funcs{&_Compile_time_parse_format_specs<_Args, _ParseContext>...} {}
    constexpr void _On_text(const _CharT*, const _CharT*) const noexcept {}
    constexpr void _On_replacement_field(size_t, const _CharT*) const noexcept {}
    constexpr const _CharT* _On_format_specs(const size_t _Id, const _CharT* _First, const _CharT*) {
        _Parse_context.advance_to(_Parse_context.begin() + (_First - _Parse_context.begin()._Unwrapped()));
        if (_Id < _Num_args) {
            auto _Iter = _Parse_funcs[_Id](_Parse_context); 
            return _Iter._Unwrapped();
        } else {
            return _First;
        }
    }
};


template <class _CharT>
struct _Format_handler {
    using _OutputIt = back_insert_iterator<_Fmt_buffer<_CharT>>;
    using _Context  = basic_format_context<_OutputIt, _CharT>;

    basic_format_parse_context<_CharT> _Parse_context;
    _Context _Ctx;

    explicit _Format_handler(_OutputIt _Out, basic_string_view<_CharT> _Str, basic_format_args<_Context> _Format_args)
        : _Parse_context(_Str), _Ctx(::std:: move(_Out), _Format_args) {}

    explicit _Format_handler(_OutputIt _Out, basic_string_view<_CharT> _Str, basic_format_args<_Context> _Format_args,
        const _Lazy_locale& _Loc)
        : _Parse_context(_Str), _Ctx(::std:: move(_Out), _Format_args, _Loc) {}

    void _On_text(const _CharT* _First, const _CharT* _Last) {
        _Ctx.advance_to(::std::ranges:: _Copy_unchecked(_First, _Last, _Ctx.out()).out);
    }

    void _On_replacement_field(const size_t _Id, const _CharT*) {
        auto _Arg = _Get_arg(_Ctx, _Id);
        _Ctx.advance_to(::std:: visit_format_arg(
            _Default_arg_formatter<_OutputIt, _CharT>{_Ctx.out(), _Ctx._Get_args(), _Ctx._Get_lazy_locale()}, _Arg));
    }

    const _CharT* _On_format_specs(const size_t _Id, const _CharT* _First, const _CharT* _Last) {
        _Parse_context.advance_to(_Parse_context.begin() + (_First - &*_Parse_context.begin()));
        auto _Arg = _Get_arg(_Ctx, _Id);
        if (_Arg._Active_state == _Basic_format_arg_type::_Custom_type) {
            _Arg._Custom_state.format(_Parse_context, _Ctx);
            return _Parse_context.begin()._Unwrapped();
        }

        _Basic_format_specs<_CharT> _Specs;
        _Specs_checker<_Specs_handler<basic_format_parse_context<_CharT>, _Context>> _Handler(
            _Specs_handler<basic_format_parse_context<_CharT>, _Context>{_Specs, _Parse_context, _Ctx},
            _Arg._Active_state);
        _First = _Parse_format_specs(_First, _Last, _Handler);
        if (_First == _Last || *_First != '}') {
            throw format_error("Missing '}' in format string.");
        }

        _Ctx.advance_to(::std:: visit_format_arg(
            _Arg_formatter<_OutputIt, _CharT>{._Ctx = ::std:: addressof(_Ctx), ._Specs = ::std:: addressof(_Specs)}, _Arg));
        return _First;
    }
};


template <class _Ty, class _CharT>
struct formatter {
    formatter()                 = delete;
    formatter(const formatter&) = delete;
    formatter operator=(const formatter&) = delete;
};

template <class _Ty, class _CharT, _Basic_format_arg_type _ArgType>
struct _Formatter_base {
    using _Pc = basic_format_parse_context<_CharT>;

    constexpr typename _Pc::iterator parse(_Pc& _ParseCtx) {
        _Specs_checker<_Dynamic_specs_handler<_Pc>> _Handler(_Dynamic_specs_handler<_Pc>{_Specs, _ParseCtx}, _ArgType);
        const auto _It = _Parse_format_specs(_ParseCtx._Unchecked_begin(), _ParseCtx._Unchecked_end(), _Handler);
        if (_It != _ParseCtx._Unchecked_end() && *_It != '}') {
            throw format_error("Missing '}' in format string.");
        }
        return _ParseCtx.begin() + (_It - _ParseCtx._Unchecked_begin());
    }

    template <class _FormatContext>
    typename _FormatContext::iterator format(const _Ty& _Val, _FormatContext& _FormatCtx) const {
        _Dynamic_format_specs<_CharT> _Format_specs = _Specs;
        if (_Specs._Dynamic_width_index >= 0) {
            _Format_specs._Width =
                _Get_dynamic_specs<_Width_checker>(_FormatCtx.arg(static_cast<size_t>(_Specs._Dynamic_width_index)));
        }

        if (_Specs._Dynamic_precision_index >= 0) {
            _Format_specs._Precision = _Get_dynamic_specs<_Precision_checker>(
                _FormatCtx.arg(static_cast<size_t>(_Specs._Dynamic_precision_index)));
        }

        return ::std:: visit_format_arg(
            _Arg_formatter<typename _FormatContext::iterator, _CharT>{
                ._Ctx = ::std:: addressof(_FormatCtx), ._Specs = ::std:: addressof(_Format_specs)},
            basic_format_arg<_FormatContext>{_Val});
    }

private:
    _Dynamic_format_specs<_CharT> _Specs;
};


template <_Format_supported_charT _CharT> struct formatter<int, _CharT> : _Formatter_base<int, _CharT, _Basic_format_arg_type::_Int_type> {};
template <_Format_supported_charT _CharT> struct formatter<unsigned int, _CharT> : _Formatter_base<unsigned int, _CharT, _Basic_format_arg_type::_UInt_type> {};
template <_Format_supported_charT _CharT> struct formatter<long long, _CharT> : _Formatter_base<long long, _CharT, _Basic_format_arg_type::_Long_long_type> {};
template <_Format_supported_charT _CharT> struct formatter<unsigned long long, _CharT> : _Formatter_base<unsigned long long, _CharT, _Basic_format_arg_type::_ULong_long_type> {};
template <_Format_supported_charT _CharT> struct formatter<bool, _CharT> : _Formatter_base<bool, _CharT, _Basic_format_arg_type::_Bool_type> {};
template <_Format_supported_charT _CharT> struct formatter<float, _CharT> : _Formatter_base<float, _CharT, _Basic_format_arg_type::_Float_type> {};
template <_Format_supported_charT _CharT> struct formatter<double, _CharT> : _Formatter_base<double, _CharT, _Basic_format_arg_type::_Double_type> {};
template <_Format_supported_charT _CharT> struct formatter<long double, _CharT> : _Formatter_base<long double, _CharT, _Basic_format_arg_type::_Long_double_type> {};
template <_Format_supported_charT _CharT> struct formatter<nullptr_t, _CharT> : _Formatter_base<nullptr_t, _CharT, _Basic_format_arg_type::_Pointer_type> {};
template <_Format_supported_charT _CharT> struct formatter<void*, _CharT> : _Formatter_base<void*, _CharT, _Basic_format_arg_type::_Pointer_type> {};
template <_Format_supported_charT _CharT> struct formatter<const void*, _CharT> : _Formatter_base<const void*, _CharT, _Basic_format_arg_type::_Pointer_type> {};
template <_Format_supported_charT _CharT> struct formatter<short, _CharT> : _Formatter_base<short, _CharT, _Basic_format_arg_type::_Int_type> {};
template <_Format_supported_charT _CharT> struct formatter<unsigned short, _CharT> : _Formatter_base<unsigned short, _CharT, _Basic_format_arg_type::_UInt_type> {};
template <_Format_supported_charT _CharT> struct formatter<long, _CharT> : _Formatter_base<long, _CharT, _Basic_format_arg_type::_Int_type> {};
template <_Format_supported_charT _CharT> struct formatter<unsigned long, _CharT> : _Formatter_base<unsigned long, _CharT, _Basic_format_arg_type::_UInt_type> {};
template <_Format_supported_charT _CharT> struct formatter<char, _CharT> : _Formatter_base<char, _CharT, _Basic_format_arg_type::_Char_type> {};
template <_Format_supported_charT _CharT> struct formatter<signed char, _CharT> : _Formatter_base<signed char, _CharT, _Basic_format_arg_type::_Int_type> {};
template <_Format_supported_charT _CharT> struct formatter<unsigned char, _CharT> : _Formatter_base<unsigned char, _CharT, _Basic_format_arg_type::_UInt_type> {};


template <>
struct formatter<wchar_t, wchar_t> : _Formatter_base<wchar_t, wchar_t, _Basic_format_arg_type::_Char_type> {};


template <_Format_supported_charT _CharT>
struct formatter<_CharT*, _CharT> : _Formatter_base<_CharT*, _CharT, _Basic_format_arg_type::_CString_type> {};

template <_Format_supported_charT _CharT>
struct formatter<const _CharT*, _CharT>
    : _Formatter_base<const _CharT*, _CharT, _Basic_format_arg_type::_CString_type> {};

template <_Format_supported_charT _CharT, size_t _Nx>
struct formatter<const _CharT[_Nx], _CharT>
    : _Formatter_base<const _CharT[_Nx], _CharT, _Basic_format_arg_type::_CString_type> {};

template <_Format_supported_charT _CharT, class _Traits, class _Allocator>
struct formatter<basic_string<_CharT, _Traits, _Allocator>, _CharT>
    : _Formatter_base<basic_string<_CharT, _Traits, _Allocator>, _CharT, _Basic_format_arg_type::_String_type> {};

template <_Format_supported_charT _CharT, class _Traits>
struct formatter<basic_string_view<_CharT, _Traits>, _CharT>
    : _Formatter_base<basic_string_view<_CharT, _Traits>, _CharT, _Basic_format_arg_type::_String_type> {};

template <class _CharT, class... _Args>
struct _Basic_format_string {
    basic_string_view<_CharT> _Str;

    template <class _Ty>
        requires convertible_to<const _Ty&, basic_string_view<_CharT>>
    consteval _Basic_format_string(const _Ty& _Str_val) : _Str(_Str_val) {
        if (_Is_execution_charset_self_synchronizing()) {
            _Parse_format_string(_Str, _Format_checker<_CharT, remove_cvref_t<_Args>...>{_Str});
        }
    }
};

template <class... _Args>
using _Fmt_string = _Basic_format_string<char, type_identity_t<_Args>...>;

template <class... _Args>
using _Fmt_wstring = _Basic_format_string<wchar_t, type_identity_t<_Args>...>;

using format_args  = basic_format_args<format_context>;
using wformat_args = basic_format_args<wformat_context>;

template <class _Context = format_context, class... _Args>
[[nodiscard]] auto make_format_args(_Args&&... _Vals) {
    return _Format_arg_store<_Context, _Args...>{_Vals...};
}

template <class... _Args>
[[nodiscard]] auto make_wformat_args(_Args&&... _Vals) {
    return _Format_arg_store<wformat_context, _Args...>{_Vals...};
}

template <output_iterator<const char&> _OutputIt>
_OutputIt vformat_to(_OutputIt _Out, const string_view _Fmt, const format_args _Args) {
    if constexpr (is_same_v<_OutputIt, _Fmt_it>) {
        _Format_handler<char> _Handler(_Out, _Fmt, _Args);
        _Parse_format_string(_Fmt, _Handler);
        return _Out;
    } else {
        _Fmt_iterator_buffer<_OutputIt, char> _Buf(::std:: move(_Out));
        _Format_handler<char> _Handler(_Fmt_it{_Buf}, _Fmt, _Args);
        _Parse_format_string(_Fmt, _Handler);
        return _Buf._Out();
    }
}

template <output_iterator<const wchar_t&> _OutputIt>
_OutputIt vformat_to(_OutputIt _Out, const wstring_view _Fmt, const wformat_args _Args) {
    if constexpr (is_same_v<_OutputIt, _Fmt_wit>) {
        _Format_handler<wchar_t> _Handler(_Out, _Fmt, _Args);
        _Parse_format_string(_Fmt, _Handler);
        return _Out;
    } else {
        _Fmt_iterator_buffer<_OutputIt, wchar_t> _Buf(::std:: move(_Out));
        _Format_handler<wchar_t> _Handler(_Fmt_wit{_Buf}, _Fmt, _Args);
        _Parse_format_string(_Fmt, _Handler);
        return _Buf._Out();
    }
}

template <output_iterator<const char&> _OutputIt>
_OutputIt vformat_to(_OutputIt _Out, const locale& _Loc, const string_view _Fmt, const format_args _Args) {
    if constexpr (is_same_v<_OutputIt, _Fmt_it>) {
        _Format_handler<char> _Handler(_Out, _Fmt, _Args, _Lazy_locale{_Loc});
        _Parse_format_string(_Fmt, _Handler);
        return _Out;
    } else {
        _Fmt_iterator_buffer<_OutputIt, char> _Buf(::std:: move(_Out));
        _Format_handler<char> _Handler(_Fmt_it{_Buf}, _Fmt, _Args, _Lazy_locale{_Loc});
        _Parse_format_string(_Fmt, _Handler);
        return _Buf._Out();
    }
}

template <output_iterator<const wchar_t&> _OutputIt>
_OutputIt vformat_to(_OutputIt _Out, const locale& _Loc, const wstring_view _Fmt, const wformat_args _Args) {
    if constexpr (is_same_v<_OutputIt, _Fmt_wit>) {
        _Format_handler<wchar_t> _Handler(_Out, _Fmt, _Args, _Lazy_locale{_Loc});
        _Parse_format_string(_Fmt, _Handler);
        return _Out;
    } else {
        _Fmt_iterator_buffer<_OutputIt, wchar_t> _Buf(::std:: move(_Out));
        _Format_handler<wchar_t> _Handler(_Fmt_wit{_Buf}, _Fmt, _Args, _Lazy_locale{_Loc});
        _Parse_format_string(_Fmt, _Handler);
        return _Buf._Out();
    }
}

template <output_iterator<const char&> _OutputIt, class... _Types>
_OutputIt format_to(_OutputIt _Out, const _Fmt_string<_Types...> _Fmt, _Types&&... _Args) {
    return ::std:: vformat_to(::std:: move(_Out), _Fmt._Str, ::std:: make_format_args(_Args...));
}

template <output_iterator<const wchar_t&> _OutputIt, class... _Types>
_OutputIt format_to(_OutputIt _Out, const _Fmt_wstring<_Types...> _Fmt, _Types&&... _Args) {
    return ::std:: vformat_to(::std:: move(_Out), _Fmt._Str, ::std:: make_wformat_args(_Args...));
}

template <output_iterator<const char&> _OutputIt, class... _Types>
_OutputIt format_to(_OutputIt _Out, const locale& _Loc, const _Fmt_string<_Types...> _Fmt, _Types&&... _Args) {
    return ::std:: vformat_to(::std:: move(_Out), _Loc, _Fmt._Str, ::std:: make_format_args(_Args...));
}

template <output_iterator<const wchar_t&> _OutputIt, class... _Types>
_OutputIt format_to(_OutputIt _Out, const locale& _Loc, const _Fmt_wstring<_Types...> _Fmt, _Types&&... _Args) {
    return ::std:: vformat_to(::std:: move(_Out), _Loc, _Fmt._Str, ::std:: make_wformat_args(_Args...));
}

template <int = 0> 
[[nodiscard]] string vformat(const string_view _Fmt, const format_args _Args) {
    string _Str;
    _Str.reserve(_Fmt.size() + _Args._Estimate_required_capacity());
    ::std:: vformat_to(back_insert_iterator{_Str}, _Fmt, _Args);
    return _Str;
}

template <int = 0> 
[[nodiscard]] wstring vformat(const wstring_view _Fmt, const wformat_args _Args) {
    wstring _Str;
    _Str.reserve(_Fmt.size() + _Args._Estimate_required_capacity());
    ::std:: vformat_to(back_insert_iterator{_Str}, _Fmt, _Args);
    return _Str;
}

template <int = 0> 
[[nodiscard]] string vformat(const locale& _Loc, const string_view _Fmt, const format_args _Args) {
    string _Str;
    _Str.reserve(_Fmt.size() + _Args._Estimate_required_capacity());
    ::std:: vformat_to(back_insert_iterator{_Str}, _Loc, _Fmt, _Args);
    return _Str;
}

template <int = 0> 
[[nodiscard]] wstring vformat(const locale& _Loc, const wstring_view _Fmt, const wformat_args _Args) {
    wstring _Str;
    _Str.reserve(_Fmt.size() + _Args._Estimate_required_capacity());
    ::std:: vformat_to(back_insert_iterator{_Str}, _Loc, _Fmt, _Args);
    return _Str;
}

template <class... _Types>
[[nodiscard]] string format(const _Fmt_string<_Types...> _Fmt, _Types&&... _Args) {
    return ::std:: vformat(_Fmt._Str, ::std:: make_format_args(_Args...));
}

template <class... _Types>
[[nodiscard]] wstring format(const _Fmt_wstring<_Types...> _Fmt, _Types&&... _Args) {
    return ::std:: vformat(_Fmt._Str, ::std:: make_wformat_args(_Args...));
}

template <class... _Types>
[[nodiscard]] string format(const locale& _Loc, const _Fmt_string<_Types...> _Fmt, _Types&&... _Args) {
    return ::std:: vformat(_Loc, _Fmt._Str, ::std:: make_format_args(_Args...));
}

template <class... _Types>
[[nodiscard]] wstring format(const locale& _Loc, const _Fmt_wstring<_Types...> _Fmt, _Types&&... _Args) {
    return ::std:: vformat(_Loc, _Fmt._Str, ::std:: make_wformat_args(_Args...));
}

template <class _OutputIt>
struct format_to_n_result {
    _OutputIt out;
    iter_difference_t<_OutputIt> size;
};

template <output_iterator<const char&> _OutputIt, class... _Types>
format_to_n_result<_OutputIt> format_to_n(
    _OutputIt _Out, const iter_difference_t<_OutputIt> _Max, const _Fmt_string<_Types...> _Fmt, _Types&&... _Args) {
    _Fmt_iterator_buffer<_OutputIt, char, _Fmt_fixed_buffer_traits> _Buf(::std:: move(_Out), _Max);
    ::std:: vformat_to(_Fmt_it{_Buf}, _Fmt._Str, ::std:: make_format_args(_Args...));
    return {.out = _Buf._Out(), .size = _Buf._Count()};
}

template <output_iterator<const wchar_t&> _OutputIt, class... _Types>
format_to_n_result<_OutputIt> format_to_n(
    _OutputIt _Out, const iter_difference_t<_OutputIt> _Max, const _Fmt_wstring<_Types...> _Fmt, _Types&&... _Args) {
    _Fmt_iterator_buffer<_OutputIt, wchar_t, _Fmt_fixed_buffer_traits> _Buf(::std:: move(_Out), _Max);
    ::std:: vformat_to(_Fmt_wit{_Buf}, _Fmt._Str, ::std:: make_wformat_args(_Args...));
    return {.out = _Buf._Out(), .size = _Buf._Count()};
}

template <output_iterator<const char&> _OutputIt, class... _Types>
format_to_n_result<_OutputIt> format_to_n(_OutputIt _Out, const iter_difference_t<_OutputIt> _Max, const locale& _Loc,
    const _Fmt_string<_Types...> _Fmt, _Types&&... _Args) {
    _Fmt_iterator_buffer<_OutputIt, char, _Fmt_fixed_buffer_traits> _Buf(::std:: move(_Out), _Max);
    ::std:: vformat_to(_Fmt_it{_Buf}, _Loc, _Fmt._Str, ::std:: make_format_args(_Args...));
    return {.out = _Buf._Out(), .size = _Buf._Count()};
}

template <output_iterator<const wchar_t&> _OutputIt, class... _Types>
format_to_n_result<_OutputIt> format_to_n(_OutputIt _Out, const iter_difference_t<_OutputIt> _Max, const locale& _Loc,
    const _Fmt_wstring<_Types...> _Fmt, _Types&&... _Args) {
    _Fmt_iterator_buffer<_OutputIt, wchar_t, _Fmt_fixed_buffer_traits> _Buf(::std:: move(_Out), _Max);
    ::std:: vformat_to(_Fmt_wit{_Buf}, _Loc, _Fmt._Str, ::std:: make_wformat_args(_Args...));
    return {.out = _Buf._Out(), .size = _Buf._Count()};
}

template <class... _Types>
[[nodiscard]] size_t formatted_size(const _Fmt_string<_Types...> _Fmt, _Types&&... _Args) {
    _Fmt_counting_buffer<char> _Buf;
    ::std:: vformat_to(_Fmt_it{_Buf}, _Fmt._Str, ::std:: make_format_args(_Args...));
    return _Buf._Count();
}

template <class... _Types>
[[nodiscard]] size_t formatted_size(const _Fmt_wstring<_Types...> _Fmt, _Types&&... _Args) {
    _Fmt_counting_buffer<wchar_t> _Buf;
    ::std:: vformat_to(_Fmt_wit{_Buf}, _Fmt._Str, ::std:: make_wformat_args(_Args...));
    return _Buf._Count();
}

template <class... _Types>
[[nodiscard]] size_t formatted_size(const locale& _Loc, const _Fmt_string<_Types...> _Fmt, _Types&&... _Args) {
    _Fmt_counting_buffer<char> _Buf;
    ::std:: vformat_to(_Fmt_it{_Buf}, _Loc, _Fmt._Str, ::std:: make_format_args(_Args...));
    return _Buf._Count();
}

template <class... _Types>
[[nodiscard]] size_t formatted_size(const locale& _Loc, const _Fmt_wstring<_Types...> _Fmt, _Types&&... _Args) {
    _Fmt_counting_buffer<wchar_t> _Buf;
    ::std:: vformat_to(_Fmt_wit{_Buf}, _Loc, _Fmt._Str, ::std:: make_wformat_args(_Args...));
    return _Buf._Count();
}

}


#pragma warning(pop)
#pragma pack(pop)

#line 3191 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\format"
#line 3192 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\format"
#line 3193 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\format"
#line 40 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iomanip"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
template <class _Elem>
struct _Fillobj { 
    _Fillobj(_Elem _Ch) : _Fill(_Ch) {}

    _Elem _Fill; 
};

template <class _Elem>
[[nodiscard]] _Fillobj<_Elem> setfill(_Elem _Ch) {
    return _Fillobj<_Elem>(_Ch);
}

template <class _Elem, class _Traits, class _Elem2>
basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
    const _Fillobj<_Elem2>& _Manip) { 
    static_assert(is_same_v<_Elem, _Elem2>, "wrong character type for setfill");

    _Istr.fill(_Manip._Fill);
    return _Istr;
}

template <class _Elem, class _Traits, class _Elem2>
basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
    const _Fillobj<_Elem2>& _Manip) { 
    static_assert(is_same_v<_Elem, _Elem2>, "wrong character type for setfill");

    _Ostr.fill(_Manip._Fill);
    return _Ostr;
}

template <class _Money>
struct _Monobj { 
    _Monobj(_Money& _Val_arg, bool _Intl_arg) : _Val(_Val_arg), _Intl(_Intl_arg) {}

    _Money& _Val; 
    bool _Intl; 
};

template <class _Money>
[[nodiscard]] _Monobj<_Money> get_money(_Money& _Val_arg, bool _Intl_arg = false) {
    return _Monobj<_Money>(_Val_arg, _Intl_arg);
}

template <class _Elem, class _Traits, class _Money>
basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
    const _Monobj<_Money>& _Manip) { 
    using _Myis   = basic_istream<_Elem, _Traits>;
    using _Iter   = istreambuf_iterator<_Elem, _Traits>;
    using _Mymget = money_get<_Elem, _Iter>;

    ios_base::iostate _State = ios_base::goodbit;
    const typename _Myis::sentry _Ok(_Istr);

    if (_Ok) { 
        const _Mymget& _Mget_fac = ::std:: use_facet<_Mymget>(_Istr.getloc());
        try {
        _Mget_fac.get(_Iter(_Istr.rdbuf()), _Iter(nullptr), _Manip._Intl, _Istr, _State, _Manip._Val);
        } catch (...) { (_Istr) .setstate(ios_base::badbit, true); }
    }

    _Istr.setstate(_State);
    return _Istr;
}

template <class _Money>
[[nodiscard]] _Monobj<const _Money> put_money(const _Money& _Val_arg, bool _Intl_arg = false) {
    return _Monobj<const _Money>(_Val_arg, _Intl_arg);
}

template <class _Elem, class _Traits, class _Money>
basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
    const _Monobj<_Money>& _Manip) { 
    using _Myos   = basic_ostream<_Elem, _Traits>;
    using _Iter   = ostreambuf_iterator<_Elem, _Traits>;
    using _Mymput = money_put<_Elem, _Iter>;

    ios_base::iostate _State = ios_base::goodbit;
    const typename _Myos::sentry _Ok(_Ostr);

    if (_Ok) { 
        const _Mymput& _Mput_fac = ::std:: use_facet<_Mymput>(_Ostr.getloc());
        try {
        if (_Mput_fac.put(_Iter(_Ostr.rdbuf()), _Manip._Intl, _Ostr, _Ostr.fill(), _Manip._Val).failed()) {
            _State |= ios_base::badbit;
        }
        } catch (...) { (_Ostr) .setstate(ios_base::badbit, true); }
    }

    _Ostr.setstate(_State);
    return _Ostr;
}

template <class _Elem, class _Ptr>
struct _Timeobj { 
    _Timeobj(_Ptr _Tptr_arg, const _Elem* _Fmt_arg) : _Tptr(_Tptr_arg), _Fmtfirst(_Fmt_arg) {
        for (_Fmtlast = _Fmtfirst; *_Fmtlast != 0; ++_Fmtlast) { 
        }
    }

    _Ptr _Tptr; 
    const _Elem* _Fmtfirst; 
    const _Elem* _Fmtlast; 
};

template <class _Elem>
[[nodiscard]] _Timeobj<_Elem, tm*> get_time(tm* _Tptr_arg, const _Elem* _Fmt_arg) {
    return _Timeobj<_Elem, tm*>(_Tptr_arg, _Fmt_arg);
}

template <class _Elem, class _Traits, class _Elem2>
basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
    const _Timeobj<_Elem2, tm*>& _Manip) { 
    using _Myis   = basic_istream<_Elem, _Traits>;
    using _Iter   = istreambuf_iterator<_Elem, _Traits>;
    using _Mytget = time_get<_Elem2, _Iter>;

    static_assert(is_same_v<_Elem, _Elem2>, "wrong character type for get_time");

    ios_base::iostate _State = ios_base::goodbit;
    const typename _Myis::sentry _Ok(_Istr);

    if (_Ok) { 
        const _Mytget& _Tget_fac = ::std:: use_facet<_Mytget>(_Istr.getloc());
        try {
        _Tget_fac.get(
            _Iter(_Istr.rdbuf()), _Iter(nullptr), _Istr, _State, _Manip._Tptr, _Manip._Fmtfirst, _Manip._Fmtlast);
        } catch (...) { (_Istr) .setstate(ios_base::badbit, true); }
    }

    _Istr.setstate(_State);
    return _Istr;
}

template <class _Elem>
[[nodiscard]] _Timeobj<_Elem, const tm*> put_time(const tm* _Tptr_arg, const _Elem* _Fmt_arg) {
    return _Timeobj<_Elem, const tm*>(_Tptr_arg, _Fmt_arg);
}

template <class _Elem, class _Traits, class _Elem2>
basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
    const _Timeobj<_Elem2, const tm*>& _Manip) { 
    using _Myos   = basic_ostream<_Elem, _Traits>;
    using _Iter   = ostreambuf_iterator<_Elem, _Traits>;
    using _Mytput = time_put<_Elem2, _Iter>;

    static_assert(is_same_v<_Elem, _Elem2>, "wrong character type for put_time");

    const typename _Myos::sentry _Ok(_Ostr);

    if (_Ok) { 
        const _Mytput& _Tput_fac = ::std:: use_facet<_Mytput>(_Ostr.getloc());
        try {
        if (_Tput_fac.put(_Iter(_Ostr.rdbuf()), _Ostr, _Ostr.fill(), _Manip._Tptr, _Manip._Fmtfirst, _Manip._Fmtlast)
                .failed()) {
            _Ostr.setstate(ios_base::badbit);
        }
        } catch (...) { (_Ostr) .setstate(ios_base::badbit, true); }
    }

    return _Ostr;
}

template <class _Elem, class _Traits, class _Alloc>
struct _Quote_in { 
    using _Mystr = basic_string<_Elem, _Traits, _Alloc>;

    _Quote_in(_Mystr& _Str_obj, _Elem _Delim_obj, _Elem _Escape_obj)
        : _Str(_Str_obj), _Delim(_Delim_obj), _Escape(_Escape_obj) {}

    _Mystr& _Str; 
    _Elem _Delim; 
    _Elem _Escape; 
};

template <class _Elem, class _Traits, class _Sizet>
struct _Quote_out { 
    _Quote_out(const _Elem* _Ptr_obj, _Sizet _Size_obj, _Elem _Delim_obj, _Elem _Escape_obj)
        : _Ptr(_Ptr_obj), _Size(_Size_obj), _Delim(_Delim_obj), _Escape(_Escape_obj) {}

    _Quote_out(const _Quote_out&) = default;

    const _Elem* _Ptr; 
    _Sizet _Size; 
    _Elem _Delim; 
    _Elem _Escape; 

    _Quote_out& operator=(const _Quote_out&) = delete;
};

template <class _Elem>
[[nodiscard]] _Quote_out<_Elem, void, size_t> quoted(
    const _Elem* _Ptr, _Elem _Delim = _Elem('"'), _Elem _Escape = _Elem('\\')) {
    size_t _Size = 0;
    while (_Ptr[_Size] != _Elem(0)) {
        ++_Size;
    }

    return _Quote_out<_Elem, void, size_t>(_Ptr, _Size, _Delim, _Escape);
}

template <class _Elem, class _Traits, class _Alloc>
[[nodiscard]] _Quote_out<_Elem, _Traits, typename basic_string<_Elem, _Traits, _Alloc>::size_type> quoted(
    const basic_string<_Elem, _Traits, _Alloc>& _Str, _Elem _Delim = _Elem('"'), _Elem _Escape = _Elem('\\')) {
    using _Qobj = _Quote_out<_Elem, _Traits, typename basic_string<_Elem, _Traits, _Alloc>::size_type>;
    return _Qobj(_Str.c_str(), _Str.size(), _Delim, _Escape);
}


template <class _Elem, class _Traits>
[[nodiscard]] _Quote_out<_Elem, _Traits, size_t> quoted(
    const basic_string_view<_Elem, _Traits> _Str, _Elem _Delim = _Elem('"'), _Elem _Escape = _Elem('\\')) {
    using _Qobj = _Quote_out<_Elem, _Traits, size_t>;
    return _Qobj(_Str.data(), _Str.size(), _Delim, _Escape);
}
#line 239 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iomanip"

template <class _Elem, class _Traits, class _Alloc>
[[nodiscard]] _Quote_in<_Elem, _Traits, _Alloc> quoted(
    basic_string<_Elem, _Traits, _Alloc>& _Str, _Elem _Delim = _Elem('"'), _Elem _Escape = _Elem('\\')) {
    return _Quote_in<_Elem, _Traits, _Alloc>(_Str, _Delim, _Escape);
}

template <class _Elem, class _Traits, class _QuTraits, class _Sizet>
basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
    const _Quote_out<_Elem, _QuTraits, _Sizet>& _Manip) { 
    static_assert(
        is_void_v<_QuTraits> || is_same_v<_QuTraits, _Traits>, "quoted() traits must match basic_ostream traits");

    using _Myos = basic_ostream<_Elem, _Traits>;

    const _Elem* const _Last = _Manip._Ptr + _Manip._Size;

    _Sizet _Size = _Manip._Size + 2; 
    for (const _Elem* _Ptr = _Manip._Ptr; _Ptr != _Last; ++_Ptr) {
        if (_Traits::eq(*_Ptr, _Manip._Delim) || _Traits::eq(*_Ptr, _Manip._Escape)) {
            ++_Size; 
        }
    }

    ios_base::iostate _State = ios_base::goodbit;

    _Sizet _Pad;
    if (_Ostr.width() <= 0 || static_cast<_Sizet>(_Ostr.width()) <= _Size) {
        _Pad = 0;
    } else {
        _Pad = static_cast<_Sizet>(_Ostr.width()) - _Size;
    }

    const typename _Myos::sentry _Ok(_Ostr);

    if (!_Ok) {
        _State |= ios_base::badbit;
    } else { 
        try {
        if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left) {
            for (; 0 < _Pad; --_Pad) { 
                if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
                    _State |= ios_base::badbit; 
                    break;
                }
            }
        }

        if (_State == ios_base::goodbit
            && _Traits::eq_int_type(_Traits::eof(),
                _Ostr.rdbuf()->sputc(_Manip._Delim))) { 
            _State |= ios_base::badbit;
        }

        for (const _Elem* _Ptr = _Manip._Ptr; _Ptr != _Last; ++_Ptr) { 
            if ((_Traits::eq(*_Ptr, _Manip._Delim) || _Traits::eq(*_Ptr, _Manip._Escape)) && _State == ios_base::goodbit
                && _Traits::eq_int_type(_Traits::eof(),
                    _Ostr.rdbuf()->sputc(_Manip._Escape))) { 
                _State |= ios_base::badbit; 
                break;
            }

            if (_State == ios_base::goodbit
                && _Traits::eq_int_type(_Traits::eof(),
                    _Ostr.rdbuf()->sputc(*_Ptr))) { 
                _State |= ios_base::badbit; 
                break;
            }
        }

        if (_State == ios_base::goodbit
            && _Traits::eq_int_type(_Traits::eof(),
                _Ostr.rdbuf()->sputc(_Manip._Delim))) { 
            _State |= ios_base::badbit;
        }

        if (_State == ios_base::goodbit) {
            for (; 0 < _Pad; --_Pad) { 
                if (_Traits::eq_int_type(_Traits::eof(), _Ostr.rdbuf()->sputc(_Ostr.fill()))) {
                    _State |= ios_base::badbit; 
                    break;
                }
            }
        }

        _Ostr.width(0);
        } catch (...) { (_Ostr) .setstate(ios_base::badbit, true); }
    }

    _Ostr.setstate(_State);
    return _Ostr;
}

template <class _Elem, class _Traits, class _Alloc>
basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
    const _Quote_in<_Elem, _Traits, _Alloc>& _Manip) { 
    using _Mystr = basic_string<_Elem, _Traits, _Alloc>;

    const _Mystr& _Ref = _Manip._Str;
    return _Ostr << ::std:: quoted(_Ref, _Manip._Delim, _Manip._Escape);
}

template <class _Elem, class _Traits, class _Alloc>
basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
    const _Quote_in<_Elem, _Traits, _Alloc>& _Manip) { 
    ios_base::iostate _State = ios_base::goodbit;
    const typename basic_istream<_Elem, _Traits>::sentry _Ok(_Istr);

    if (_Ok) { 
        try {
        const auto _Buf   = _Istr.rdbuf();
        auto& _Str        = _Manip._Str;
        const auto _Delim = _Traits::to_int_type(_Manip._Delim);
        auto _Meta        = _Buf->sgetc();

        if (!_Traits::eq_int_type(_Meta, _Delim)) { 
            return _Istr >> _Str;
        }

        const auto _Escape = _Traits::to_int_type(_Manip._Escape);
        _Str.clear();
        for (;;) {
            _Meta = _Buf->snextc();
            if (_Traits::eq_int_type(_Traits::eof(), _Meta)) { 
                _State = ios_base::eofbit | ios_base::failbit;
                break;
            } else if (_Traits::eq_int_type(_Meta, _Escape)) { 
                _Meta = _Buf->snextc();
                if (_Traits::eq_int_type(_Traits::eof(), _Meta)) { 
                    _State = ios_base::eofbit | ios_base::failbit;
                    break;
                }
            } else if (_Traits::eq_int_type(_Meta, _Delim)) { 
                if (_Traits::eq_int_type(_Traits::eof(), _Buf->sbumpc())) { 
                    _State = ios_base::eofbit;
                }

                break;
            }

            _Str.push_back(_Traits::to_char_type(_Meta));
        }
        } catch (...) { (_Istr) .setstate(ios_base::badbit, true); }
    }

    _Istr.setstate(_State);
    return _Istr;
}

template <class _Arg>
struct _Smanip { 
    _Smanip(void(__cdecl* _Left)(ios_base&, _Arg), _Arg _Val) : _Pfun(_Left), _Manarg(_Val) {}

    void(__cdecl* _Pfun)(ios_base&, _Arg); 
    _Arg _Manarg; 
};

template <class _Elem, class _Traits, class _Arg>
basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
    const _Smanip<_Arg>& _Manip) { 
    (*_Manip._Pfun)(_Istr, _Manip._Manarg);
    return _Istr;
}

template <class _Elem, class _Traits, class _Arg>
basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
    const _Smanip<_Arg>& _Manip) { 
    (*_Manip._Pfun)(_Ostr, _Manip._Manarg);
    return _Ostr;
}

[[nodiscard]]  _Smanip<ios_base::fmtflags> __cdecl resetiosflags(ios_base::fmtflags);
[[nodiscard]]  _Smanip<ios_base::fmtflags> __cdecl setiosflags(ios_base::fmtflags);
[[nodiscard]]  _Smanip<int> __cdecl setbase(int);
[[nodiscard]]  _Smanip<streamsize> __cdecl setprecision(streamsize);
[[nodiscard]]  _Smanip<streamsize> __cdecl setw(streamsize);
}


#pragma warning(pop)
#pragma pack(pop)
#line 421 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iomanip"
#line 422 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iomanip"
#line 41 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"
#line 42 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"
#line 43 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
namespace chrono {
    template <class _Rep>
    struct treat_as_floating_point : is_floating_point<_Rep> {}; 

    template <class _Rep>
    inline constexpr bool treat_as_floating_point_v = treat_as_floating_point<_Rep>::value;

    template <class _Rep>
    struct duration_values { 
        [[nodiscard]] static constexpr _Rep zero() noexcept {
            
            return _Rep(0);
        }

        [[nodiscard]] static constexpr _Rep(min)() noexcept {
            
            return numeric_limits<_Rep>::lowest();
        }

        [[nodiscard]] static constexpr _Rep(max)() noexcept {
            
            return (numeric_limits<_Rep>::max)();
        }
    };


    template <class _Clock, class = void>
    inline constexpr bool _Is_clock_v = false;

    template <class _Clock>
    inline constexpr bool
        _Is_clock_v<_Clock, void_t<typename _Clock::rep, typename _Clock::period, typename _Clock::duration,
                                typename _Clock::time_point, decltype(_Clock::is_steady), decltype(_Clock::now())>> =
            true; 

    template <class _Clock>
    struct is_clock : bool_constant<_Is_clock_v<_Clock>> {};
    template <class _Clock>
    inline constexpr bool is_clock_v = _Is_clock_v<_Clock>;
#line 92 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"

    template <class _Rep, class _Period = ratio<1>>
    class duration;

    template <class _Ty>
    inline constexpr bool _Is_duration_v = _Is_specialization_v<_Ty, duration>;

    template <class _To, class _Rep, class _Period, enable_if_t<_Is_duration_v<_To>, int> = 0>
    constexpr _To duration_cast(const duration<_Rep, _Period>&) noexcept(
        is_arithmetic_v<_Rep>&& is_arithmetic_v<typename _To::rep>); 

    template <class _Rep, class _Period>
    class duration { 
    public:
        using rep    = _Rep;
        using period = typename _Period::type;

        static_assert(!_Is_duration_v<_Rep>, "duration can't have duration as first template argument");
        static_assert(_Is_ratio_v<_Period>, "period not an instance of std::ratio");
        static_assert(0 < _Period::num, "period negative or zero");

        constexpr duration() = default;

        template <class _Rep2,
            enable_if_t<is_convertible_v<const _Rep2&,
                            _Rep> && (treat_as_floating_point_v<_Rep> || !treat_as_floating_point_v<_Rep2>),
                int> = 0>
        constexpr explicit duration(const _Rep2& _Val) noexcept(
            is_arithmetic_v<_Rep>&& is_arithmetic_v<_Rep2>) 
            : _MyRep(static_cast<_Rep>(_Val)) {}

        template <class _Rep2, class _Period2,
            enable_if_t<
                treat_as_floating_point_v<
                    _Rep> || (_Ratio_divide_sfinae<_Period2, _Period>::den == 1 && !treat_as_floating_point_v<_Rep2>),
                int> = 0>
        constexpr duration(const duration<_Rep2, _Period2>& _Dur) noexcept(
            is_arithmetic_v<_Rep>&& is_arithmetic_v<_Rep2>) 
            : _MyRep(::std::chrono:: duration_cast<duration>(_Dur).count()) {}

        [[nodiscard]] constexpr _Rep count() const noexcept(is_arithmetic_v<_Rep>)  {
            return _MyRep;
        }

        [[nodiscard]] constexpr common_type_t<duration> operator+() const
            noexcept(is_arithmetic_v<_Rep>)  {
            return common_type_t<duration>(*this);
        }

        [[nodiscard]] constexpr common_type_t<duration> operator-() const
            noexcept(is_arithmetic_v<_Rep>)  {
            return common_type_t<duration>(-_MyRep);
        }

        constexpr duration& operator++() noexcept(is_arithmetic_v<_Rep>)  {
            ++_MyRep;
            return *this;
        }

        constexpr duration operator++(int) noexcept(is_arithmetic_v<_Rep>)  {
            return duration(_MyRep++);
        }

        constexpr duration& operator--() noexcept(is_arithmetic_v<_Rep>)  {
            --_MyRep;
            return *this;
        }

        constexpr duration operator--(int) noexcept(is_arithmetic_v<_Rep>)  {
            return duration(_MyRep--);
        }

        constexpr duration& operator+=(const duration& _Right) noexcept(is_arithmetic_v<_Rep>)  {
            _MyRep += _Right._MyRep;
            return *this;
        }

        constexpr duration& operator-=(const duration& _Right) noexcept(is_arithmetic_v<_Rep>)  {
            _MyRep -= _Right._MyRep;
            return *this;
        }

        constexpr duration& operator*=(const _Rep& _Right) noexcept(is_arithmetic_v<_Rep>)  {
            _MyRep *= _Right;
            return *this;
        }

        constexpr duration& operator/=(const _Rep& _Right) noexcept(is_arithmetic_v<_Rep>)  {
            _MyRep /= _Right;
            return *this;
        }

        constexpr duration& operator%=(const _Rep& _Right) noexcept(is_arithmetic_v<_Rep>)  {
            _MyRep %= _Right;
            return *this;
        }

        constexpr duration& operator%=(const duration& _Right) noexcept(is_arithmetic_v<_Rep>)  {
            _MyRep %= _Right.count();
            return *this;
        }

        [[nodiscard]] static constexpr duration zero() noexcept {
            
            return duration(duration_values<_Rep>::zero());
        }

        [[nodiscard]] static constexpr duration(min)() noexcept {
            
            return duration((duration_values<_Rep>::min)());
        }

        [[nodiscard]] static constexpr duration(max)() noexcept {
            
            return duration((duration_values<_Rep>::max)());
        }

    private:
        _Rep _MyRep; 
    };

    template <class _Clock, class _Duration = typename _Clock::duration>
    class time_point { 
    public:
        using clock    = _Clock;
        using duration = _Duration;
        using rep      = typename _Duration::rep;
        using period   = typename _Duration::period;

        static_assert(_Is_duration_v<_Duration>,
            "N4885 [time.point.general]/1 mandates Duration to be a specialization of chrono::duration.");

        constexpr time_point() = default;

        constexpr explicit time_point(const _Duration& _Other) noexcept(is_arithmetic_v<rep>) 
            : _MyDur(_Other) {}

        template <class _Duration2, enable_if_t<is_convertible_v<_Duration2, _Duration>, int> = 0>
        constexpr time_point(const time_point<_Clock, _Duration2>& _Tp) noexcept(
            is_arithmetic_v<rep>&& is_arithmetic_v<typename _Duration2::rep>) 
            : _MyDur(_Tp.time_since_epoch()) {}

        [[nodiscard]] constexpr _Duration time_since_epoch() const noexcept(is_arithmetic_v<rep>)  {
            return _MyDur;
        }


        constexpr time_point& operator++() noexcept(is_arithmetic_v<rep>)  {
            ++_MyDur;
            return *this;
        }
        constexpr time_point operator++(int) noexcept(is_arithmetic_v<rep>)  {
            return time_point{_MyDur++};
        }
        constexpr time_point& operator--() noexcept(is_arithmetic_v<rep>)  {
            --_MyDur;
            return *this;
        }
        constexpr time_point operator--(int) noexcept(is_arithmetic_v<rep>)  {
            return time_point{_MyDur--};
        }
#line 254 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"

        constexpr time_point& operator+=(const _Duration& _Dur) noexcept(is_arithmetic_v<rep>)  {
            _MyDur += _Dur;
            return *this;
        }

        constexpr time_point& operator-=(const _Duration& _Dur) noexcept(is_arithmetic_v<rep>)  {
            _MyDur -= _Dur;
            return *this;
        }

        [[nodiscard]] static constexpr time_point(min)() noexcept {
            return time_point((_Duration::min)());
        }

        [[nodiscard]] static constexpr time_point(max)() noexcept {
            return time_point((_Duration::max)());
        }

    private:
        _Duration _MyDur{duration::zero()}; 
    };
} 

template <class _Rep, class _Period>
inline constexpr bool _Is_trivially_swappable_v<chrono::duration<_Rep, _Period>> = _Is_trivially_swappable_v<_Rep>;

template <class _Clock, class _Duration>
inline constexpr bool _Is_trivially_swappable_v<chrono::time_point<_Clock, _Duration>> =
    _Is_trivially_swappable_v<_Duration>;

[[nodiscard]] constexpr intmax_t _Lcm(const intmax_t _Ax, const intmax_t _Bx) noexcept {
    return (_Ax / _Gcd(_Ax, _Bx)) * _Bx;
}

template <class _Rep1, class _Period1, class _Rep2, class _Period2>
struct common_type<::std::chrono:: duration<_Rep1, _Period1>, ::std::chrono:: duration<_Rep2, _Period2>> {
    using type = ::std::chrono:: duration<common_type_t<_Rep1, _Rep2>,
        ratio<_Gcd(_Period1::num, _Period2::num), _Lcm(_Period1::den, _Period2::den)>>;
};

template <class _Clock, class _Duration1, class _Duration2>
struct common_type<::std::chrono:: time_point<_Clock, _Duration1>,
    ::std::chrono:: time_point<_Clock, _Duration2>> { 
    using type = ::std::chrono:: time_point<_Clock, common_type_t<_Duration1, _Duration2>>;
};

namespace chrono {
    template <class _Rep1, class _Period1, class _Rep2, class _Period2>
    [[nodiscard]] constexpr common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>
        operator+(const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right) noexcept(
            is_arithmetic_v<_Rep1>&& is_arithmetic_v<_Rep2>)  {
        using _CD = common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>;
        return _CD(_CD(_Left).count() + _CD(_Right).count());
    }

    template <class _Rep1, class _Period1, class _Rep2, class _Period2>
    [[nodiscard]] constexpr common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>
        operator-(const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right) noexcept(
            is_arithmetic_v<_Rep1>&& is_arithmetic_v<_Rep2>)  {
        using _CD = common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>;
        return _CD(_CD(_Left).count() - _CD(_Right).count());
    }

    template <class _Rep1, class _Period1, class _Rep2,
        enable_if_t<is_convertible_v<const _Rep2&, common_type_t<_Rep1, _Rep2>>, int> = 0>
    [[nodiscard]] constexpr duration<common_type_t<_Rep1, _Rep2>, _Period1> operator*(
        const duration<_Rep1, _Period1>& _Left,
        const _Rep2& _Right) noexcept(is_arithmetic_v<_Rep1>&& is_arithmetic_v<_Rep2>)  {
        using _CR = common_type_t<_Rep1, _Rep2>;
        using _CD = duration<_CR, _Period1>;
        return _CD(_CD(_Left).count() * _Right);
    }

    template <class _Rep1, class _Rep2, class _Period2,
        enable_if_t<is_convertible_v<const _Rep1&, common_type_t<_Rep1, _Rep2>>, int> = 0>
    [[nodiscard]] constexpr duration<common_type_t<_Rep1, _Rep2>, _Period2>
        operator*(const _Rep1& _Left, const duration<_Rep2, _Period2>& _Right) noexcept(
            is_arithmetic_v<_Rep1>&& is_arithmetic_v<_Rep2>)  {
        return _Right * _Left;
    }

    template <class _CR, class _Period1, class _Rep2, bool = is_convertible_v<const _Rep2&, _CR>>
    struct _Duration_div_mod1 { 
        using type = duration<_CR, _Period1>;
    };

    template <class _CR, class _Period1, class _Rep2>
    struct _Duration_div_mod1<_CR, _Period1, _Rep2, false> {}; 

    template <class _CR, class _Period1, class _Rep2, bool = _Is_duration_v<_Rep2>>
    struct _Duration_div_mod {}; 

    template <class _CR, class _Period1, class _Rep2>
    struct _Duration_div_mod<_CR, _Period1, _Rep2, false> : _Duration_div_mod1<_CR, _Period1, _Rep2> {
        
    };

    template <class _Rep1, class _Period1, class _Rep2>
    [[nodiscard]] constexpr typename _Duration_div_mod<common_type_t<_Rep1, _Rep2>, _Period1, _Rep2>::type operator/(
        const duration<_Rep1, _Period1>& _Left,
        const _Rep2& _Right) noexcept(is_arithmetic_v<_Rep1>&& is_arithmetic_v<_Rep2>)  {
        using _CR = common_type_t<_Rep1, _Rep2>;
        using _CD = duration<_CR, _Period1>;
        return _CD(_CD(_Left).count() / _Right);
    }

    template <class _Rep1, class _Period1, class _Rep2, class _Period2>
    [[nodiscard]] constexpr common_type_t<_Rep1, _Rep2>
        operator/(const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right) noexcept(
            is_arithmetic_v<_Rep1>&& is_arithmetic_v<_Rep2>)  {
        using _CD = common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>;
        return _CD(_Left).count() / _CD(_Right).count();
    }

    template <class _Rep1, class _Period1, class _Rep2>
    [[nodiscard]] constexpr typename _Duration_div_mod<common_type_t<_Rep1, _Rep2>, _Period1, _Rep2>::type operator%(
        const duration<_Rep1, _Period1>& _Left,
        const _Rep2& _Right) noexcept(is_arithmetic_v<_Rep1>&& is_arithmetic_v<_Rep2>)  {
        using _CR = common_type_t<_Rep1, _Rep2>;
        using _CD = duration<_CR, _Period1>;
        return _CD(_CD(_Left).count() % _Right);
    }

    template <class _Rep1, class _Period1, class _Rep2, class _Period2>
    [[nodiscard]] constexpr common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>
        operator%(const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right) noexcept(
            is_arithmetic_v<_Rep1>&& is_arithmetic_v<_Rep2>)  {
        using _CD = common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>;
        return _CD(_CD(_Left).count() % _CD(_Right).count());
    }

    template <class _Rep1, class _Period1, class _Rep2, class _Period2>
    [[nodiscard]] constexpr bool
        operator==(const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right) noexcept(
            is_arithmetic_v<_Rep1>&& is_arithmetic_v<_Rep2>)  {
        using _CT = common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>;
        return _CT(_Left).count() == _CT(_Right).count();
    }


#line 402 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"

    template <class _Rep1, class _Period1, class _Rep2, class _Period2>
    [[nodiscard]] constexpr bool
        operator<(const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right) noexcept(
            is_arithmetic_v<_Rep1>&& is_arithmetic_v<_Rep2>)  {
        using _CT = common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>;
        return _CT(_Left).count() < _CT(_Right).count();
    }

    template <class _Rep1, class _Period1, class _Rep2, class _Period2>
    [[nodiscard]] constexpr bool
        operator<=(const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right) noexcept(
            is_arithmetic_v<_Rep1>&& is_arithmetic_v<_Rep2>)  {
        return !(_Right < _Left);
    }

    template <class _Rep1, class _Period1, class _Rep2, class _Period2>
    [[nodiscard]] constexpr bool
        operator>(const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right) noexcept(
            is_arithmetic_v<_Rep1>&& is_arithmetic_v<_Rep2>)  {
        return _Right < _Left;
    }

    template <class _Rep1, class _Period1, class _Rep2, class _Period2>
    [[nodiscard]] constexpr bool
        operator>=(const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right) noexcept(
            is_arithmetic_v<_Rep1>&& is_arithmetic_v<_Rep2>)  {
        return !(_Left < _Right);
    }


    template <class _Rep1, class _Period1, class _Rep2, class _Period2>
        requires three_way_comparable<typename common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>::rep>
    [[nodiscard]] constexpr auto
        operator<=>(const duration<_Rep1, _Period1>& _Left, const duration<_Rep2, _Period2>& _Right) noexcept(
            is_arithmetic_v<_Rep1>&& is_arithmetic_v<_Rep2>)  {
        
        using _CT = common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>;
        return _CT(_Left).count() <=> _CT(_Right).count();
    }
#line 444 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"

    template <class _To, class _Rep, class _Period, enable_if_t<_Is_duration_v<_To>, int> _Enabled>
    [[nodiscard]] constexpr _To duration_cast(const duration<_Rep, _Period>& _Dur) noexcept(
        is_arithmetic_v<_Rep>&& is_arithmetic_v<typename _To::rep>)  {
        
        using _CF = ratio_divide<_Period, typename _To::period>;

        using _ToRep = typename _To::rep;
        using _CR    = common_type_t<_ToRep, _Rep, intmax_t>;

        constexpr bool _Num_is_one = _CF::num == 1;
        constexpr bool _Den_is_one = _CF::den == 1;

        if (_Den_is_one) {
            if (_Num_is_one) {
                return static_cast<_To>(static_cast<_ToRep>(_Dur.count()));
            } else {
                return static_cast<_To>(
                    static_cast<_ToRep>(static_cast<_CR>(_Dur.count()) * static_cast<_CR>(_CF::num)));
            }
        } else {
            if (_Num_is_one) {
                return static_cast<_To>(
                    static_cast<_ToRep>(static_cast<_CR>(_Dur.count()) / static_cast<_CR>(_CF::den)));
            } else {
                return static_cast<_To>(static_cast<_ToRep>(
                    static_cast<_CR>(_Dur.count()) * static_cast<_CR>(_CF::num) / static_cast<_CR>(_CF::den)));
            }
        }
    }

    template <class _To, class _Rep, class _Period, enable_if_t<_Is_duration_v<_To>, int> = 0>
    [[nodiscard]] constexpr _To floor(const duration<_Rep, _Period>& _Dur) noexcept(
        is_arithmetic_v<_Rep>&& is_arithmetic_v<typename _To::rep>)  {
        
        
        const _To _Casted{::std::chrono:: duration_cast<_To>(_Dur)};
        if (_Casted > _Dur) {
            return _To{_Casted.count() - static_cast<typename _To::rep>(1)};
        }

        return _Casted;
    }

    template <class _To, class _Rep, class _Period, enable_if_t<_Is_duration_v<_To>, int> = 0>
    [[nodiscard]] constexpr _To ceil(const duration<_Rep, _Period>& _Dur) noexcept(
        is_arithmetic_v<_Rep>&& is_arithmetic_v<typename _To::rep>)  {
        
        
        const _To _Casted{::std::chrono:: duration_cast<_To>(_Dur)};
        if (_Casted < _Dur) {
            return _To{_Casted.count() + static_cast<typename _To::rep>(1)};
        }

        return _Casted;
    }

    template <class _Rep>
    constexpr bool _Is_even(_Rep _Val) noexcept(is_arithmetic_v<_Rep>)  {
        
        return _Val % 2 == 0;
    }

    template <class _To, class _Rep, class _Period,
        enable_if_t<_Is_duration_v<_To> && !treat_as_floating_point_v<typename _To::rep>, int> = 0>
    [[nodiscard]] constexpr _To round(const duration<_Rep, _Period>& _Dur) noexcept(
        is_arithmetic_v<_Rep>&& is_arithmetic_v<typename _To::rep>)  {
        
        const _To _Floored{::std::chrono:: floor<_To>(_Dur)};
        const _To _Ceiled{_Floored + _To{1}};
        const auto _Floor_adjustment = _Dur - _Floored;
        const auto _Ceil_adjustment  = _Ceiled - _Dur;
        if (_Floor_adjustment < _Ceil_adjustment
            || (_Floor_adjustment == _Ceil_adjustment && _Is_even(_Floored.count()))) {
            return _Floored;
        }

        return _Ceiled;
    }

    template <class _Rep, class _Period, enable_if_t<numeric_limits<_Rep>::is_signed, int> = 0>
    [[nodiscard]] constexpr duration<_Rep, _Period> abs(const duration<_Rep, _Period> _Dur) noexcept(
        is_arithmetic_v<_Rep>)  {
        
        return _Dur < duration<_Rep, _Period>::zero() ? duration<_Rep, _Period>::zero() - _Dur : _Dur;
    }

    using nanoseconds  = duration<long long, nano>;
    using microseconds = duration<long long, micro>;
    using milliseconds = duration<long long, milli>;
    using seconds      = duration<long long>;
    using minutes      = duration<int, ratio<60>>;
    using hours        = duration<int, ratio<3600>>;

    using days   = duration<int, ratio_multiply<ratio<24>, hours::period>>;
    using weeks  = duration<int, ratio_multiply<ratio<7>, days::period>>;
    using years  = duration<int, ratio_multiply<ratio<146097, 400>, days::period>>;
    using months = duration<int, ratio_divide<years::period, ratio<12>>>;
#line 543 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"

    template <class _Clock, class _Duration, class _Rep, class _Period>
    [[nodiscard]] constexpr time_point<_Clock, common_type_t<_Duration, duration<_Rep, _Period>>>
        operator+(const time_point<_Clock, _Duration>& _Left, const duration<_Rep, _Period>& _Right) noexcept(
            is_arithmetic_v<typename _Duration::rep>&& is_arithmetic_v<_Rep>)  {
        using _RT = time_point<_Clock, common_type_t<_Duration, duration<_Rep, _Period>>>;
        return _RT(_Left.time_since_epoch() + _Right);
    }

    template <class _Rep, class _Period, class _Clock, class _Duration>
    [[nodiscard]] constexpr time_point<_Clock, common_type_t<duration<_Rep, _Period>, _Duration>>
        operator+(const duration<_Rep, _Period>& _Left, const time_point<_Clock, _Duration>& _Right) noexcept(
            is_arithmetic_v<_Rep>&& is_arithmetic_v<typename _Duration::rep>)  {
        return _Right + _Left;
    }

    template <class _Clock, class _Duration, class _Rep, class _Period>
    [[nodiscard]] constexpr time_point<_Clock, common_type_t<_Duration, duration<_Rep, _Period>>>
        operator-(const time_point<_Clock, _Duration>& _Left, const duration<_Rep, _Period>& _Right) noexcept(
            is_arithmetic_v<typename _Duration::rep>&& is_arithmetic_v<_Rep>)  {
        using _RT = time_point<_Clock, common_type_t<_Duration, duration<_Rep, _Period>>>;
        return _RT(_Left.time_since_epoch() - _Right);
    }

    template <class _Clock, class _Duration1, class _Duration2>
    [[nodiscard]] constexpr common_type_t<_Duration1, _Duration2>
        operator-(const time_point<_Clock, _Duration1>& _Left, const time_point<_Clock, _Duration2>& _Right) noexcept(
            is_arithmetic_v<typename _Duration1::rep>&& is_arithmetic_v<typename _Duration2::rep>)  {
        return _Left.time_since_epoch() - _Right.time_since_epoch();
    }

    template <class _Clock, class _Duration1, class _Duration2>
    [[nodiscard]] constexpr bool
        operator==(const time_point<_Clock, _Duration1>& _Left, const time_point<_Clock, _Duration2>& _Right) noexcept(
            is_arithmetic_v<typename _Duration1::rep>&& is_arithmetic_v<typename _Duration2::rep>)  {
        return _Left.time_since_epoch() == _Right.time_since_epoch();
    }


#line 589 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"

    template <class _Clock, class _Duration1, class _Duration2>
    [[nodiscard]] constexpr bool
        operator<(const time_point<_Clock, _Duration1>& _Left, const time_point<_Clock, _Duration2>& _Right) noexcept(
            is_arithmetic_v<typename _Duration1::rep>&& is_arithmetic_v<typename _Duration2::rep>)  {
        return _Left.time_since_epoch() < _Right.time_since_epoch();
    }

    template <class _Clock, class _Duration1, class _Duration2>
    [[nodiscard]] constexpr bool
        operator<=(const time_point<_Clock, _Duration1>& _Left, const time_point<_Clock, _Duration2>& _Right) noexcept(
            is_arithmetic_v<typename _Duration1::rep>&& is_arithmetic_v<typename _Duration2::rep>)  {
        return !(_Right < _Left);
    }

    template <class _Clock, class _Duration1, class _Duration2>
    [[nodiscard]] constexpr bool
        operator>(const time_point<_Clock, _Duration1>& _Left, const time_point<_Clock, _Duration2>& _Right) noexcept(
            is_arithmetic_v<typename _Duration1::rep>&& is_arithmetic_v<typename _Duration2::rep>)  {
        return _Right < _Left;
    }

    template <class _Clock, class _Duration1, class _Duration2>
    [[nodiscard]] constexpr bool
        operator>=(const time_point<_Clock, _Duration1>& _Left, const time_point<_Clock, _Duration2>& _Right) noexcept(
            is_arithmetic_v<typename _Duration1::rep>&& is_arithmetic_v<typename _Duration2::rep>)  {
        return !(_Left < _Right);
    }


    template <class _Clock, class _Duration1, three_way_comparable_with<_Duration1> _Duration2>
    [[nodiscard]] constexpr auto
        operator<=>(const time_point<_Clock, _Duration1>& _Left, const time_point<_Clock, _Duration2>& _Right) noexcept(
            is_arithmetic_v<typename _Duration1::rep>&& is_arithmetic_v<typename _Duration2::rep>)  {
        return _Left.time_since_epoch() <=> _Right.time_since_epoch();
    }
#line 626 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"

    template <class _To, class _Clock, class _Duration, enable_if_t<_Is_duration_v<_To>, int> = 0>
    [[nodiscard]] constexpr time_point<_Clock, _To> time_point_cast(const time_point<_Clock, _Duration>& _Time) noexcept(
        is_arithmetic_v<typename _Duration::rep>&& is_arithmetic_v<typename _To::rep>)  {
        
        return time_point<_Clock, _To>(::std::chrono:: duration_cast<_To>(_Time.time_since_epoch()));
    }

    template <class _To, class _Clock, class _Duration, enable_if_t<_Is_duration_v<_To>, int> = 0>
    [[nodiscard]] constexpr time_point<_Clock, _To> floor(const time_point<_Clock, _Duration>& _Time) noexcept(
        is_arithmetic_v<typename _Duration::rep>&& is_arithmetic_v<typename _To::rep>)  {
        
        return time_point<_Clock, _To>(::std::chrono:: floor<_To>(_Time.time_since_epoch()));
    }

    template <class _To, class _Clock, class _Duration, enable_if_t<_Is_duration_v<_To>, int> = 0>
    [[nodiscard]] constexpr time_point<_Clock, _To> ceil(const time_point<_Clock, _Duration>& _Time) noexcept(
        is_arithmetic_v<typename _Duration::rep>&& is_arithmetic_v<typename _To::rep>)  {
        
        return time_point<_Clock, _To>(::std::chrono:: ceil<_To>(_Time.time_since_epoch()));
    }

    template <class _To, class _Clock, class _Duration,
        enable_if_t<_Is_duration_v<_To> && !treat_as_floating_point_v<typename _To::rep>, int> = 0>
    [[nodiscard]] constexpr time_point<_Clock, _To> round(const time_point<_Clock, _Duration>& _Time) noexcept(
        is_arithmetic_v<typename _Duration::rep>&& is_arithmetic_v<typename _To::rep>)  {
        
        return time_point<_Clock, _To>(::std::chrono:: round<_To>(_Time.time_since_epoch()));
    }

    struct system_clock { 
        using rep                       = long long;
        using period                    = ratio<1, 10'000'000>; 
        using duration                  = ::std::chrono:: duration<rep, period>;
        using time_point                = ::std::chrono:: time_point<system_clock>;
        static constexpr bool is_steady = false;

        [[nodiscard]] static time_point now() noexcept { 
            return time_point(duration(_Xtime_get_ticks()));
        }

        [[nodiscard]] static __time64_t to_time_t(const time_point& _Time) noexcept { 
            return duration_cast<seconds>(_Time.time_since_epoch()).count();
        }

        [[nodiscard]] static time_point from_time_t(__time64_t _Tm) noexcept { 
            return time_point{seconds{_Tm}};
        }
    };


    template <class _Duration>
    using sys_time    = time_point<system_clock, _Duration>;
    using sys_seconds = sys_time<seconds>;
    using sys_days    = sys_time<days>;
#line 682 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"

    struct steady_clock { 
        using rep                       = long long;
        using period                    = nano;
        using duration                  = nanoseconds;
        using time_point                = ::std::chrono:: time_point<steady_clock>;
        static constexpr bool is_steady = true;

        [[nodiscard]] static time_point now() noexcept { 
            const long long _Freq = _Query_perf_frequency(); 
            const long long _Ctr  = _Query_perf_counter();
            static_assert(period::num == 1, "This assumes period::num == 1.");
            
            
            constexpr long long _TenMHz = 10'000'000;
            if (_Freq == _TenMHz) {
                static_assert(period::den % _TenMHz == 0, "It should never fail.");
                constexpr long long _Multiplier = period::den / _TenMHz;
                return time_point(duration(_Ctr * _Multiplier));
            } else {
                
                
                const long long _Whole = (_Ctr / _Freq) * period::den;
                const long long _Part  = (_Ctr % _Freq) * period::den / _Freq;
                return time_point(duration(_Whole + _Part));
            }
        }
    };

    using high_resolution_clock = steady_clock;


    template <class _CharT, class _Period>
    [[nodiscard]] constexpr const _CharT* _Get_literal_unit_suffix() {
        if constexpr (is_same_v<_Period, atto>) { if constexpr (is_same_v<_CharT, char>) { return "as"; } else { return L"as"; } } else
        if constexpr (is_same_v<_Period, femto>) { if constexpr (is_same_v<_CharT, char>) { return "fs"; } else { return L"fs"; } } else
        if constexpr (is_same_v<_Period, pico>) { if constexpr (is_same_v<_CharT, char>) { return "ps"; } else { return L"ps"; } } else
        if constexpr (is_same_v<_Period, nano>) { if constexpr (is_same_v<_CharT, char>) { return "ns"; } else { return L"ns"; } } else
        if constexpr (is_same_v<_Period, micro>) { if constexpr (is_same_v<_CharT, char>) { return "us"; } else { return L"us"; } } else
        if constexpr (is_same_v<_Period, milli>) { if constexpr (is_same_v<_CharT, char>) { return "ms"; } else { return L"ms"; } } else
        if constexpr (is_same_v<_Period, centi>) { if constexpr (is_same_v<_CharT, char>) { return "cs"; } else { return L"cs"; } } else
        if constexpr (is_same_v<_Period, deci>) { if constexpr (is_same_v<_CharT, char>) { return "ds"; } else { return L"ds"; } } else
        if constexpr (is_same_v<_Period, seconds::period>) { if constexpr (is_same_v<_CharT, char>) { return "s"; } else { return L"s"; } } else
        if constexpr (is_same_v<_Period, deca>) { if constexpr (is_same_v<_CharT, char>) { return "das"; } else { return L"das"; } } else
        if constexpr (is_same_v<_Period, hecto>) { if constexpr (is_same_v<_CharT, char>) { return "hs"; } else { return L"hs"; } } else
        if constexpr (is_same_v<_Period, kilo>) { if constexpr (is_same_v<_CharT, char>) { return "ks"; } else { return L"ks"; } } else
        if constexpr (is_same_v<_Period, mega>) { if constexpr (is_same_v<_CharT, char>) { return "Ms"; } else { return L"Ms"; } } else
        if constexpr (is_same_v<_Period, giga>) { if constexpr (is_same_v<_CharT, char>) { return "Gs"; } else { return L"Gs"; } } else
        if constexpr (is_same_v<_Period, tera>) { if constexpr (is_same_v<_CharT, char>) { return "Ts"; } else { return L"Ts"; } } else
        if constexpr (is_same_v<_Period, peta>) { if constexpr (is_same_v<_CharT, char>) { return "Ps"; } else { return L"Ps"; } } else
        if constexpr (is_same_v<_Period, exa>) { if constexpr (is_same_v<_CharT, char>) { return "Es"; } else { return L"Es"; } } else
        if constexpr (is_same_v<_Period, minutes::period>) { if constexpr (is_same_v<_CharT, char>) { return "min"; } else { return L"min"; } } else
        if constexpr (is_same_v<_Period, hours::period>) { if constexpr (is_same_v<_CharT, char>) { return "h"; } else { return L"h"; } } else
        if constexpr (is_same_v<_Period, ratio<86400>>) { if constexpr (is_same_v<_CharT, char>) { return "d"; } else { return L"d"; } } else

        {
            return nullptr;
        }
    }


    template <class _CharT>
    [[nodiscard]] _CharT* _Get_general_unit_suffix(_CharT* _Rnext, const intmax_t _Num, const intmax_t _Den) {
        
        ;
        *--_Rnext = '\0';
        *--_Rnext = 's';
        *--_Rnext = ']';
        if (_Den != 1) {
            _Rnext    = _UIntegral_to_buff(_Rnext, static_cast<uintmax_t>(_Den));
            *--_Rnext = '/';
        }

        _Rnext    = _UIntegral_to_buff(_Rnext, static_cast<uintmax_t>(_Num));
        *--_Rnext = '[';
        return _Rnext;
    }

    template <class _Period, class _CharT, class _Traits>
    void _Write_unit_suffix(basic_ostream<_CharT, _Traits>& _Os) {
        constexpr auto _Suffix = _Get_literal_unit_suffix<_CharT, _Period>();
        if constexpr (_Suffix == nullptr) {
            _CharT _Buffer[2 * (numeric_limits<intmax_t>::digits10 + 1) + 5] = {}; 
            const _CharT* const _Begin =
                _Get_general_unit_suffix<_CharT>(::std:: end(_Buffer), _Period::num, _Period::den);
            _Os << _Begin;
        } else {
            _Os << _Suffix;
        }
    }

    template <class _CharT, class _Traits, class _Rep, class _Period>
    basic_ostream<_CharT, _Traits>& operator<<(
        basic_ostream<_CharT, _Traits>& _Os, const duration<_Rep, _Period>& _Dur) {
        basic_ostringstream<_CharT, _Traits> _Sstr;
        _Sstr.flags(_Os.flags());
        _Sstr.imbue(_Os.getloc());
        _Sstr.precision(_Os.precision());
        _Sstr << _Dur.count();
        _Write_unit_suffix<_Period>(_Sstr);

        return _Os << _Sstr.str();
    }

    struct local_t {};

    template <class _Duration>
    using local_time    = time_point<local_t, _Duration>;
    using local_seconds = local_time<seconds>;
    using local_days    = local_time<days>;

    struct last_spec {
        explicit last_spec() = default;
    };
    inline constexpr last_spec last{};

    class day {
    public:
        day() = default;
        constexpr explicit day(unsigned int _Val) noexcept : _Day{static_cast<unsigned char>(_Val)} {}

        constexpr day& operator++() noexcept {
            ++_Day;
            return *this;
        }
        constexpr day operator++(int) noexcept {
            return day{_Day++};
        }
        constexpr day& operator--() noexcept {
            --_Day;
            return *this;
        }
        constexpr day operator--(int) noexcept {
            return day{_Day--};
        }

        constexpr day& operator+=(const days& _Days) noexcept {
            _Day += static_cast<unsigned char>(_Days.count());
            return *this;
        }
        constexpr day& operator-=(const days& _Days) noexcept {
            _Day -= static_cast<unsigned char>(_Days.count());
            return *this;
        }

        [[nodiscard]] constexpr explicit operator unsigned int() const noexcept {
            return _Day;
        }
        [[nodiscard]] constexpr bool ok() const noexcept {
            return _Day >= 1 && _Day <= 31;
        }

    private:
        unsigned char _Day;
    };

    [[nodiscard]] constexpr bool operator==(const day& _Left, const day& _Right) noexcept {
        return static_cast<unsigned int>(_Left) == static_cast<unsigned int>(_Right);
    }
    [[nodiscard]] constexpr strong_ordering operator<=>(const day& _Left, const day& _Right) noexcept {
        return static_cast<unsigned int>(_Left) <=> static_cast<unsigned int>(_Right);
    }

    [[nodiscard]] constexpr day operator+(const day& _Left, const days& _Right) noexcept {
        return day{static_cast<unsigned int>(_Left) + _Right.count()};
    }
    [[nodiscard]] constexpr day operator+(const days& _Left, const day& _Right) noexcept {
        return _Right + _Left;
    }
    [[nodiscard]] constexpr day operator-(const day& _Left, const days& _Right) noexcept {
        return day{static_cast<unsigned int>(_Left) - _Right.count()};
    }
    [[nodiscard]] constexpr days operator-(const day& _Left, const day& _Right) noexcept {
        return days{
            static_cast<int>(static_cast<unsigned int>(_Left)) - static_cast<int>(static_cast<unsigned int>(_Right))};
    }

    class month {
    public:
        month() = default;
        constexpr explicit month(unsigned int _Val) noexcept : _Month{static_cast<unsigned char>(_Val)} {}

        constexpr month& operator++() noexcept {
            *this += months{1};
            return *this;
        }
        constexpr month operator++(int) noexcept {
            month _Temp{*this};
            ++*this;
            return _Temp;
        }
        constexpr month& operator--() noexcept {
            *this -= months{1};
            return *this;
        }
        constexpr month operator--(int) noexcept {
            month _Temp{*this};
            --*this;
            return _Temp;
        }

        constexpr month& operator+=(const months& _Months) noexcept;
        constexpr month& operator-=(const months& _Months) noexcept;

        [[nodiscard]] constexpr explicit operator unsigned int() const noexcept {
            return _Month;
        }
        [[nodiscard]] constexpr bool ok() const noexcept {
            return _Month >= 1 && _Month <= 12;
        }

    private:
        unsigned char _Month;
    };

    [[nodiscard]] constexpr bool operator==(const month& _Left, const month& _Right) noexcept {
        return static_cast<unsigned int>(_Left) == static_cast<unsigned int>(_Right);
    }
    [[nodiscard]] constexpr strong_ordering operator<=>(const month& _Left, const month& _Right) noexcept {
        return static_cast<unsigned int>(_Left) <=> static_cast<unsigned int>(_Right);
    }

    [[nodiscard]] constexpr month operator+(const month& _Left, const months& _Right) noexcept {
        const auto _Mo  = static_cast<long long>(static_cast<unsigned int>(_Left)) + (_Right.count() - 1);
        const auto _Div = (_Mo >= 0 ? _Mo : _Mo - 11) / 12;
        return month{static_cast<unsigned int>(_Mo - _Div * 12 + 1)};
    }
    [[nodiscard]] constexpr month operator+(const months& _Left, const month& _Right) noexcept {
        return _Right + _Left;
    }
    [[nodiscard]] constexpr month operator-(const month& _Left, const months& _Right) noexcept {
        return _Left + -_Right;
    }
    [[nodiscard]] constexpr months operator-(const month& _Left, const month& _Right) noexcept {
        const auto _Mo = static_cast<unsigned int>(_Left) - static_cast<unsigned int>(_Right);
        return months{_Mo <= 11 ? _Mo : _Mo + 12};
    }

    constexpr month& month::operator+=(const months& _Months) noexcept {
        *this = *this + _Months;
        return *this;
    }
    constexpr month& month::operator-=(const months& _Months) noexcept {
        *this = *this - _Months;
        return *this;
    }

    class year {
    public:
        year() = default;
        constexpr explicit year(int _Val) noexcept : _Year{static_cast<short>(_Val)} {}

        constexpr year& operator++() noexcept {
            ++_Year;
            return *this;
        }
        constexpr year operator++(int) noexcept {
            return year{_Year++};
        }
        constexpr year& operator--() noexcept {
            --_Year;
            return *this;
        }
        constexpr year operator--(int) noexcept {
            return year{_Year--};
        }

        constexpr year& operator+=(const years& _Years) noexcept {


            _Year += static_cast<short>(_Years.count());
#line 971 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"
            return *this;
        }
        constexpr year& operator-=(const years& _Years) noexcept {


            _Year -= static_cast<short>(_Years.count());
#line 979 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"
            return *this;
        }

        [[nodiscard]] constexpr year operator+() const noexcept {
            return *this;
        }
        [[nodiscard]] constexpr year operator-() const noexcept {
            return year{-_Year};
        }

        [[nodiscard]] constexpr bool is_leap() const noexcept {
            return _Year % 4 == 0 && (_Year % 100 != 0 || _Year % 400 == 0);
        }

        [[nodiscard]] constexpr explicit operator int() const noexcept {
            return _Year;
        }

        [[nodiscard]] constexpr bool ok() const noexcept {
            return _Year_min <= _Year && _Year <= _Year_max;
        }

        [[nodiscard]] static constexpr year(min)() noexcept {
            return year{_Year_min};
        }
        [[nodiscard]] static constexpr year(max)() noexcept {
            return year{_Year_max};
        }

    private:
        short _Year;
        static constexpr int _Year_min = -32767;
        static constexpr int _Year_max = 32767;
    };

    [[nodiscard]] constexpr bool operator==(const year& _Left, const year& _Right) noexcept {
        return static_cast<int>(_Left) == static_cast<int>(_Right);
    }
    [[nodiscard]] constexpr strong_ordering operator<=>(const year& _Left, const year& _Right) noexcept {
        return static_cast<int>(_Left) <=> static_cast<int>(_Right);
    }

    [[nodiscard]] constexpr year operator+(const year& _Left, const years& _Right) noexcept {
        return year{static_cast<int>(_Left) + _Right.count()};
    }
    [[nodiscard]] constexpr year operator+(const years& _Left, const year& _Right) noexcept {
        return _Right + _Left;
    }
    [[nodiscard]] constexpr year operator-(const year& _Left, const years& _Right) noexcept {
        return _Left + -_Right;
    }
    [[nodiscard]] constexpr years operator-(const year& _Left, const year& _Right) noexcept {
        return years{static_cast<int>(_Left) - static_cast<int>(_Right)};
    }

    class weekday_indexed;
    class weekday_last;

    class weekday {
    public:
        weekday() = default;
        constexpr explicit weekday(unsigned int _Val) noexcept
            : _Weekday{static_cast<unsigned char>(_Val == 7 ? 0 : _Val)} {}
        constexpr weekday(const sys_days& _Sys_day) noexcept
            : _Weekday{static_cast<unsigned char>(_Weekday_from_days(_Sys_day.time_since_epoch().count()))} {}
        constexpr explicit weekday(const local_days& _Local_day) noexcept
            : _Weekday{static_cast<unsigned char>(_Weekday_from_days(_Local_day.time_since_epoch().count()))} {}

        constexpr weekday& operator++() noexcept {
            return *this += days{1};
        }
        constexpr weekday operator++(int) noexcept {
            weekday _Temp{*this};
            ++*this;
            return _Temp;
        }
        constexpr weekday& operator--() noexcept {
            return *this -= days{1};
        }
        constexpr weekday operator--(int) noexcept {
            weekday _Temp{*this};
            --*this;
            return _Temp;
        }

        constexpr weekday& operator+=(const days& _Days) noexcept;
        constexpr weekday& operator-=(const days& _Days) noexcept;

        [[nodiscard]] constexpr unsigned int c_encoding() const noexcept {
            return _Weekday;
        }
        [[nodiscard]] constexpr unsigned int iso_encoding() const noexcept {
            return _Weekday == 0u ? 7u : _Weekday;
        }
        [[nodiscard]] constexpr bool ok() const noexcept {
            return _Weekday <= 6;
        }

        [[nodiscard]] constexpr weekday_indexed operator[](unsigned int _Index) const noexcept;
        [[nodiscard]] constexpr weekday_last operator[](last_spec) const noexcept;

    private:
        unsigned char _Weekday;

        
        [[nodiscard]] static constexpr unsigned int _Weekday_from_days(int _Tp) noexcept {
            return static_cast<unsigned int>(_Tp >= -4 ? (_Tp + 4) % 7 : (_Tp + 5) % 7 + 6);
        }
    };

    [[nodiscard]] constexpr bool operator==(const weekday& _Left, const weekday& _Right) noexcept {
        return _Left.c_encoding() == _Right.c_encoding();
    }

    [[nodiscard]] constexpr weekday operator+(const weekday& _Left, const days& _Right) noexcept {
        const auto _Wd  = static_cast<long long>(_Left.c_encoding()) + _Right.count();
        const auto _Div = (_Wd >= 0 ? _Wd : _Wd - 6) / 7;
        return weekday{static_cast<unsigned int>(_Wd - _Div * 7)};
    }
    [[nodiscard]] constexpr weekday operator+(const days& _Left, const weekday& _Right) noexcept {
        return _Right + _Left;
    }
    [[nodiscard]] constexpr weekday operator-(const weekday& _Left, const days& _Right) noexcept {
        return _Left + -_Right;
    }
    [[nodiscard]] constexpr days operator-(const weekday& _Left, const weekday& _Right) noexcept {
        const auto _Wd = _Left.c_encoding() - _Right.c_encoding();
        const auto _Wk = _Wd <= 6 ? _Wd : _Wd + 7;
        return days{_Wk};
    }

    constexpr weekday& weekday::operator+=(const days& _Days) noexcept {
        *this = *this + _Days;
        return *this;
    }
    constexpr weekday& weekday::operator-=(const days& _Days) noexcept {
        *this = *this - _Days;
        return *this;
    }

    class weekday_indexed {
    public:
        weekday_indexed() = default;
        constexpr weekday_indexed(const weekday& _Wd, unsigned int _Idx) noexcept
            : _Weekday{_Wd}, _Index{static_cast<unsigned char>(_Idx)} {}

        [[nodiscard]] constexpr weekday weekday() const noexcept {
            return _Weekday;
        }
        [[nodiscard]] constexpr unsigned int index() const noexcept {
            return _Index;
        }
        [[nodiscard]] constexpr bool ok() const noexcept {
            return _Weekday.ok() && _Index >= 1 && _Index <= 5;
        }

    private:
        ::std::chrono:: weekday _Weekday;
        unsigned char _Index;
    };

    [[nodiscard]] constexpr bool operator==(const weekday_indexed& _Left, const weekday_indexed& _Right) noexcept {
        return _Left.weekday() == _Right.weekday() && _Left.index() == _Right.index();
    }

    class weekday_last {
    public:
        constexpr explicit weekday_last(const weekday& _Wd) noexcept : _Weekday{_Wd} {}

        [[nodiscard]] constexpr weekday weekday() const noexcept {
            return _Weekday;
        }
        [[nodiscard]] constexpr bool ok() const noexcept {
            return _Weekday.ok();
        }

    private:
        ::std::chrono:: weekday _Weekday;
    };

    [[nodiscard]] constexpr bool operator==(const weekday_last& _Left, const weekday_last& _Right) noexcept {
        return _Left.weekday() == _Right.weekday();
    }

    [[nodiscard]] constexpr weekday_indexed weekday::operator[](unsigned int _Index) const noexcept {
        return {*this, _Index};
    }
    [[nodiscard]] constexpr weekday_last weekday::operator[](last_spec) const noexcept {
        return weekday_last{*this};
    }

    class month_day {
    public:
        month_day() = default;
        constexpr month_day(const month& _Month_, const day& _Day_) noexcept : _Month{_Month_}, _Day{_Day_} {}

        [[nodiscard]] constexpr month month() const noexcept {
            return _Month;
        }
        [[nodiscard]] constexpr day day() const noexcept {
            return _Day;
        }
        [[nodiscard]] constexpr bool ok() const noexcept {
            if (!_Month.ok() || !_Day.ok()) {
                return false;
            }

            const auto _Da = static_cast<unsigned int>(_Day);
            const auto _Mo = static_cast<unsigned int>(_Month);
            if (_Mo == 2) {
                return _Da <= 29;
            }

            if (_Mo == 4 || _Mo == 6 || _Mo == 9 || _Mo == 11) {
                return _Da <= 30;
            }
            return true;
        }

    private:
        ::std::chrono:: month _Month;
        ::std::chrono:: day _Day;
    };

    [[nodiscard]] constexpr bool operator==(const month_day& _Left, const month_day& _Right) noexcept {
        return _Left.month() == _Right.month() && _Left.day() == _Right.day();
    }
    [[nodiscard]] constexpr strong_ordering operator<=>(const month_day& _Left, const month_day& _Right) noexcept {
        const auto _Comp = _Left.month() <=> _Right.month();
        if (_Comp != 0) {
            return _Comp;
        }

        return _Left.day() <=> _Right.day();
    }

    class month_day_last {
    public:
        constexpr explicit month_day_last(const month& _Month_) noexcept : _Month{_Month_} {}

        [[nodiscard]] constexpr month month() const noexcept {
            return _Month;
        }
        [[nodiscard]] constexpr bool ok() const noexcept {
            return _Month.ok();
        }

    private:
        ::std::chrono:: month _Month;
    };

    [[nodiscard]] constexpr bool operator==(const month_day_last& _Left, const month_day_last& _Right) noexcept {
        return _Left.month() == _Right.month();
    }
    [[nodiscard]] constexpr strong_ordering operator<=>(
        const month_day_last& _Left, const month_day_last& _Right) noexcept {
        return _Left.month() <=> _Right.month();
    }

    class month_weekday {
    public:
        constexpr month_weekday(const month& _Month_, const weekday_indexed& _Wdi) noexcept
            : _Month{_Month_}, _Weekday_index{_Wdi} {}

        [[nodiscard]] constexpr month month() const noexcept {
            return _Month;
        }
        [[nodiscard]] constexpr weekday_indexed weekday_indexed() const noexcept {
            return _Weekday_index;
        }

        [[nodiscard]] constexpr bool ok() const noexcept {
            return _Month.ok() && _Weekday_index.ok();
        }

    private:
        ::std::chrono:: month _Month;
        ::std::chrono:: weekday_indexed _Weekday_index;
    };

    [[nodiscard]] constexpr bool operator==(const month_weekday& _Left, const month_weekday& _Right) noexcept {
        return _Left.month() == _Right.month() && _Left.weekday_indexed() == _Right.weekday_indexed();
    }

    class month_weekday_last {
    public:
        constexpr month_weekday_last(const month& _Month_, const weekday_last& _Wdl) noexcept
            : _Month{_Month_}, _Weekday_last{_Wdl} {}

        [[nodiscard]] constexpr month month() const noexcept {
            return _Month;
        }
        [[nodiscard]] constexpr weekday_last weekday_last() const noexcept {
            return _Weekday_last;
        }
        [[nodiscard]] constexpr bool ok() const noexcept {
            return _Month.ok() && _Weekday_last.ok();
        }

    private:
        ::std::chrono:: month _Month;
        ::std::chrono:: weekday_last _Weekday_last;
    };

    [[nodiscard]] constexpr bool operator==(const month_weekday_last& _Left, const month_weekday_last& _Right) noexcept {
        return _Left.month() == _Right.month() && _Left.weekday_last() == _Right.weekday_last();
    }

    class year_month {
    public:
        year_month() = default;
        constexpr year_month(const year& _Year_, const month& _Month_) noexcept : _Year{_Year_}, _Month{_Month_} {}

        [[nodiscard]] constexpr year year() const noexcept {
            return _Year;
        }
        [[nodiscard]] constexpr month month() const noexcept {
            return _Month;
        }

        template <int = 0>
        constexpr year_month& operator+=(const months& _Months) noexcept;
        template <int = 0>
        constexpr year_month& operator-=(const months& _Months) noexcept;
        constexpr year_month& operator+=(const years& _Years) noexcept;
        constexpr year_month& operator-=(const years& _Years) noexcept;

        [[nodiscard]] constexpr bool ok() const noexcept {
            return _Year.ok() && _Month.ok();
        }

    private:
        ::std::chrono:: year _Year;
        ::std::chrono:: month _Month;
    };

    [[nodiscard]] constexpr bool operator==(const year_month& _Left, const year_month& _Right) noexcept {
        return _Left.year() == _Right.year() && _Left.month() == _Right.month();
    }
    [[nodiscard]] constexpr strong_ordering operator<=>(const year_month& _Left, const year_month& _Right) noexcept {
        const auto _Comp = _Left.year() <=> _Right.year();
        if (_Comp != 0) {
            return _Comp;
        }

        return _Left.month() <=> _Right.month();
    }

    template <int = 0>
    [[nodiscard]] constexpr year_month operator+(const year_month& _Left, const months& _Right) noexcept {
        const auto _Mo  = static_cast<long long>(static_cast<unsigned int>(_Left.month())) + (_Right.count() - 1);
        const auto _Div = (_Mo >= 0 ? _Mo : _Mo - 11) / 12;
        return year_month{_Left.year() + years{_Div}, month{static_cast<unsigned int>(_Mo - _Div * 12 + 1)}};
    }
    template <int = 0>
    [[nodiscard]] constexpr year_month operator+(const months& _Left, const year_month& _Right) noexcept {
        return _Right + _Left;
    }

    template <int = 0>
    [[nodiscard]] constexpr year_month operator-(const year_month& _Left, const months& _Right) noexcept {
        return _Left + -_Right;
    }

    [[nodiscard]] constexpr months operator-(const year_month& _Left, const year_month& _Right) noexcept {
        return _Left.year() - _Right.year()
             + months{static_cast<int>(static_cast<unsigned int>(_Left.month()))
                      - static_cast<int>(static_cast<unsigned int>(_Right.month()))};
    }

    [[nodiscard]] constexpr year_month operator+(const year_month& _Left, const years& _Right) noexcept {
        return {year{_Left.year() + _Right}, _Left.month()};
    }

    [[nodiscard]] constexpr year_month operator+(const years& _Left, const year_month& _Right) noexcept {
        return _Right + _Left;
    }

    [[nodiscard]] constexpr year_month operator-(const year_month& _Left, const years& _Right) noexcept {
        return _Left + -_Right;
    }

    template <int>
    constexpr year_month& year_month::operator+=(const months& _Months) noexcept {
        *this = *this + _Months;
        return *this;
    }
    template <int>
    constexpr year_month& year_month::operator-=(const months& _Months) noexcept {
        *this = *this - _Months;
        return *this;
    }
    constexpr year_month& year_month::operator+=(const years& _Years) noexcept {
        *this = *this + _Years;
        return *this;
    }
    constexpr year_month& year_month::operator-=(const years& _Years) noexcept {
        *this = *this - _Years;
        return *this;
    }

    
    inline constexpr day _Last_day_table[] = {day{31}, day{28}, day{31}, day{30}, day{31}, day{30}, day{31}, day{31},
        day{30}, day{31}, day{30}, day{31}, day{255}, day{255}, day{255}, day{255}};

    [[nodiscard]] constexpr day _Last_day(const year& _Year, const month& _Month) {
        if (_Month == month{2} && _Year.is_leap()) {
            return day{29};
        }

        return _Last_day_table[(static_cast<unsigned int>(_Month) - 1) & 0xF];
    }

    class year_month_day_last;

    class year_month_day {
    public:
        year_month_day() = default;
        constexpr year_month_day(const year& _Year_, const month& _Month_, const day& _Day_) noexcept
            : _Year{_Year_}, _Month{_Month_}, _Day{_Day_} {}
        constexpr year_month_day(const year_month_day_last& _Ymdl) noexcept;
        constexpr year_month_day(const sys_days& _Sys_days) noexcept
            : year_month_day{_Civil_from_days(_Sys_days.time_since_epoch().count())} {}
        constexpr explicit year_month_day(const local_days& _Local_days) noexcept
            : year_month_day{_Civil_from_days(_Local_days.time_since_epoch().count())} {}

        template <int = 0>
        constexpr year_month_day& operator+=(const months& _Months) noexcept;
        template <int = 0>
        constexpr year_month_day& operator-=(const months& _Months) noexcept;
        constexpr year_month_day& operator+=(const years& _Years) noexcept;
        constexpr year_month_day& operator-=(const years& _Years) noexcept;

        [[nodiscard]] constexpr year year() const noexcept {
            return _Year;
        }
        [[nodiscard]] constexpr month month() const noexcept {
            return _Month;
        }
        [[nodiscard]] constexpr day day() const noexcept {
            return _Day;
        }

        [[nodiscard]] constexpr operator sys_days() const noexcept {
            return sys_days{_Days_from_civil()};
        }
        [[nodiscard]] constexpr explicit operator local_days() const noexcept {
            return local_days{static_cast<sys_days>(*this).time_since_epoch()};
        }
        [[nodiscard]] constexpr bool ok() const noexcept {
            if (!_Year.ok() || !_Month.ok()) {
                return false;
            }

            return _Day >= ::std::chrono:: day{1} && _Day <= _Last_day(_Year, _Month);
        }

        [[nodiscard]] constexpr int _Calculate_weekday() const noexcept {
            const int _Day_int   = static_cast<int>(static_cast<unsigned int>(_Day));
            const int _Month_int = static_cast<int>(static_cast<unsigned int>(_Month));

            const int _Era_year = static_cast<int>(_Year) - (_Month_int <= 2);
            const int _Era      = (_Era_year >= 0 ? _Era_year : _Era_year - 399) / 400;
            const int _Yoe      = _Era_year - _Era * 400;
            const int _Yday_era = ((979 * (_Month_int + (_Month_int > 2 ? -3 : 9)) + 19) >> 5) + _Day_int - 1;
            const int _Doe      = ((1461 * _Yoe) >> 2) - _Yoe / 100 + _Yday_era;
            return (_Doe + 3) % 7; 
        }

    private:
        ::std::chrono:: year _Year;
        ::std::chrono:: month _Month;
        ::std::chrono:: day _Day;

        
        [[nodiscard]] static constexpr year_month_day _Civil_from_days(int _Tp) noexcept {
            static_assert(numeric_limits<unsigned int>::digits >= 32);
            static_assert(numeric_limits<int>::digits >= 26);
            const int _Zx = _Tp + 719468; 
            
            const int _Century = (_Zx >= 0 ? 4 * _Zx + 3 : 4 * _Zx - 146093) / 146097;
            
            const unsigned int _Day_of_century =
                static_cast<unsigned int>(_Zx - ((146097 * _Century) >> 2)); 
            
            const unsigned int _Year_of_century = (91867 * (_Day_of_century + 1)) >> 25; 
            const int _Yp = static_cast<int>(_Year_of_century) + _Century * 100; 
            
            const unsigned int _Day_of_year = _Day_of_century - ((1461 * _Year_of_century) >> 2); 
            
            const unsigned int _Mp = (535 * _Day_of_year + 333) >> 14; 
            
            const unsigned int _Day   = _Day_of_year - ((979 * _Mp + 19) >> 5) + 1; 
            const unsigned int _Month = _Mp + (_Mp < 10 ? 3 : static_cast<unsigned int>(-9)); 
            return year_month_day{::std::chrono:: year{_Yp + (_Month <= 2)}, ::std::chrono:: month{_Month}, ::std::chrono:: day{_Day}};
        }
        
        
        [[nodiscard]] constexpr days _Days_from_civil() const noexcept {
            static_assert(numeric_limits<unsigned int>::digits >= 18);
            static_assert(numeric_limits<int>::digits >= 26);
            const unsigned int _Mo = static_cast<unsigned int>(_Month); 
            const int _Yp          = static_cast<int>(_Year) - (_Mo <= 2);
            const int _Century     = (_Yp >= 0 ? _Yp : _Yp - 99) / 100;
            const unsigned int _Mp = _Mo + (_Mo > 2 ? static_cast<unsigned int>(-3) : 9); 
            
            const int _Day_of_year = static_cast<int>(((979 * _Mp + 19) >> 5) + static_cast<unsigned int>(_Day)) - 1;
            
            return days{((1461 * _Yp) >> 2) - _Century + (_Century >> 2) + _Day_of_year - 719468};
        }
    };

    [[nodiscard]] constexpr bool operator==(const year_month_day& _Left, const year_month_day& _Right) noexcept {
        return _Left.year() == _Right.year() && _Left.month() == _Right.month() && _Left.day() == _Right.day();
    }
    [[nodiscard]] constexpr strong_ordering operator<=>(
        const year_month_day& _Left, const year_month_day& _Right) noexcept {
        auto _Comp = _Left.year() <=> _Right.year();
        if (_Comp != 0) {
            return _Comp;
        }

        _Comp = _Left.month() <=> _Right.month();
        if (_Comp != 0) {
            return _Comp;
        }

        return _Left.day() <=> _Right.day();
    }

    template <int = 0>
    [[nodiscard]] constexpr year_month_day operator+(const year_month_day& _Left, const months& _Right) noexcept {
        const auto _Ym = year_month{_Left.year(), _Left.month()} + _Right;
        return {_Ym.year(), _Ym.month(), _Left.day()};
    }

    template <int = 0>
    [[nodiscard]] constexpr year_month_day operator+(const months& _Left, const year_month_day& _Right) noexcept {
        return _Right + _Left;
    }

    template <int = 0>
    [[nodiscard]] constexpr year_month_day operator-(const year_month_day& _Left, const months& _Right) noexcept {
        return _Left + -_Right;
    }

    [[nodiscard]] constexpr year_month_day operator+(const year_month_day& _Left, const years& _Right) noexcept {
        return {_Left.year() + _Right, _Left.month(), _Left.day()};
    }

    [[nodiscard]] constexpr year_month_day operator+(const years& _Left, const year_month_day& _Right) noexcept {
        return _Right + _Left;
    }

    [[nodiscard]] constexpr year_month_day operator-(const year_month_day& _Left, const years& _Right) noexcept {
        return _Left + -_Right;
    }

    template <int>
    constexpr year_month_day& year_month_day::operator+=(const months& _Months) noexcept {
        *this = *this + _Months;
        return *this;
    }
    template <int>
    constexpr year_month_day& year_month_day::operator-=(const months& _Months) noexcept {
        *this = *this - _Months;
        return *this;
    }
    constexpr year_month_day& year_month_day::operator+=(const years& _Years) noexcept {
        *this = *this + _Years;
        return *this;
    }
    constexpr year_month_day& year_month_day::operator-=(const years& _Years) noexcept {
        *this = *this - _Years;
        return *this;
    }

    class year_month_day_last {
    public:
        constexpr year_month_day_last(const year& _Year_, const month_day_last& _Mdl) noexcept
            : _Year{_Year_}, _Month_day_last{_Mdl} {}

        template <int = 0>
        constexpr year_month_day_last& operator+=(const months& _Months) noexcept;
        template <int = 0>
        constexpr year_month_day_last& operator-=(const months& _Months) noexcept;
        constexpr year_month_day_last& operator+=(const years& _Years) noexcept;
        constexpr year_month_day_last& operator-=(const years& _Years) noexcept;

        [[nodiscard]] constexpr year year() const noexcept {
            return _Year;
        }
        [[nodiscard]] constexpr month month() const noexcept {
            return _Month_day_last.month();
        }
        [[nodiscard]] constexpr month_day_last month_day_last() const noexcept {
            return _Month_day_last;
        }
        [[nodiscard]] constexpr day day() const noexcept {
            return _Last_day(year(), month());
        }

        [[nodiscard]] constexpr operator sys_days() const noexcept {
            return sys_days{year_month_day{year(), month(), day()}};
        }
        [[nodiscard]] constexpr explicit operator local_days() const noexcept {
            return local_days{static_cast<sys_days>(*this).time_since_epoch()};
        }
        [[nodiscard]] constexpr bool ok() const noexcept {
            return _Year.ok() && _Month_day_last.ok();
        }

    private:
        ::std::chrono:: year _Year;
        ::std::chrono:: month_day_last _Month_day_last;
    };

    [[nodiscard]] constexpr bool operator==(const year_month_day_last& _Left, const year_month_day_last& _Right) noexcept {
        return _Left.year() == _Right.year() && _Left.month_day_last() == _Right.month_day_last();
    }
    [[nodiscard]] constexpr strong_ordering operator<=>(
        const year_month_day_last& _Left, const year_month_day_last& _Right) noexcept {
        const auto _Comp = _Left.year() <=> _Right.year();
        if (_Comp != 0) {
            return _Comp;
        }

        return _Left.month_day_last() <=> _Right.month_day_last();
    }

    template <int = 0>
    [[nodiscard]] constexpr year_month_day_last operator+(
        const year_month_day_last& _Left, const months& _Right) noexcept {
        const auto _Ym = year_month{_Left.year(), _Left.month()} + _Right;
        return {_Ym.year(), month_day_last{_Ym.month()}};
    }
    template <int = 0>
    [[nodiscard]] constexpr year_month_day_last operator+(
        const months& _Left, const year_month_day_last& _Right) noexcept {
        return _Right + _Left;
    }

    template <int = 0>
    [[nodiscard]] constexpr year_month_day_last operator-(
        const year_month_day_last& _Left, const months& _Right) noexcept {
        return _Left + -_Right;
    }

    [[nodiscard]] constexpr year_month_day_last operator+(const year_month_day_last& _Left, const years& _Right) noexcept {
        return {_Left.year() + _Right, _Left.month_day_last()};
    }
    [[nodiscard]] constexpr year_month_day_last operator+(const years& _Left, const year_month_day_last& _Right) noexcept {
        return _Right + _Left;
    }
    [[nodiscard]] constexpr year_month_day_last operator-(const year_month_day_last& _Left, const years& _Right) noexcept {
        return _Left + -_Right;
    }

    template <int>
    constexpr year_month_day_last& year_month_day_last::operator+=(const months& _Months) noexcept {
        *this = *this + _Months;
        return *this;
    }
    template <int>
    constexpr year_month_day_last& year_month_day_last::operator-=(const months& _Months) noexcept {
        *this = *this - _Months;
        return *this;
    }
    constexpr year_month_day_last& year_month_day_last::operator+=(const years& _Years) noexcept {
        *this = *this + _Years;
        return *this;
    }
    constexpr year_month_day_last& year_month_day_last::operator-=(const years& _Years) noexcept {
        *this = *this - _Years;
        return *this;
    }

    constexpr year_month_day::year_month_day(const year_month_day_last& _Ymdl) noexcept
        : _Year{_Ymdl.year()}, _Month{_Ymdl.month()}, _Day{_Ymdl.day()} {}

    class year_month_weekday {
    public:
        year_month_weekday() = default;
        constexpr year_month_weekday(const year& _Year_, const month& _Month_, const weekday_indexed& _Wdi) noexcept
            : _Year{_Year_}, _Month{_Month_}, _Weekday_index{_Wdi} {}
        constexpr year_month_weekday(const sys_days& _Sys_days) noexcept
            : year_month_weekday{_Ymwd_from_days(_Sys_days.time_since_epoch())} {}
        constexpr explicit year_month_weekday(const local_days& _Local_days) noexcept
            : year_month_weekday{_Ymwd_from_days(_Local_days.time_since_epoch())} {}

        template <int = 0>
        constexpr year_month_weekday& operator+=(const months& _Months) noexcept;
        template <int = 0>
        constexpr year_month_weekday& operator-=(const months& _Months) noexcept;
        constexpr year_month_weekday& operator+=(const years& _Years) noexcept;
        constexpr year_month_weekday& operator-=(const years& _Years) noexcept;

        [[nodiscard]] constexpr year year() const noexcept {
            return _Year;
        }
        [[nodiscard]] constexpr month month() const noexcept {
            return _Month;
        }
        [[nodiscard]] constexpr weekday weekday() const noexcept {
            return _Weekday_index.weekday();
        }
        [[nodiscard]] constexpr unsigned int index() const noexcept {
            return _Weekday_index.index();
        }
        [[nodiscard]] constexpr weekday_indexed weekday_indexed() const noexcept {
            return _Weekday_index;
        }

        [[nodiscard]] constexpr operator sys_days() const noexcept {
            const sys_days _First = year_month_day{_Year, _Month, day{1}};
            const days _Diff      = weekday() - ::std::chrono:: weekday{_First};
            const days _Days      = _Diff + days{(static_cast<int>(index()) - 1) * 7};
            return _First + _Days;
        }
        [[nodiscard]] constexpr explicit operator local_days() const noexcept {
            return local_days{static_cast<sys_days>(*this).time_since_epoch()};
        }
        [[nodiscard]] constexpr bool ok() const noexcept {
            if (!_Year.ok() || !_Month.ok() || !_Weekday_index.ok()) {
                return false;
            }

            if (_Weekday_index.index() <= 4) {
                return true;
            }

            
            const sys_days _First_of_month = year_month_day{_Year, _Month, day{1}};
            const days _First_weekday      = weekday() - ::std::chrono:: weekday{_First_of_month} + days{1};
            const days _Last               = _First_weekday + days{28};
            return static_cast<unsigned int>(_Last.count()) <= static_cast<unsigned int>(_Last_day(_Year, _Month));
        }

    private:
        ::std::chrono:: year _Year;
        ::std::chrono:: month _Month;
        ::std::chrono:: weekday_indexed _Weekday_index;

        [[nodiscard]] static constexpr year_month_weekday _Ymwd_from_days(days _Dp) noexcept {
            const ::std::chrono:: year_month_day _Ymd = sys_days{_Dp};
            const ::std::chrono:: weekday _Wd         = sys_days{_Dp};
            const auto _Idx                   = ((static_cast<unsigned int>(_Ymd.day()) - 1) / 7) + 1;
            return {_Ymd.year(), _Ymd.month(), _Wd[_Idx]};
        }
    };

    [[nodiscard]] constexpr bool operator==(const year_month_weekday& _Left, const year_month_weekday& _Right) noexcept {
        return _Left.year() == _Right.year() && _Left.month() == _Right.month()
            && _Left.weekday_indexed() == _Right.weekday_indexed();
    }

    template <int = 0>
    [[nodiscard]] constexpr year_month_weekday operator+(const year_month_weekday& _Left, const months& _Right) noexcept {
        const auto _Ym = year_month{_Left.year(), _Left.month()} + _Right;
        return {_Ym.year(), _Ym.month(), _Left.weekday_indexed()};
    }
    template <int = 0>
    [[nodiscard]] constexpr year_month_weekday operator+(const months& _Left, const year_month_weekday& _Right) noexcept {
        return _Right + _Left;
    }

    template <int = 0>
    [[nodiscard]] constexpr year_month_weekday operator-(const year_month_weekday& _Left, const months& _Right) noexcept {
        return _Left + -_Right;
    }

    [[nodiscard]] constexpr year_month_weekday operator+(const year_month_weekday& _Left, const years& _Right) noexcept {
        return year_month_weekday{_Left.year() + _Right, _Left.month(), _Left.weekday_indexed()};
    }
    [[nodiscard]] constexpr year_month_weekday operator+(const years& _Left, const year_month_weekday& _Right) noexcept {
        return _Right + _Left;
    }

    [[nodiscard]] constexpr year_month_weekday operator-(const year_month_weekday& _Left, const years& _Right) noexcept {
        return _Left + -_Right;
    }

    template <int>
    constexpr year_month_weekday& year_month_weekday::operator+=(const months& _Months) noexcept {
        *this = *this + _Months;
        return *this;
    }
    template <int>
    constexpr year_month_weekday& year_month_weekday::operator-=(const months& _Months) noexcept {
        *this = *this - _Months;
        return *this;
    }
    constexpr year_month_weekday& year_month_weekday::operator+=(const years& _Years) noexcept {
        *this = *this + _Years;
        return *this;
    }
    constexpr year_month_weekday& year_month_weekday::operator-=(const years& _Years) noexcept {
        *this = *this - _Years;
        return *this;
    }

    class year_month_weekday_last {
    public:
        constexpr year_month_weekday_last(const year& _Year_, const month& _Month_, const weekday_last& _Wdl) noexcept
            : _Year{_Year_}, _Month{_Month_}, _Weekday_last{_Wdl} {}

        template <int = 0>
        constexpr year_month_weekday_last& operator+=(const months& _Months) noexcept;
        template <int = 0>
        constexpr year_month_weekday_last& operator-=(const months& _Months) noexcept;
        constexpr year_month_weekday_last& operator+=(const years& _Years) noexcept;
        constexpr year_month_weekday_last& operator-=(const years& _Years) noexcept;

        [[nodiscard]] constexpr year year() const noexcept {
            return _Year;
        }
        [[nodiscard]] constexpr month month() const noexcept {
            return _Month;
        }
        [[nodiscard]] constexpr weekday weekday() const noexcept {
            return _Weekday_last.weekday();
        }

        [[nodiscard]] constexpr weekday_last weekday_last() const noexcept {
            return _Weekday_last;
        }

        [[nodiscard]] constexpr operator sys_days() const noexcept {
            const sys_days _Last = year_month_day_last{_Year, month_day_last{_Month}};
            const auto _Diff     = ::std::chrono:: weekday{_Last} - weekday();
            return _Last - _Diff;
        }
        [[nodiscard]] constexpr explicit operator local_days() const noexcept {
            return local_days{static_cast<sys_days>(*this).time_since_epoch()};
        }
        [[nodiscard]] constexpr bool ok() const noexcept {
            return _Year.ok() && _Month.ok() && _Weekday_last.ok();
        }

    private:
        ::std::chrono:: year _Year;
        ::std::chrono:: month _Month;
        ::std::chrono:: weekday_last _Weekday_last;
    };

    [[nodiscard]] constexpr bool operator==(
        const year_month_weekday_last& _Left, const year_month_weekday_last& _Right) noexcept {
        return _Left.year() == _Right.year() && _Left.month() == _Right.month()
            && _Left.weekday_last() == _Right.weekday_last();
    }

    template <int = 0>
    [[nodiscard]] constexpr year_month_weekday_last operator+(
        const year_month_weekday_last& _Left, const months& _Right) noexcept {
        const auto _Ym = year_month{_Left.year(), _Left.month()} + _Right;
        return {_Ym.year(), _Ym.month(), _Left.weekday_last()};
    }
    template <int = 0>
    [[nodiscard]] constexpr year_month_weekday_last operator+(
        const months& _Left, const year_month_weekday_last& _Right) noexcept {
        return _Right + _Left;
    }

    template <int = 0>
    [[nodiscard]] constexpr year_month_weekday_last operator-(
        const year_month_weekday_last& _Left, const months& _Right) noexcept {
        return _Left + -_Right;
    }

    [[nodiscard]] constexpr year_month_weekday_last operator+(
        const year_month_weekday_last& _Left, const years& _Right) noexcept {
        return {_Left.year() + _Right, _Left.month(), _Left.weekday_last()};
    }
    [[nodiscard]] constexpr year_month_weekday_last operator+(
        const years& _Left, const year_month_weekday_last& _Right) noexcept {
        return _Right + _Left;
    }

    [[nodiscard]] constexpr year_month_weekday_last operator-(
        const year_month_weekday_last& _Left, const years& _Right) noexcept {
        return _Left + -_Right;
    }

    template <int>
    constexpr year_month_weekday_last& year_month_weekday_last::operator+=(const months& _Months) noexcept {
        *this = *this + _Months;
        return *this;
    }
    template <int>
    constexpr year_month_weekday_last& year_month_weekday_last::operator-=(const months& _Months) noexcept {
        *this = *this - _Months;
        return *this;
    }
    constexpr year_month_weekday_last& year_month_weekday_last::operator+=(const years& _Years) noexcept {
        *this = *this + _Years;
        return *this;
    }
    constexpr year_month_weekday_last& year_month_weekday_last::operator-=(const years& _Years) noexcept {
        *this = *this - _Years;
        return *this;
    }

    
    [[nodiscard]] constexpr year_month operator/(const year& _Year, const month& _Month) noexcept {
        return {_Year, _Month};
    }
    [[nodiscard]] constexpr year_month operator/(const year& _Year, int _Month) noexcept {
        return _Year / month{static_cast<unsigned int>(_Month)};
    }
    [[nodiscard]] constexpr month_day operator/(const month& _Month, const day& _Day) noexcept {
        return {_Month, _Day};
    }
    [[nodiscard]] constexpr month_day operator/(const month& _Month, int _Day) noexcept {
        return _Month / day{static_cast<unsigned int>(_Day)};
    }
    [[nodiscard]] constexpr month_day operator/(int _Month, const day& _Day) noexcept {
        return month{static_cast<unsigned int>(_Month)} / _Day;
    }
    [[nodiscard]] constexpr month_day operator/(const day& _Day, const month& _Month) noexcept {
        return _Month / _Day;
    }
    [[nodiscard]] constexpr month_day operator/(const day& _Day, int _Month) noexcept {
        return month{static_cast<unsigned int>(_Month)} / _Day;
    }
    [[nodiscard]] constexpr month_day_last operator/(const month& _Month, last_spec) noexcept {
        return month_day_last{_Month};
    }
    [[nodiscard]] constexpr month_day_last operator/(int _Month, last_spec) noexcept {
        return month{static_cast<unsigned int>(_Month)} / last;
    }
    [[nodiscard]] constexpr month_day_last operator/(last_spec, const month& _Month) noexcept {
        return _Month / last;
    }
    [[nodiscard]] constexpr month_day_last operator/(last_spec, int _Month) noexcept {
        return month{static_cast<unsigned int>(_Month)} / last;
    }
    [[nodiscard]] constexpr month_weekday operator/(const month& _Month, const weekday_indexed& _Wdi) noexcept {
        return {_Month, _Wdi};
    }
    [[nodiscard]] constexpr month_weekday operator/(int _Month, const weekday_indexed& _Wdi) noexcept {
        return month{static_cast<unsigned int>(_Month)} / _Wdi;
    }
    [[nodiscard]] constexpr month_weekday operator/(const weekday_indexed& _Wdi, const month& _Month) noexcept {
        return _Month / _Wdi;
    }
    [[nodiscard]] constexpr month_weekday operator/(const weekday_indexed& _Wdi, int _Month) noexcept {
        return month{static_cast<unsigned int>(_Month)} / _Wdi;
    }
    [[nodiscard]] constexpr month_weekday_last operator/(const month& _Month, const weekday_last& _Wdl) noexcept {
        return {_Month, _Wdl};
    }
    [[nodiscard]] constexpr month_weekday_last operator/(int _Month, const weekday_last& _Wdl) noexcept {
        return month{static_cast<unsigned int>(_Month)} / _Wdl;
    }
    [[nodiscard]] constexpr month_weekday_last operator/(const weekday_last& _Wdl, const month& _Month) noexcept {
        return _Month / _Wdl;
    }
    [[nodiscard]] constexpr month_weekday_last operator/(const weekday_last& _Wdl, int _Month) noexcept {
        return month{static_cast<unsigned int>(_Month)} / _Wdl;
    }
    [[nodiscard]] constexpr year_month_day operator/(const year_month& _Ym, const day& _Day) noexcept {
        return {_Ym.year(), _Ym.month(), _Day};
    }
    [[nodiscard]] constexpr year_month_day operator/(const year_month& _Ym, int _Day) noexcept {
        return _Ym / day{static_cast<unsigned int>(_Day)};
    }
    [[nodiscard]] constexpr year_month_day operator/(const year& _Year, const month_day& _Md) noexcept {
        return _Year / _Md.month() / _Md.day();
    }
    [[nodiscard]] constexpr year_month_day operator/(int _Year, const month_day& _Md) noexcept {
        return year{_Year} / _Md.month() / _Md.day();
    }
    [[nodiscard]] constexpr year_month_day operator/(const month_day& _Md, const year& _Year) noexcept {
        return _Year / _Md.month() / _Md.day();
    }
    [[nodiscard]] constexpr year_month_day operator/(const month_day& _Md, int _Year) noexcept {
        return year{_Year} / _Md.month() / _Md.day();
    }
    [[nodiscard]] constexpr year_month_day_last operator/(const year_month& _Ym, last_spec) noexcept {
        return {_Ym.year(), month_day_last{_Ym.month()}};
    }
    [[nodiscard]] constexpr year_month_day_last operator/(const year& _Year, const month_day_last& _Mdl) noexcept {
        return {_Year, _Mdl};
    }
    [[nodiscard]] constexpr year_month_day_last operator/(int _Year, const month_day_last& _Mdl) noexcept {
        return year{_Year} / _Mdl;
    }
    [[nodiscard]] constexpr year_month_day_last operator/(const month_day_last& _Mdl, const year& _Year) noexcept {
        return _Year / _Mdl;
    }
    [[nodiscard]] constexpr year_month_day_last operator/(const month_day_last& _Mdl, int _Year) noexcept {
        return year{_Year} / _Mdl;
    }
    [[nodiscard]] constexpr year_month_weekday operator/(const year_month& _Ym, const weekday_indexed& _Wdi) noexcept {
        return year_month_weekday{_Ym.year(), _Ym.month(), _Wdi};
    }
    [[nodiscard]] constexpr year_month_weekday operator/(const year& _Year, const month_weekday& _Mwd) noexcept {
        return year_month_weekday{_Year, _Mwd.month(), _Mwd.weekday_indexed()};
    }
    [[nodiscard]] constexpr year_month_weekday operator/(int _Year, const month_weekday& _Mwd) noexcept {
        return year{_Year} / _Mwd;
    }
    [[nodiscard]] constexpr year_month_weekday operator/(const month_weekday& _Mwd, const year& _Year) noexcept {
        return _Year / _Mwd;
    }
    [[nodiscard]] constexpr year_month_weekday operator/(const month_weekday& _Mwd, int _Year) noexcept {
        return year{_Year} / _Mwd;
    }
    [[nodiscard]] constexpr year_month_weekday_last operator/(const year_month& _Ym, const weekday_last& _Wdl) noexcept {
        return {_Ym.year(), _Ym.month(), _Wdl};
    }
    [[nodiscard]] constexpr year_month_weekday_last operator/(
        const year& _Year, const month_weekday_last& _Mwdl) noexcept {
        return {_Year, _Mwdl.month(), _Mwdl.weekday_last()};
    }
    [[nodiscard]] constexpr year_month_weekday_last operator/(int _Year, const month_weekday_last& _Mwdl) noexcept {
        return year{_Year} / _Mwdl;
    }
    [[nodiscard]] constexpr year_month_weekday_last operator/(
        const month_weekday_last& _Mwdl, const year& _Year) noexcept {
        return _Year / _Mwdl;
    }
    [[nodiscard]] constexpr year_month_weekday_last operator/(const month_weekday_last& _Mwdl, int _Year) noexcept {
        return year{_Year} / _Mwdl;
    }

    
    inline constexpr weekday Sunday{0};
    inline constexpr weekday Monday{1};
    inline constexpr weekday Tuesday{2};
    inline constexpr weekday Wednesday{3};
    inline constexpr weekday Thursday{4};
    inline constexpr weekday Friday{5};
    inline constexpr weekday Saturday{6};

    inline constexpr month January{1};
    inline constexpr month February{2};
    inline constexpr month March{3};
    inline constexpr month April{4};
    inline constexpr month May{5};
    inline constexpr month June{6};
    inline constexpr month July{7};
    inline constexpr month August{8};
    inline constexpr month September{9};
    inline constexpr month October{10};
    inline constexpr month November{11};
    inline constexpr month December{12};

    [[nodiscard]] constexpr intmax_t _Pow10(const unsigned int _Exp) {
        intmax_t _Result = 1;
        for (unsigned int _Ix = 0; _Ix < _Exp; ++_Ix) {
            _Result *= 10;
        }
        return _Result;
    }

    template <class _Duration>
    class hh_mm_ss {
    public:
        static_assert(_Is_duration_v<_Duration>,
            "N4885 [time.hms.overview]/2 mandates Duration to be a specialization of chrono::duration.");

        static constexpr unsigned int fractional_width = [] {
            auto _Num           = _Duration::period::num;
            constexpr auto _Den = _Duration::period::den;
            
            
            ;
            unsigned int _Result = 0;
            for (; _Num % _Den != 0 && _Result < 19; _Num = _Num % _Den * 10, ++_Result) {
            }
            return _Result == 19 ? 6 : _Result;
        }();
        using precision =
            duration<common_type_t<typename _Duration::rep, seconds::rep>, ratio<1, _Pow10(fractional_width)>>;

        constexpr hh_mm_ss() noexcept : hh_mm_ss{_Duration::zero()} {}
        constexpr explicit hh_mm_ss(_Duration _Dur)
            : _Is_neg{_Dur < _Duration::zero()}, 
              _Hours{::std::chrono:: duration_cast<::std::chrono:: hours>(::std::chrono:: abs(_Dur))},
              _Mins{::std::chrono:: duration_cast<::std::chrono:: minutes>(::std::chrono:: abs(_Dur) - hours())},
              _Secs{::std::chrono:: duration_cast<::std::chrono:: seconds>(::std::chrono:: abs(_Dur) - hours() - minutes())} {
            if constexpr (treat_as_floating_point_v<typename precision::rep>) {
                _Sub_secs = ::std::chrono:: abs(_Dur) - hours() - minutes() - seconds();
            } else {
                _Sub_secs = ::std::chrono:: duration_cast<precision>(::std::chrono:: abs(_Dur) - hours() - minutes() - seconds());
            }
        }

        [[nodiscard]] constexpr bool is_negative() const noexcept {
            return _Is_neg;
        }
        [[nodiscard]] constexpr hours hours() const noexcept {
            return _Hours;
        }
        [[nodiscard]] constexpr minutes minutes() const noexcept {
            return _Mins;
        }
        [[nodiscard]] constexpr seconds seconds() const noexcept {
            return _Secs;
        }
        [[nodiscard]] constexpr precision subseconds() const noexcept {
            return _Sub_secs;
        }

        [[nodiscard]] constexpr explicit operator precision() const noexcept {
            return to_duration();
        }
        [[nodiscard]] constexpr precision to_duration() const noexcept {
            const auto _Dur = _Hours + _Mins + _Secs + _Sub_secs;
            return _Is_neg ? -_Dur : _Dur;
        }

    private:
        bool _Is_neg;
        ::std::chrono:: hours _Hours;
        ::std::chrono:: minutes _Mins;
        ::std::chrono:: seconds _Secs;
        precision _Sub_secs;
    };

    [[nodiscard]] constexpr bool is_am(const hours& _Hours) noexcept {
        return _Hours >= hours{0} && _Hours <= hours{11};
    }
    [[nodiscard]] constexpr bool is_pm(const hours& _Hours) noexcept {
        return _Hours >= hours{12} && _Hours <= hours{23};
    }

    [[nodiscard]] constexpr hours make12(const hours& _Hours) noexcept {
        const auto _H_count{_Hours.count()};
        auto _Ret{_H_count == 0 ? 12 : _H_count};
        if (_Ret > 12) {
            _Ret -= 12;
        }

        return hours{_Ret};
    }
    [[nodiscard]] constexpr hours make24(const hours& _Hours, bool _Is_pm) noexcept {
        const auto _H_count{_Hours.count()};
        auto _Ret{_H_count == 12 ? 0 : _H_count};
        if (_Is_pm) {
            _Ret += 12;
        }

        return hours{_Ret};
    }

    
    struct sys_info {
        sys_seconds begin;
        sys_seconds end;
        seconds offset;
        minutes save;
        string abbrev;
    };

    struct local_info {
        static constexpr int unique      = 0;
        static constexpr int nonexistent = 1;
        static constexpr int ambiguous   = 2;

        int result;
        sys_info first;
        sys_info second;
    };

    class nonexistent_local_time : public runtime_error {
    public:
        template <class _Duration>
        nonexistent_local_time(const local_time<_Duration>& _Tp, const local_info& _Info)
            : runtime_error(_Make_string(_Tp, _Info)) {}

    private:

        template <class _Duration>
        [[nodiscard]] static string _Make_string(const local_time<_Duration>& _Tp, const local_info& _Info);


#line 2280 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"
    };

    class ambiguous_local_time : public runtime_error {
    public:
        template <class _Duration>
        ambiguous_local_time(const local_time<_Duration>& _Tp, const local_info& _Info)
            : runtime_error(_Make_string(_Tp, _Info)) {}

    private:

        template <class _Duration>
        [[nodiscard]] static string _Make_string(const local_time<_Duration>& _Tp, const local_info& _Info);


#line 2298 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"
    };

    
    enum class choose { earliest, latest };

    class time_zone {
    public:
        explicit time_zone(string_view _Name_) : _Name(_Name_) {}

        time_zone(time_zone&&) = default;
        time_zone& operator=(time_zone&&) = default;

        [[nodiscard]] string_view name() const noexcept {
            return _Name;
        }

        template <class _Duration>
        [[nodiscard]] sys_info get_info(const sys_time<_Duration>& _Sys) const {
            return _Get_info(_Sys.time_since_epoch());
        }

        template <class _Duration>
        [[nodiscard]] local_info get_info(const local_time<_Duration>& _Local) const {
            local_info _Info{};
            const auto _Time_since_ep = _Local.time_since_epoch();
            _Info.first               = _Get_info(_Time_since_ep);

            const sys_seconds _Local_sys{::std::chrono:: duration_cast<sys_seconds::duration>(_Time_since_ep)};
            const auto _Curr_sys = _Local_sys - _Info.first.offset;
            if (_Info.first.begin != _Min_seconds && _Curr_sys < _Info.first.begin + days{1}) {
                
                _Info.second = get_info(_Info.first.begin - seconds{1});

                const auto _Transition = _Info.first.begin;
                const auto _Prev_sys   = _Local_sys - _Info.second.offset;
                if (_Curr_sys >= _Transition) {
                    if (_Prev_sys < _Transition) {
                        _Info.result = local_info::ambiguous;
                        ::std:: swap(_Info.first, _Info.second);
                    } else {
                        _Info.result = local_info::unique;
                        _Info.second = {};
                    }
                } else {
                    if (_Prev_sys >= _Transition) {
                        _Info.result = local_info::nonexistent;
                        ::std:: swap(_Info.first, _Info.second);
                    } else {
                        _Info.result = local_info::unique;
                        _Info.first  = ::std:: move(_Info.second);
                        _Info.second = {};
                    }
                }
            } else if (_Info.first.end != _Max_seconds && _Curr_sys > _Info.first.end - days{1}) {
                
                _Info.second = get_info(_Info.first.end + seconds{1});

                const auto _Transition = _Info.first.end;
                const auto _Next_sys   = _Local_sys - _Info.second.offset;
                if (_Curr_sys < _Transition) {
                    if (_Next_sys >= _Transition) {
                        _Info.result = local_info::ambiguous;
                    } else {
                        _Info.result = local_info::unique;
                        _Info.second = {};
                    }
                } else {
                    if (_Next_sys < _Transition) {
                        _Info.result = local_info::nonexistent;
                    } else {
                        _Info.result = local_info::unique;
                        _Info.first  = ::std:: move(_Info.second);
                        _Info.second = {};
                    }
                }
            } else {
                
                _Info.result = local_info::unique;
                _Info.second = {};
            }

            return _Info;
        }

        template <class _Duration>
        [[nodiscard]] sys_time<common_type_t<_Duration, seconds>> to_sys(const local_time<_Duration>& _Local) const {
            const auto _Info = get_info(_Local);
            if (_Info.result == local_info::nonexistent) {
                throw nonexistent_local_time(_Local, _Info);
            } else if (_Info.result == local_info::ambiguous) {
                throw ambiguous_local_time(_Local, _Info);
            }

            return sys_time<common_type_t<_Duration, seconds>>{_Local.time_since_epoch() - _Info.first.offset};
        }

        template <class _Duration>
        [[nodiscard]] sys_time<common_type_t<_Duration, seconds>> to_sys(
            const local_time<_Duration>& _Local, const choose _Choose) const {
            const auto _Info = get_info(_Local);
            if (_Info.result == local_info::nonexistent) {
                return _Info.first.end;
            }

            const auto _Offset = (_Info.result == local_info::unique || _Choose == choose::earliest)
                                   ? _Info.first.offset
                                   : _Info.second.offset;
            return sys_time<common_type_t<_Duration, seconds>>{_Local.time_since_epoch() - _Offset};
        }

        template <class _Duration>
        [[nodiscard]] local_time<common_type_t<_Duration, seconds>> to_local(const sys_time<_Duration>& _Sys) const {
            const auto _Info = get_info(_Sys);
            return local_time<common_type_t<_Duration, seconds>>{_Sys.time_since_epoch() + _Info.offset};
        }

        static constexpr sys_seconds _Min_seconds{sys_days{(year::min)() / January / 1}};
        static constexpr sys_seconds _Max_seconds{sys_seconds{sys_days{(year::max)() / December / 32}} - seconds{1}};

    private:
        template <class _Duration>
        [[nodiscard]] sys_info _Get_info(const _Duration& _Dur) const {
            using _Internal_duration = duration<__std_tzdb_epoch_milli, milli>;
            const auto _Internal_dur = ::std::chrono:: duration_cast<_Internal_duration>(_Dur);
            const unique_ptr<__std_tzdb_sys_info, _Tzdb_deleter<__std_tzdb_sys_info>> _Info{
                __std_tzdb_get_sys_info(_Name.c_str(), _Name.length(), _Internal_dur.count())};
            if (_Info == nullptr) {
                _Xbad_alloc();
            } else if (_Info->_Err == __std_tzdb_error::_Win_error) {
                _XGetLastError();
            } else if (_Info->_Err == __std_tzdb_error::_Icu_error) {
                _Xruntime_error("Internal error loading IANA database information");
            }

            constexpr auto _Min_internal =
                ::std::chrono:: duration_cast<_Internal_duration>(_Min_seconds.time_since_epoch()).count();
            constexpr auto _Max_internal =
                ::std::chrono:: duration_cast<_Internal_duration>(_Max_seconds.time_since_epoch()).count();
            const auto _Begin =
                _Info->_Begin <= _Min_internal
                    ? _Min_seconds
                    : sys_seconds{::std::chrono:: duration_cast<sys_seconds::duration>(_Internal_duration{_Info->_Begin})};
            const auto _End =
                _Info->_End >= _Max_internal
                    ? _Max_seconds
                    : sys_seconds{::std::chrono:: duration_cast<sys_seconds::duration>(_Internal_duration{_Info->_End})};
            return {.begin = _Begin,
                .end       = _End,
                .offset    = ::std::chrono:: duration_cast<seconds>(_Internal_duration{_Info->_Offset}),
                .save      = ::std::chrono:: duration_cast<minutes>(_Internal_duration{_Info->_Save}),
                .abbrev    = _Info->_Abbrev};
        }

        string _Name;
    };

    [[nodiscard]] inline bool operator==(const time_zone& _Left, const time_zone& _Right) noexcept {
        return _Left.name() == _Right.name();
    }


    [[nodiscard]] inline strong_ordering operator<=>(const time_zone& _Left, const time_zone& _Right) noexcept {
        return _Left.name() <=> _Right.name();
    }
#line 2464 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"

    
    class leap_second {
    public:
        leap_second(const leap_second&) = default;
        leap_second& operator=(const leap_second&) = default;

        constexpr leap_second(
            const sys_seconds& _Date_, const bool _Is_positive_, const seconds& _Prev_elapsed) noexcept
            : _Date{_Date_}, _Is_positive{_Is_positive_} {
            _Elapsed_offset = _Prev_elapsed + value();
        }

        [[nodiscard]] constexpr sys_seconds date() const noexcept {
            return _Date;
        }

        [[nodiscard]] constexpr seconds value() const noexcept {
            return _Is_positive ? seconds{1} : seconds{-1};
        }

        [[nodiscard]] constexpr bool _Positive() const noexcept {
            return _Is_positive;
        }

        [[nodiscard]] constexpr seconds _Elapsed() const noexcept {
            return _Elapsed_offset;
        }

    private:
        sys_seconds _Date;
        bool _Is_positive;
        seconds _Elapsed_offset;
    };

    [[nodiscard]] constexpr bool operator==(const leap_second& _Left, const leap_second& _Right) noexcept {
        return _Left.date() == _Right.date();
    }
    template <class _Duration>
    [[nodiscard]] constexpr bool operator==(const leap_second& _Left, const sys_time<_Duration>& _Right) noexcept {
        return _Left.date() == _Right;
    }

    template <class _Duration>
    [[nodiscard]] constexpr bool operator<(const leap_second& _Left, const sys_time<_Duration>& _Right) noexcept {
        return _Left.date() < _Right;
    }
    template <class _Duration>
    [[nodiscard]] constexpr bool operator<(const sys_time<_Duration>& _Left, const leap_second& _Right) noexcept {
        return _Left < _Right.date();
    }

    template <class _Duration>
    [[nodiscard]] constexpr bool operator>(const leap_second& _Left, const sys_time<_Duration>& _Right) noexcept {
        return _Right < _Left.date();
    }
    template <class _Duration>
    [[nodiscard]] constexpr bool operator>(const sys_time<_Duration>& _Left, const leap_second& _Right) noexcept {
        return _Right.date() < _Left;
    }

    template <class _Duration>
    [[nodiscard]] constexpr bool operator<=(const leap_second& _Left, const sys_time<_Duration>& _Right) noexcept {
        return !(_Right < _Left.date());
    }
    template <class _Duration>
    [[nodiscard]] constexpr bool operator<=(const sys_time<_Duration>& _Left, const leap_second& _Right) noexcept {
        return !(_Right.date() < _Left);
    }

    template <class _Duration>
    [[nodiscard]] constexpr bool operator>=(const leap_second& _Left, const sys_time<_Duration>& _Right) noexcept {
        return !(_Left.date() < _Right);
    }
    template <class _Duration>
    [[nodiscard]] constexpr bool operator>=(const sys_time<_Duration>& _Left, const leap_second& _Right) noexcept {
        return !(_Left < _Right.date());
    }


    template <class _Duration>
        requires three_way_comparable_with<sys_seconds, sys_time<_Duration>>
    [[nodiscard]] constexpr auto operator<=>(
        const leap_second& _Left, const sys_time<_Duration>& _Right) noexcept {
        
        return _Left.date() <=> _Right;
    }
    [[nodiscard]] constexpr strong_ordering operator<=>(const leap_second& _Left, const leap_second& _Right) noexcept {
        return _Left.date() <=> _Right.date();
    }
#line 2557 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"

    
    class time_zone_link {
    public:
        explicit time_zone_link(string_view _Name_, string_view _Target_) : _Name(_Name_), _Target(_Target_) {}

        time_zone_link(time_zone_link&&) = default;
        time_zone_link& operator=(time_zone_link&&) = default;

        [[nodiscard]] string_view name() const noexcept {
            return _Name;
        }

        [[nodiscard]] string_view target() const noexcept {
            return _Target;
        }

    private:
        string _Name;
        string _Target;
    };

    [[nodiscard]] inline bool operator==(const time_zone_link& _Left, const time_zone_link& _Right) noexcept {
        return _Left.name() == _Right.name();
    }


    [[nodiscard]] inline strong_ordering operator<=>(const time_zone_link& _Left, const time_zone_link& _Right) noexcept {
        return _Left.name() <=> _Right.name();
    }
#line 2589 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"

    
    [[nodiscard]] inline string _Tzdb_generate_current_zone() {
        unique_ptr<__std_tzdb_current_zone_info, _Tzdb_deleter<__std_tzdb_current_zone_info>> _Info{
            __std_tzdb_get_current_zone()};
        if (_Info == nullptr) {
            _Xbad_alloc();
        } else if (_Info->_Err == __std_tzdb_error::_Win_error) {
            _XGetLastError();
        } else if (_Info->_Err == __std_tzdb_error::_Icu_error) {
            _Xruntime_error("Internal error loading IANA database information");
        }

        return {_Info->_Tz_name};
    }

    template <class _Ty>
    [[nodiscard]] const _Ty* _Locate_zone_impl(const vector<_Ty>& _Vec, string_view _Name) {
        const auto _Result = ::std:: find_if(_Vec.begin(), _Vec.end(), [&](auto& _Tz) { return _Tz.name() == _Name; });
        return _Result == _Vec.end() ? nullptr : &*_Result;
    }

    struct tzdb {
        string version;
        vector<time_zone> zones;
        vector<time_zone_link> links;
        vector<leap_second> leap_seconds;
        bool _All_ls_positive;

        [[nodiscard]] const time_zone* locate_zone(string_view _Tz_name) const {
            auto _Tz = _Locate_zone_impl(zones, _Tz_name);
            if (_Tz != nullptr) {
                return _Tz;
            }

            const auto _Link = _Locate_zone_impl(links, _Tz_name);
            if (_Link != nullptr) {
                _Tz = _Locate_zone_impl(zones, _Link->target());
                if (_Tz != nullptr) {
                    return _Tz;
                }
            }

            _Xruntime_error("unable to locate time_zone with given name");
        }

        [[nodiscard]] const time_zone* current_zone() const {
            return locate_zone(_Tzdb_generate_current_zone());
        }
    };

    [[nodiscard]] inline tuple<string, decltype(tzdb::zones), decltype(tzdb::links)> _Tzdb_generate_time_zones() {
        unique_ptr<__std_tzdb_time_zones_info, _Tzdb_deleter<__std_tzdb_time_zones_info>> _Info{
            __std_tzdb_get_time_zones()};
        if (_Info == nullptr) {
            _Xbad_alloc();
        } else if (_Info->_Err == __std_tzdb_error::_Win_error) {
            _XGetLastError();
        } else if (_Info->_Err == __std_tzdb_error::_Icu_error) {
            _Xruntime_error("Internal error loading IANA database information");
        }

        decltype(tzdb::zones) _Time_zones;
        decltype(tzdb::links) _Time_zone_links;
        for (size_t _Idx = 0; _Idx < _Info->_Num_time_zones; ++_Idx) {
            const string_view _Name{_Info->_Names[_Idx]};
            if (_Info->_Links[_Idx] == nullptr) {
                _Time_zones.emplace_back(_Name);
            } else {
                const string_view _Target{_Info->_Links[_Idx]};
                _Time_zone_links.emplace_back(_Name, _Target);
            }
        }

        return {_Info->_Version, ::std:: move(_Time_zones), ::std:: move(_Time_zone_links)};
    }

    [[nodiscard]] inline pair<decltype(tzdb::leap_seconds), bool> _Tzdb_generate_leap_seconds(const size_t _Current_size) {
        
        static constexpr leap_second _Known_leap_seconds[]{
            {sys_seconds{seconds{78796800}}, true, seconds{0}},
            {sys_seconds{seconds{94694400}}, true, seconds{1}},
            {sys_seconds{seconds{126230400}}, true, seconds{2}},
            {sys_seconds{seconds{157766400}}, true, seconds{3}},
            {sys_seconds{seconds{189302400}}, true, seconds{4}},
            {sys_seconds{seconds{220924800}}, true, seconds{5}},
            {sys_seconds{seconds{252460800}}, true, seconds{6}},
            {sys_seconds{seconds{283996800}}, true, seconds{7}},
            {sys_seconds{seconds{315532800}}, true, seconds{8}},
            {sys_seconds{seconds{362793600}}, true, seconds{9}},
            {sys_seconds{seconds{394329600}}, true, seconds{10}},
            {sys_seconds{seconds{425865600}}, true, seconds{11}},
            {sys_seconds{seconds{489024000}}, true, seconds{12}},
            {sys_seconds{seconds{567993600}}, true, seconds{13}},
            {sys_seconds{seconds{631152000}}, true, seconds{14}},
            {sys_seconds{seconds{662688000}}, true, seconds{15}},
            {sys_seconds{seconds{709948800}}, true, seconds{16}},
            {sys_seconds{seconds{741484800}}, true, seconds{17}},
            {sys_seconds{seconds{773020800}}, true, seconds{18}},
            {sys_seconds{seconds{820454400}}, true, seconds{19}},
            {sys_seconds{seconds{867715200}}, true, seconds{20}},
            {sys_seconds{seconds{915148800}}, true, seconds{21}},
            {sys_seconds{seconds{1136073600}}, true, seconds{22}},
            {sys_seconds{seconds{1230768000}}, true, seconds{23}},
            {sys_seconds{seconds{1341100800}}, true, seconds{24}},
            {sys_seconds{seconds{1435708800}}, true, seconds{25}},
            {sys_seconds{seconds{1483228800}}, true, seconds{26}},
        };

        
        constexpr size_t _Pre_2018_count = 27;
        const size_t _Known_post_2018_ls_size =
            (::std:: max)(_Current_size, ::std:: size(_Known_leap_seconds)) - _Pre_2018_count;

        size_t _Reg_post_2018_ls_size; 
        unique_ptr<__std_tzdb_leap_info[], _Tzdb_deleter<__std_tzdb_leap_info[]>> _Reg_ls_data{
            __std_tzdb_get_leap_seconds(_Known_post_2018_ls_size, &_Reg_post_2018_ls_size)};

        if (_Reg_post_2018_ls_size > _Known_post_2018_ls_size && !_Reg_ls_data) {
            _Xbad_alloc(); 
        } else if (_Reg_post_2018_ls_size == 0 && _Reg_ls_data) {
            _XGetLastError(); 
        }

        const size_t _New_size = _Pre_2018_count + _Reg_post_2018_ls_size; 
        decltype(tzdb::leap_seconds) _Leap_sec_info;
        bool _All_ls_positive = true;

        if (_New_size > _Current_size) {
            _Leap_sec_info.reserve(_New_size);
            _Leap_sec_info.assign(::std:: cbegin(_Known_leap_seconds), ::std:: cend(_Known_leap_seconds));

            for (size_t _Idx = 0; _Idx < _Reg_post_2018_ls_size; ++_Idx) {
                
                
                const auto& _Ls = _Reg_ls_data[_Idx];
                const auto _Date =
                    static_cast<sys_days>(year_month_day{year{_Ls._Year}, month{_Ls._Month}, day{_Ls._Day}})
                    + hours{_Ls._Hour + 1};
                _Leap_sec_info.emplace_back(_Date, !_Ls._Negative, _Leap_sec_info.back()._Elapsed());
                _All_ls_positive = _All_ls_positive && !_Ls._Negative;
            }
        }

        return {::std:: move(_Leap_sec_info), _All_ls_positive};
    }

    [[nodiscard]] inline string _Tzdb_update_version(const string_view _Version, const size_t _Num_leap_seconds) {
        string _Icu_version{_Version.substr(0, _Version.find_last_of('.'))};
        return ::std:: move(_Icu_version) + "." + ::std:: to_string(_Num_leap_seconds);
    }

    class tzdb_list {
    private:
        using _ListType = forward_list<tzdb, _Crt_allocator<tzdb>>;

    public:
        using const_iterator = _ListType::const_iterator;

        tzdb_list(const tzdb_list&) = delete;
        tzdb_list& operator=(const tzdb_list&) = delete;

        tzdb_list() {
            auto [_Icu_version, _Zones, _Links] = _Tzdb_generate_time_zones();
            auto [_Leap_sec, _All_ls_positive]  = _Tzdb_generate_leap_seconds(0);
            auto _Version                       = _Icu_version + "." + ::std:: to_string(_Leap_sec.size());
            _Tzdb_list.emplace_front(tzdb{
                ::std:: move(_Version), ::std:: move(_Zones), ::std:: move(_Links), ::std:: move(_Leap_sec), _All_ls_positive});
        }

        [[nodiscard]] const tzdb& front() const noexcept {
            _Shared_lock _Lk(_Tzdb_mutex);
            return _Tzdb_list.front();
        }

        const_iterator erase_after(const_iterator _Where) noexcept  {
            _Unique_lock _Lk(_Tzdb_mutex);
            return _Tzdb_list.erase_after(_Where);
        }

        [[nodiscard]] const_iterator begin() const noexcept {
            _Shared_lock _Lk(_Tzdb_mutex);
            return _Tzdb_list.begin();
        }

        [[nodiscard]] const_iterator end() const noexcept {
            return _Tzdb_list.end(); 
        }

        [[nodiscard]] const_iterator cbegin() const noexcept {
            _Shared_lock _Lk(_Tzdb_mutex);
            return _Tzdb_list.cbegin();
        }

        [[nodiscard]] const_iterator cend() const noexcept {
            return _Tzdb_list.cend(); 
        }

        template <class... _ArgsTy>
        void _Emplace_front(_ArgsTy&&... _Args) {
            _Unique_lock _Lk(_Tzdb_mutex);
            _Tzdb_list.emplace_front(::std:: forward<_ArgsTy>(_Args)...);
        }

        const tzdb& _Reload() {
            _Unique_lock _Lk(_Tzdb_mutex);
            auto [_Leap_sec, _All_ls_positive] = _Tzdb_generate_leap_seconds(_Tzdb_list.front().leap_seconds.size());
            if (!_Leap_sec.empty()) {
                const auto& _Tzdb = _Tzdb_list.front();
                vector<time_zone> _Zones;
                ::std:: transform(_Tzdb.zones.begin(), _Tzdb.zones.end(), ::std:: back_inserter(_Zones),
                    [](const auto& _Tz) { return time_zone{_Tz.name()}; });
                vector<time_zone_link> _Links;
                ::std:: transform(
                    _Tzdb.links.begin(), _Tzdb.links.end(), ::std:: back_inserter(_Links), [](const auto& _Link) {
                        return time_zone_link{_Link.name(), _Link.target()};
                    });
                auto _Version = _Tzdb_update_version(_Tzdb.version, _Leap_sec.size());
                _Tzdb_list.emplace_front(tzdb{
                    ::std:: move(_Version), ::std:: move(_Zones), ::std:: move(_Links), ::std:: move(_Leap_sec), _All_ls_positive});
            }
            return _Tzdb_list.front();
        }

    private:
        _ListType _Tzdb_list;
        mutable _Smtx_t _Tzdb_mutex = {};

        struct [[nodiscard]] _Shared_lock {
            explicit _Shared_lock(_Smtx_t& _Mtx_) : _Mtx{&_Mtx_} {
                _Smtx_lock_shared(_Mtx);
            }

            _Shared_lock(const _Shared_lock&) = delete;
            _Shared_lock& operator=(const _Shared_lock&) = delete;

            ~_Shared_lock() {
                _Smtx_unlock_shared(_Mtx);
            }

            _Smtx_t* _Mtx;
        };

        struct [[nodiscard]] _Unique_lock {
            explicit _Unique_lock(_Smtx_t& _Mtx_) : _Mtx{&_Mtx_} {
                _Smtx_lock_exclusive(_Mtx);
            }

            _Unique_lock(const _Unique_lock&) = delete;
            _Unique_lock& operator=(const _Unique_lock&) = delete;

            ~_Unique_lock() {
                _Smtx_unlock_exclusive(_Mtx);
            }

            _Smtx_t* _Mtx;
        };
    };

    inline atomic<tzdb_list*> _Global_tzdb_list;

    [[nodiscard]] inline tzdb_list& get_tzdb_list() {
        auto* _Tzdb_ptr = _Global_tzdb_list.load();
        if (_Tzdb_ptr != nullptr) {
            return *_Tzdb_ptr;
        }

        auto _My_tzdb = static_cast<tzdb_list*>(__std_calloc_crt(1, sizeof(tzdb_list)));
        if (_My_tzdb == nullptr) {
            _Xruntime_error("bad allocation"); 
        }

        try {
        ::std:: construct_at(_My_tzdb);
        } catch (const runtime_error&) {
        __std_free_crt(_My_tzdb);
        throw;
        } catch (const exception& _Except) {

        __std_free_crt(_My_tzdb);
        _Xruntime_error(_Except.what());
#line 2875 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"
        }

        if (_Global_tzdb_list.compare_exchange_strong(_Tzdb_ptr, _My_tzdb)) {
            _Tzdb_ptr = _My_tzdb;
        } else {
            ::std:: destroy_at(_My_tzdb);
            __std_free_crt(_My_tzdb);
        }

        return *_Tzdb_ptr;
    }

    [[nodiscard]] inline const tzdb& get_tzdb() {
        return ::std::chrono:: get_tzdb_list().front();
    }

    [[nodiscard]] inline const time_zone* locate_zone(string_view _Tz_name) {
        return ::std::chrono:: get_tzdb().locate_zone(_Tz_name);
    }

    [[nodiscard]] inline const time_zone* current_zone() {
        return ::std::chrono:: get_tzdb().current_zone();
    }

    inline const tzdb& reload_tzdb() {
        try {
        return ::std::chrono:: get_tzdb_list()._Reload();
        } catch (const runtime_error&) {
        throw;
        } catch (const exception& _Except) {

        _Xruntime_error(_Except.what());
#line 2908 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"
        }
    }

    [[nodiscard]] inline string remote_version() {
        const auto& _Tzdb                = ::std::chrono:: get_tzdb();
        const auto& _Version             = _Tzdb.version;
        const auto [_Leap_sec, _Ignored] = _Tzdb_generate_leap_seconds(_Tzdb.leap_seconds.size());
        return _Leap_sec.empty() ? _Version : _Tzdb_update_version(_Version, _Leap_sec.size());
    }

    
    template <class _Ty>
    struct zoned_traits {};

    template <>
    struct zoned_traits<const time_zone*> {
        [[nodiscard]] static const time_zone* default_zone() {
            return ::std::chrono:: get_tzdb().locate_zone("UTC");
        }

        [[nodiscard]] static const time_zone* locate_zone(string_view _Name) {
            return ::std::chrono:: get_tzdb().locate_zone(_Name);
        }
    };

    
    template <class _Duration, class _TimeZonePtr = const time_zone*>
    class zoned_time {
    private:
        static_assert(_Is_duration_v<_Duration>,
            "N4885 [time.zone.zonedtime.overview]/2 mandates Duration to be a specialization of chrono::duration.");

        using _Traits = zoned_traits<_TimeZonePtr>;

    public:
        using duration = common_type_t<_Duration, seconds>;

        template <class _Traits2 = _Traits, class = void_t<decltype(_Traits2::default_zone())>>
        zoned_time() : _Zone{_Traits::default_zone()} {}
        zoned_time(const zoned_time&) = default;
        zoned_time& operator=(const zoned_time&) = default;

        template <class _Traits2 = _Traits, class = void_t<decltype(_Traits2::default_zone())>>
        zoned_time(const sys_time<_Duration>& _Sys) : _Zone{_Traits::default_zone()}, _Tp{_Sys} {}

        explicit zoned_time(_TimeZonePtr _Tz) noexcept  : _Zone{::std:: move(_Tz)} {}

        
        template <class _Traits2 = _Traits, enable_if_t<is_constructible_v<
            zoned_time, decltype(_Traits2::locate_zone(string_view{}))>,
            int> = 0>
        
        explicit zoned_time(string_view _Name) : _Zone{_Traits::locate_zone(_Name)} {}

        template <class _Duration2, enable_if_t<is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>, int> = 0>
        zoned_time(const zoned_time<_Duration2, _TimeZonePtr>& _Zt) noexcept 
            : _Zone{_Zt.get_time_zone()}, _Tp{_Zt.get_sys_time()} {}

        zoned_time(_TimeZonePtr _Tz, const sys_time<_Duration>& _Sys) : _Zone{::std:: move(_Tz)}, _Tp{_Sys} {}

        
        template <class _Traits2 = _Traits, enable_if_t<is_constructible_v<
            zoned_time, decltype(_Traits2::locate_zone(string_view{})), const sys_time<_Duration>&>,
            int> = 0>
        
        zoned_time(string_view _Name, type_identity_t<const sys_time<_Duration>&> _Sys)
            : zoned_time{_Traits::locate_zone(_Name), _Sys} {}

        template <class _Ptr = _TimeZonePtr,
            enable_if_t<
                is_convertible_v<decltype(::std:: declval<_Ptr&>()->to_sys(local_time<_Duration>{})), sys_time<duration>>,
                int> = 0>
        zoned_time(_TimeZonePtr _Tz, const local_time<_Duration>& _Local)
            : _Zone{::std:: move(_Tz)}, _Tp{_Zone->to_sys(_Local)} {}

        
        template <class _Traits2 = _Traits, enable_if_t<is_constructible_v<
            zoned_time, decltype(_Traits2::locate_zone(string_view{})), const local_time<_Duration>&>,
            int> = 0>
        
        zoned_time(string_view _Name, type_identity_t<const local_time<_Duration>>& _Local)
            : zoned_time{_Traits::locate_zone(_Name), _Local} {}

        template <class _Ptr = _TimeZonePtr,
            enable_if_t<
                is_convertible_v<decltype(::std:: declval<_Ptr&>()->to_sys(local_time<_Duration>{}, choose::earliest)),
                    sys_time<duration>>,
                int> = 0>
        zoned_time(_TimeZonePtr _Tz, const local_time<_Duration>& _Local, choose _Choose)
            : _Zone{::std:: move(_Tz)}, _Tp{_Zone->to_sys(_Local, _Choose)} {}

        
        template <class _Traits2 = _Traits, enable_if_t<is_constructible_v<
            zoned_time, decltype(_Traits2::locate_zone(string_view{})), const local_time<_Duration>&, choose>,
            int> = 0>
        
        zoned_time(string_view _Name, type_identity_t<const local_time<_Duration>&> _Local, choose _Choose)
            : zoned_time{_Traits::locate_zone(_Name), _Local, _Choose} {}

        template <class _Duration2, class _TimeZonePtr2,
            enable_if_t<is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>, int> = 0>
        zoned_time(_TimeZonePtr _Tz, const zoned_time<_Duration2, _TimeZonePtr2>& _Zt) noexcept 
            : _Zone{::std:: move(_Tz)}, _Tp{_Zt.get_sys_time()} {}

        template <class _Duration2, class _TimeZonePtr2,
            enable_if_t<is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>, int> = 0>
        zoned_time(
            _TimeZonePtr _Tz, const zoned_time<_Duration2, _TimeZonePtr2>& _Zt, choose) noexcept 
            : zoned_time{_Tz, _Zt} {}

        
        template <class _Duration2, class _TimeZonePtr2,
            class _Traits2 = _Traits, enable_if_t<is_constructible_v<
            zoned_time, decltype(_Traits2::locate_zone(string_view{})),
            const zoned_time<_Duration2, _TimeZonePtr2>&>,
            int> = 0>
        
        zoned_time(string_view _Name, const zoned_time<_Duration2, _TimeZonePtr2>& _Zt)
            : zoned_time{_Traits::locate_zone(_Name), _Zt} {}

        
        template <class _Duration2, class _TimeZonePtr2,
            class _Traits2 = _Traits, enable_if_t<is_constructible_v<
            zoned_time, decltype(_Traits2::locate_zone(string_view{})),
            const zoned_time<_Duration2, _TimeZonePtr2>&, choose>,
            int> = 0>
        
        zoned_time(string_view _Name, const zoned_time<_Duration2, _TimeZonePtr2>& _Zt, choose _Choose)
            : zoned_time{_Traits::locate_zone(_Name), _Zt, _Choose} {}

        zoned_time& operator=(const sys_time<_Duration>& _Sys) noexcept  {
            _Tp = _Sys;
            return *this;
        }

        zoned_time& operator=(const local_time<_Duration>& _Local) {
            _Tp = _Zone->to_sys(_Local);
            return *this;
        }

        operator sys_time<duration>() const noexcept  {
            return get_sys_time();
        }

        explicit operator local_time<duration>() const {
            return get_local_time();
        }

        [[nodiscard]] _TimeZonePtr get_time_zone() const noexcept  {
            return _Zone;
        }

        [[nodiscard]] local_time<duration> get_local_time() const {
            return _Zone->to_local(_Tp);
        }

        [[nodiscard]] sys_time<duration> get_sys_time() const noexcept  {
            return _Tp;
        }

        [[nodiscard]] sys_info get_info() const {
            return _Zone->get_info(_Tp);
        }

    private:
        _TimeZonePtr _Zone;
        sys_time<duration> _Tp{};
    };

    zoned_time()->zoned_time<seconds>;

    template <class _Duration>
    zoned_time(sys_time<_Duration>) -> zoned_time<common_type_t<_Duration, seconds>>;

    template <class _TimeZonePtrOrName>
    using _Time_zone_representation = conditional_t<is_convertible_v<_TimeZonePtrOrName, string_view>, const time_zone*,
        remove_cvref_t<_TimeZonePtrOrName>>;

    template <class _TimeZonePtrOrName>
    zoned_time(_TimeZonePtrOrName&&) -> zoned_time<seconds, _Time_zone_representation<_TimeZonePtrOrName>>;

    template <class _TimeZonePtrOrName, class _Duration>
    zoned_time(_TimeZonePtrOrName&&, sys_time<_Duration>)
        -> zoned_time<common_type_t<_Duration, seconds>, _Time_zone_representation<_TimeZonePtrOrName>>;

    template <class _TimeZonePtrOrName, class _Duration>
    zoned_time(_TimeZonePtrOrName&&, local_time<_Duration>, choose = choose::earliest)
        -> zoned_time<common_type_t<_Duration, seconds>, _Time_zone_representation<_TimeZonePtrOrName>>;

    template <class _Duration, class _TimeZonePtrOrName, class _TimeZonePtr2>
    zoned_time(_TimeZonePtrOrName&&, zoned_time<_Duration, _TimeZonePtr2>, choose = choose::earliest)
        -> zoned_time<common_type_t<_Duration, seconds>, _Time_zone_representation<_TimeZonePtrOrName>>;

    using zoned_seconds = zoned_time<seconds>;

    template <class _Duration1, class _Duration2, class _TimeZonePtr>
    [[nodiscard]] bool operator==(
        const zoned_time<_Duration1, _TimeZonePtr>& _Left, const zoned_time<_Duration2, _TimeZonePtr>& _Right) {
        return _Left.get_time_zone() == _Right.get_time_zone() && _Left.get_sys_time() == _Right.get_sys_time();
    }

    
    class utc_clock;
    template <class _Duration>
    using utc_time    = time_point<utc_clock, _Duration>;
    using utc_seconds = utc_time<seconds>;

    struct leap_second_info {
        bool is_leap_second;
        seconds elapsed;
    };

    template <class _Duration>
    [[nodiscard]] leap_second_info get_leap_second_info(const utc_time<_Duration>& _Time) {
        const utc_seconds _Time_floor = ::std::chrono:: floor<seconds>(_Time);
        const auto& _Tzdb             = ::std::chrono:: get_tzdb();
        const auto& _Ls_vector        = _Tzdb.leap_seconds;

        
        vector<leap_second>::const_iterator _It;
        if (_Tzdb._All_ls_positive) {
            
            
            _It = ::std:: upper_bound(_Ls_vector.begin(), _Ls_vector.end(), sys_seconds{_Time_floor.time_since_epoch()});
        } else {
            seconds _Prev_elapsed{0};
            for (_It = _Ls_vector.begin(); _It != _Ls_vector.end(); ++_It) {
                
                
                const utc_seconds _This_ls_begin{
                    _It->date().time_since_epoch() + (_It->_Positive() ? _Prev_elapsed : _It->_Elapsed())};
                if (_This_ls_begin > _Time_floor) {
                    break;
                }
                _Prev_elapsed = _It->_Elapsed();
            }
        }

        if (_It == _Ls_vector.begin()) {
            return {false, seconds{0}};
        } else {
            
            const auto& _Last_leap = *--_It;
            const utc_seconds _Utc_leap_second{_Last_leap.date().time_since_epoch() + _It->_Elapsed() - seconds{1}};

            const auto _Leap_cmp = _Utc_leap_second <=> _Time_floor;


#line 3189 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"
            if (_Tzdb._All_ls_positive && ::std:: is_gt(_Leap_cmp)) { 
                --_It;
            }
            return {_Last_leap._Positive() && ::std:: is_eq(_Leap_cmp), _It->_Elapsed()};
        }
    }

    class utc_clock {
    public:
        using rep                       = system_clock::rep;
        using period                    = system_clock::period;
        using duration                  = ::std::chrono:: duration<rep, period>;
        using time_point                = ::std::chrono:: time_point<utc_clock>;
        static constexpr bool is_steady = system_clock::is_steady;

        [[nodiscard]] static time_point now() {
            return from_sys(system_clock::now());
        }

        template <class _Duration>
        [[nodiscard]] static sys_time<common_type_t<_Duration, seconds>> to_sys(const utc_time<_Duration>& _Utc_time) {
            using _CommonType = common_type_t<_Duration, seconds>;
            const auto _Lsi{::std::chrono:: get_leap_second_info(_Utc_time)};
            _CommonType _Ticks;
            if (_Lsi.is_leap_second) {
                const auto _Leap_sec_minus_one = ::std::chrono:: floor<seconds>(_Utc_time.time_since_epoch()) - _Lsi.elapsed;
                if constexpr (is_integral_v<typename _Duration::rep>) {
                    constexpr auto _Delta{seconds{1} - _CommonType{1}};
                    _Ticks = _Leap_sec_minus_one + _Delta;
                } else {
                    const auto _Leap_sec_begin = ::std::chrono:: ceil<_CommonType>(_Leap_sec_minus_one + seconds{1});
                    _Ticks = _CommonType{::std:: nextafter(_Leap_sec_begin.count(), typename _CommonType::rep{0})};
                }
            } else {
                _Ticks = _Utc_time.time_since_epoch() - _Lsi.elapsed;
            }
            return sys_time<_CommonType>{_Ticks};
        }

        template <class _Duration>
        [[nodiscard]] static utc_time<common_type_t<_Duration, seconds>> from_sys(const sys_time<_Duration>& _Sys_time) {
            const auto& _Tzdb      = ::std::chrono:: get_tzdb();
            const auto& _Ls_vector = _Tzdb.leap_seconds;
            auto _It = ::std:: upper_bound(_Ls_vector.begin(), _Ls_vector.end(), ::std::chrono:: floor<seconds>(_Sys_time));
            const auto _Offset = _It == _Ls_vector.begin() ? seconds{0} : (--_It)->_Elapsed();
            return utc_time<common_type_t<_Duration, seconds>>{_Sys_time.time_since_epoch() + _Offset};
        }
    };

    
    class tai_clock;

    template <class _Duration>
    using tai_time    = time_point<tai_clock, _Duration>;
    using tai_seconds = tai_time<seconds>;

    class tai_clock {
    public:
        using rep                       = system_clock::rep;
        using period                    = system_clock::period;
        using duration                  = ::std::chrono:: duration<rep, period>;
        using time_point                = ::std::chrono:: time_point<tai_clock>;
        static constexpr bool is_steady = system_clock::is_steady;

        static constexpr seconds _Tai_epoch_adjust{378691210};

        [[nodiscard]] static time_point now() {
            return from_utc(utc_clock::now());
        }

        template <class _Duration>
        [[nodiscard]] static utc_time<common_type_t<_Duration, seconds>> to_utc(
            const tai_time<_Duration>& _Time) noexcept {
            return utc_time<common_type_t<_Duration, seconds>>{_Time.time_since_epoch()} - _Tai_epoch_adjust;
        }

        template <class _Duration>
        [[nodiscard]] static tai_time<common_type_t<_Duration, seconds>> from_utc(
            const utc_time<_Duration>& _Time) noexcept {
            return tai_time<common_type_t<_Duration, seconds>>{_Time.time_since_epoch()} + _Tai_epoch_adjust;
        }
    };

    
    class gps_clock;

    template <class _Duration>
    using gps_time    = time_point<gps_clock, _Duration>;
    using gps_seconds = gps_time<seconds>;

    class gps_clock {
    public:
        using rep                       = system_clock::rep;
        using period                    = system_clock::period;
        using duration                  = ::std::chrono:: duration<rep, period>;
        using time_point                = ::std::chrono:: time_point<gps_clock>;
        static constexpr bool is_steady = system_clock::is_steady;

        static constexpr seconds _Gps_epoch_adjust{-315964809};

        [[nodiscard]] static time_point now() {
            return from_utc(utc_clock::now());
        }

        template <class _Duration>
        [[nodiscard]] static utc_time<common_type_t<_Duration, seconds>> to_utc(
            const gps_time<_Duration>& _Time) noexcept {
            return utc_time<common_type_t<_Duration, seconds>>{_Time.time_since_epoch()} - _Gps_epoch_adjust;
        }

        template <class _Duration>
        [[nodiscard]] static gps_time<common_type_t<_Duration, seconds>> from_utc(
            const utc_time<_Duration>& _Time) noexcept {
            return gps_time<common_type_t<_Duration, seconds>>{_Time.time_since_epoch()} + _Gps_epoch_adjust;
        }
    };
#line 3308 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"
} 


namespace filesystem {
    struct _File_time_clock;
} 

namespace chrono {
    using file_clock = filesystem::_File_time_clock;

    template <class _Duration>
    using file_time = time_point<file_clock, _Duration>;
} 
#line 3324 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"


namespace filesystem {
    inline constexpr long long __std_fs_file_time_epoch_adjustment = 0x19DB1DED53E8000LL; 

    struct _File_time_clock { 
        using rep                       = long long;
        using period                    = chrono::system_clock::period;
        using duration                  = chrono::duration<rep, period>;
        using time_point                = chrono::time_point<_File_time_clock>;
        static constexpr bool is_steady = false;

        [[nodiscard]] static time_point now() noexcept { 
            return time_point(duration(_Xtime_get_ticks() + __std_fs_file_time_epoch_adjustment)); 
        }


        static constexpr chrono::seconds _Skipped_filetime_leap_seconds{27};
        static constexpr chrono::sys_days _Cutoff{
            chrono::year_month_day{chrono::year{2017}, chrono::January, chrono::day{1}}};

        template <class _Duration>
        [[nodiscard]] static chrono::utc_time<common_type_t<_Duration, chrono::seconds>> to_utc(
            const chrono::file_time<_Duration>& _File_time) {
            using namespace chrono;
            using _CommonType = common_type_t<_Duration, seconds>;
            const auto _Ticks = _File_time.time_since_epoch()
                              - ::std::chrono:: duration_cast<seconds>(duration{__std_fs_file_time_epoch_adjustment});

            if (_Ticks < _Cutoff.time_since_epoch()) {
                return utc_clock::from_sys(sys_time<_CommonType>{_Ticks});
            } else {
                return utc_time<_CommonType>{_Ticks + _Skipped_filetime_leap_seconds};
            }
        }

        template <class _Duration>
        [[nodiscard]] static chrono::file_time<common_type_t<_Duration, chrono::seconds>> from_utc(
            const chrono::utc_time<_Duration>& _Utc_time) {
            using namespace chrono;
            file_time<common_type_t<_Duration, seconds>> _File_time{
                ::std::chrono:: duration_cast<seconds>(duration{__std_fs_file_time_epoch_adjustment})};

            if (_Utc_time < utc_seconds{_Cutoff.time_since_epoch()} + _Skipped_filetime_leap_seconds) {
                _File_time += utc_clock::to_sys(_Utc_time).time_since_epoch();
            } else {
                _File_time += _Utc_time.time_since_epoch() - _Skipped_filetime_leap_seconds;
            }

            return _File_time;
        }
#line 3378 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"
    };
} 
#line 3381 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"

namespace chrono {

    
    template <class _DestClock, class _SourceClock>
    struct clock_time_conversion {};

    
    template <class _Clock>
    struct clock_time_conversion<_Clock, _Clock> {
        template <class _Duration>
        [[nodiscard]] time_point<_Clock, _Duration> operator()(const time_point<_Clock, _Duration>& _Time) const
            noexcept(is_arithmetic_v<typename _Duration::rep>)  {
            return _Time;
        }
    };

    template <>
    struct clock_time_conversion<system_clock, system_clock> {
        template <class _Duration>
        [[nodiscard]] sys_time<_Duration> operator()(const sys_time<_Duration>& _Time) const
            noexcept(is_arithmetic_v<typename _Duration::rep>)  {
            return _Time;
        }
    };

    template <>
    struct clock_time_conversion<utc_clock, utc_clock> {
        template <class _Duration>
        [[nodiscard]] utc_time<_Duration> operator()(const utc_time<_Duration>& _Time) const
            noexcept(is_arithmetic_v<typename _Duration::rep>)  {
            return _Time;
        }
    };

    
    template <>
    struct clock_time_conversion<utc_clock, system_clock> {
        template <class _Duration>
        [[nodiscard]] utc_time<common_type_t<_Duration, seconds>> operator()(const sys_time<_Duration>& _Sys_time) const {
            return utc_clock::from_sys(_Sys_time);
        }
    };

    template <>
    struct clock_time_conversion<system_clock, utc_clock> {
        template <class _Duration>
        [[nodiscard]] sys_time<common_type_t<_Duration, seconds>> operator()(const utc_time<_Duration>& _Utc_time) const {
            return utc_clock::to_sys(_Utc_time);
        }
    };

    
    template <class _TimePoint, class _Clock>
    inline constexpr bool _Is_time_point_for_clock = false;

    template <class _Clock, class _Duration>
    inline constexpr bool _Is_time_point_for_clock<time_point<_Clock, _Duration>, _Clock> = true;

    template <class _SourceClock>
    struct clock_time_conversion<system_clock, _SourceClock> {
        template <class _Duration, class _SourceClock2 = _SourceClock,
            class =
                void_t<decltype(_SourceClock2::to_sys(::std:: declval<const time_point<_SourceClock2, _Duration>&>()))>>
        [[nodiscard]] auto operator()(const time_point<_SourceClock, _Duration>& _Time) const
            noexcept(noexcept(_SourceClock::to_sys(_Time)))  {
            static_assert(_Is_time_point_for_clock<decltype(_SourceClock::to_sys(_Time)), system_clock>,
                "N4885 [time.clock.cast.sys]/2: Mandates: SourceClock::to_sys(t) returns a sys_time<Duration>");
            return _SourceClock::to_sys(_Time);
        }
    };

    template <class _DestClock>
    struct clock_time_conversion<_DestClock, system_clock> {
        template <class _Duration, class _DestClock2 = _DestClock,
            class = void_t<decltype(_DestClock2::from_sys(::std:: declval<const sys_time<_Duration>&>()))>>
        [[nodiscard]] auto operator()(const sys_time<_Duration>& _Time) const
            noexcept(noexcept(_DestClock::from_sys(_Time)))  {
            static_assert(_Is_time_point_for_clock<decltype(_DestClock::from_sys(_Time)), _DestClock>,
                "N4885 [time.clock.cast.sys]/5: Mandates: DestClock::from_sys(t) returns a "
                "time_point<DestClock, Duration>");
            return _DestClock::from_sys(_Time);
        }
    };

    
    template <class _SourceClock>
    struct clock_time_conversion<utc_clock, _SourceClock> {
        template <class _Duration, class _SourceClock2 = _SourceClock,
            class =
                void_t<decltype(_SourceClock2::to_utc(::std:: declval<const time_point<_SourceClock2, _Duration>&>()))>>
        [[nodiscard]] auto operator()(const time_point<_SourceClock, _Duration>& _Time) const
            noexcept(noexcept(_SourceClock::to_utc(_Time)))  {
            static_assert(_Is_time_point_for_clock<decltype(_SourceClock::to_utc(_Time)), utc_clock>,
                "N4885 [time.clock.cast.utc]/2: Mandates: SourceClock::to_utc(t) returns a utc_time<Duration>");
            return _SourceClock::to_utc(_Time);
        }
    };

    template <class _DestClock>
    struct clock_time_conversion<_DestClock, utc_clock> {
        template <class _Duration, class _DestClock2 = _DestClock,
            class = void_t<decltype(_DestClock2::from_utc(::std:: declval<const utc_time<_Duration>&>()))>>
        [[nodiscard]] auto operator()(const utc_time<_Duration>& _Time) const
            noexcept(noexcept(_DestClock::from_utc(_Time)))  {
            static_assert(_Is_time_point_for_clock<decltype(_DestClock::from_utc(_Time)), _DestClock>,
                "N4885 [time.clock.cast.utc]/5: Mandates: DestClock::from_utc(t) returns a "
                "time_point<DestClock, Duration>");
            return _DestClock::from_utc(_Time);
        }
    };

    
    enum class _Clock_cast_strategy {
        _Direct,
        _Via_sys,
        _Via_utc,
        _Via_utc_from_sys,
        _Via_sys_from_utc,
        _Two_step_ambiguous,
        _Three_step_ambiguous,
        _None,
    };

    template <class _Conv1, class _Conv2, class _Tp, class = void>
    inline constexpr bool _Has_two_step_conversion = false;

    template <class _Conv1, class _Conv2, class _Tp>
    inline constexpr bool
        _Has_two_step_conversion<_Conv1, _Conv2, _Tp, void_t<decltype(_Conv1{}(_Conv2{}(::std:: declval<_Tp>())))>> = true;

    template <class _Conv1, class _Conv2, class _Conv3, class _Tp, class = void>
    inline constexpr bool _Has_three_step_conversion = false;

    template <class _Conv1, class _Conv2, class _Conv3, class _Tp>
    inline constexpr bool _Has_three_step_conversion<_Conv1, _Conv2, _Conv3, _Tp,
        void_t<decltype(_Conv1{}(_Conv2{}(_Conv3{}(::std:: declval<_Tp>()))))>> = true;

    template <class _DestClock, class _SourceClock, class _Duration>
    [[nodiscard]] consteval _Clock_cast_strategy _Choose_clock_cast() noexcept {
        using _Tp = const time_point<_SourceClock, _Duration>&;

        if constexpr (is_invocable_v<clock_time_conversion<_DestClock, _SourceClock>, _Tp>) {
            return _Clock_cast_strategy::_Direct;
        } else {
            constexpr bool _Has_sys = _Has_two_step_conversion< 
                clock_time_conversion<_DestClock, system_clock>, 
                clock_time_conversion<system_clock, _SourceClock>, _Tp>;

            constexpr bool _Has_utc = _Has_two_step_conversion< 
                clock_time_conversion<_DestClock, utc_clock>, 
                clock_time_conversion<utc_clock, _SourceClock>, _Tp>;

            if constexpr (_Has_sys && _Has_utc) {
                return _Clock_cast_strategy::_Two_step_ambiguous;
            } else if constexpr (_Has_sys) {
                return _Clock_cast_strategy::_Via_sys;
            } else if constexpr (_Has_utc) {
                return _Clock_cast_strategy::_Via_utc;
            } else {
                constexpr bool _Has_utc_from_sys = _Has_three_step_conversion< 
                    clock_time_conversion<_DestClock, utc_clock>, 
                    clock_time_conversion<utc_clock, system_clock>, 
                    clock_time_conversion<system_clock, _SourceClock>, _Tp>;

                constexpr bool _Has_sys_from_utc = _Has_three_step_conversion< 
                    clock_time_conversion<_DestClock, system_clock>, 
                    clock_time_conversion<system_clock, utc_clock>, 
                    clock_time_conversion<utc_clock, _SourceClock>, _Tp>;

                if constexpr (_Has_utc_from_sys && _Has_sys_from_utc) {
                    return _Clock_cast_strategy::_Three_step_ambiguous;
                } else if constexpr (_Has_utc_from_sys) {
                    return _Clock_cast_strategy::_Via_utc_from_sys;
                } else if constexpr (_Has_sys_from_utc) {
                    return _Clock_cast_strategy::_Via_sys_from_utc;
                } else {
                    return _Clock_cast_strategy::_None;
                }
            }
        }
    }

    template <class _DestClock, class _SourceClock, class _Duration>
    inline constexpr auto _Clock_cast_choice = _Choose_clock_cast<_DestClock, _SourceClock, _Duration>();

    template <class _DestClock, class _SourceClock, class _Duration,
        enable_if_t<_Clock_cast_choice<_DestClock, _SourceClock, _Duration> != _Clock_cast_strategy::_None, int> = 0>
    [[nodiscard]] auto clock_cast(const time_point<_SourceClock, _Duration>& _Time) {
        constexpr auto _Strat = _Clock_cast_choice<_DestClock, _SourceClock, _Duration>;

        if constexpr (_Strat == _Clock_cast_strategy::_Direct) {
            return clock_time_conversion<_DestClock, _SourceClock>{}(_Time);
        } else if constexpr (_Strat == _Clock_cast_strategy::_Via_sys) {
            return clock_time_conversion<_DestClock, system_clock>{}(
                clock_time_conversion<system_clock, _SourceClock>{}(_Time));
        } else if constexpr (_Strat == _Clock_cast_strategy::_Via_utc) {
            return clock_time_conversion<_DestClock, utc_clock>{}(
                clock_time_conversion<utc_clock, _SourceClock>{}(_Time));
        } else if constexpr (_Strat == _Clock_cast_strategy::_Via_utc_from_sys) {
            return clock_time_conversion<_DestClock, utc_clock>{}( 
                clock_time_conversion<utc_clock, system_clock>{}(
                    clock_time_conversion<system_clock, _SourceClock>{}(_Time)));
        } else if constexpr (_Strat == _Clock_cast_strategy::_Via_sys_from_utc) {
            return clock_time_conversion<_DestClock, system_clock>{}( 
                clock_time_conversion<system_clock, utc_clock>{}(
                    clock_time_conversion<utc_clock, _SourceClock>{}(_Time)));
        } else if constexpr (_Strat == _Clock_cast_strategy::_Two_step_ambiguous) {
            static_assert(_Always_false<_Duration>,
                "A two-step clock time conversion is required to be unique, "
                "either through utc_clock or system_clock, but not both (N4878 [time.clock.cast.fn]/2).");
        } else if constexpr (_Strat == _Clock_cast_strategy::_Three_step_ambiguous) {
            static_assert(_Always_false<_Duration>,
                "A three-step clock time conversion is required to be unique, "
                "either utc-to-system or system-to-utc, but not both (N4878 [time.clock.cast.fn]/2).");
        } else {
            static_assert(_Always_false<_Duration>, "should be unreachable");
        }
    }

    
    struct _Time_parse_fields {
        using _SubsecondType = duration<int64_t, atto>;

        
        optional<int64_t> _Subsecond;
        optional<int> _Second;
        optional<int> _Minute;
        optional<int> _Hour_24;
        optional<int> _Weekday; 
        optional<int> _Day; 
        optional<int> _Month; 
        optional<int> _Day_of_year; 
        optional<int> _Two_dig_year;
        optional<int> _Century;
        optional<int> _Utc_offset; 
        optional<string> _Tz_name;

        
        optional<int> _Hour_12;
        optional<int> _Ampm;
        optional<int> _Iso_year;
        optional<int> _Two_dig_iso_year;
        optional<int> _Iso_week; 
        optional<int> _Week_u; 
        optional<int> _Week_w; 

        enum _FieldFlags : unsigned int {
            _F_sec   = 0x01,
            _F_min   = 0x02,
            _F_hr    = 0x04,
            _F_day   = 0x08,
            _F_wkday = 0x10,
            _F_mon   = 0x20,
            _F_doy   = 0x40,
            _F_year  = 0x80,
        };

        [[nodiscard]] unsigned int _Used_fields() const {
            unsigned int _Ret{0};
            if (_Second || _Subsecond) {
                _Ret |= _F_sec;
            }
            if (_Minute) {
                _Ret |= _F_min;
            }
            if (_Hour_24) {
                _Ret |= _F_hr;
            }
            if (_Day) {
                _Ret |= _F_day;
            }
            if (_Weekday) {
                _Ret |= _F_wkday;
            }
            if (_Month) {
                _Ret |= _F_mon;
            }
            if (_Day_of_year) {
                _Ret |= _F_doy;
            }
            if (_Two_dig_year && _Century) {
                _Ret |= _F_year;
            }
            return _Ret;
        }

        [[nodiscard]] static bool _Test_bits(
            const unsigned int _Bits, const unsigned int _Must_set, const unsigned int _Optional = 0) {
            return (_Bits & ~_Optional) == _Must_set;
        }


        template <class _Ty>
        static constexpr _Ty _Invalid_time_field{numeric_limits<_Ty>::lowest()};

        static void _Initialize_time_point(tm& _Tp) {
            _Tp.tm_sec  = _Invalid_time_field<int>;
            _Tp.tm_min  = _Invalid_time_field<int>;
            _Tp.tm_hour = _Invalid_time_field<int>;
            _Tp.tm_wday = _Invalid_time_field<int>;
            _Tp.tm_mday = _Invalid_time_field<int>;
            _Tp.tm_mon  = _Invalid_time_field<int>;
            _Tp.tm_yday = _Invalid_time_field<int>;
            _Tp.tm_year = _Invalid_time_field<int>;
        }

        template <class _Ty>
        [[nodiscard]] static bool _Update(optional<_Ty>& _Val, const _Ty& _New) {
            
            
            if constexpr (!is_same_v<_Ty, string>) {
                if (_New == _Invalid_time_field<_Ty>) {
                    return true;
                }
            }

            if (!_Val.has_value()) {
                _Val = _New;
                return true;
            } else {
                return ::std:: exchange(_Val, _New) == _New;
            }
        }

        [[nodiscard]] static pair<int, int> _Decompose_year(const int _Year) {
            int _Two_d_year = _Year % 100;
            if (_Two_d_year < 0) {
                _Two_d_year += 100;
            }
            return {_Year - _Two_d_year, _Two_d_year};
        }

        [[nodiscard]] bool _Update_if_valid(const tm& _Tp, const bool _Full_year) {
            bool _No_err{true};
            if (_Tp.tm_hour != _Invalid_time_field<int>) {
                _No_err = _No_err && _Update(_Hour_24, _Tp.tm_hour);
                _No_err = _No_err && _Update(_Ampm, _Hour_24 >= 12 ? 1 : 0);
                _No_err = _No_err && _Update(_Hour_12, ::std::chrono:: make12(hours{*_Hour_24}).count());
            }

            _No_err = _No_err && _Update(_Minute, _Tp.tm_min);
            _No_err = _No_err && _Update(_Second, _Tp.tm_sec);
            _No_err = _No_err && _Update(_Day, _Tp.tm_mday);
            _No_err = _No_err && _Update(_Weekday, _Tp.tm_wday);

            if (_Tp.tm_mon != _Invalid_time_field<int>) {
                _No_err = _No_err && _Update(_Month, _Tp.tm_mon + 1);
            }

            if (_Tp.tm_yday != _Invalid_time_field<int>) {
                _No_err = _No_err && _Update(_Day_of_year, _Tp.tm_yday + 1);
            }

            if (_Tp.tm_year != _Invalid_time_field<int>) {
                
                const auto _Year_parts = _Decompose_year(_Tp.tm_year + 1900);
                _No_err                = _No_err && _Update(_Two_dig_year, _Year_parts.second);
                if (_Full_year) {
                    _No_err = _No_err && _Update(_Century, _Year_parts.first);
                }
            }

            return _No_err;
        }

        [[nodiscard]] bool _Yday_to_month_day(const int _Yday, const int _Year) {
            
            
            if (_Out_of_range(_Day_of_year, 1, _Two_dig_year || _Iso_year ? _Days_in_year(_Year) : 59)) {
                return false;
            }

            if (_Day_of_year <= 31) {
                return _Update(_Day, _Yday) && _Update(_Month, 1);
            }

            const int _Feb_end{_Is_leap(_Year) ? 60 : 59};
            if (_Day_of_year <= _Feb_end) {
                return _Update(_Day, _Yday - 31) && _Update(_Month, 2);
            }

            
            const int _Shifted_yday{*_Day_of_year - _Feb_end};
            return _Update(_Month, (535 * _Shifted_yday + 48950) >> 14)
                && _Update(_Day, _Shifted_yday - ((979 * *_Month - 2918) >> 5));
        }

        static constexpr int _Era_begin_wday{3}; 

        [[nodiscard]] static constexpr int _Jan1_weekday(int _Year) {
            --_Year;
            const int _Era = (_Year >= 0 ? _Year : _Year - 399) / 400;
            const int _Yoe = _Year - _Era * 400;
            
            const int _Doe = ((1461 * _Yoe) >> 2) - _Yoe / 100 + 306;
            return (_Doe + _Era_begin_wday) % 7;
        }

        [[nodiscard]] static constexpr int _Iso8601_weeks(int _Year) {
            const int _P_y = (_Year + _Year / 4 - _Year / 100 + _Year / 400) % 7;
            --_Year;
            const int _P_ym1 = (_Year + _Year / 4 - _Year / 100 + _Year / 400) % 7;
            return 52 + (_P_y == 4 || _P_ym1 == 3);
        }

        [[nodiscard]] static constexpr int _Iso8601_week(const int _Day_of_year, const int _Weekday, const int _Year) {
            
            const auto _Week{(_Day_of_year + 9 - _Prev_weekday(_Weekday, 1)) / 7};
            if (_Week < 1) {
                return _Iso8601_weeks(_Year - 1);
            } else if (_Week > _Iso8601_weeks(_Year)) {
                return 1;
            } else {
                return _Week;
            }
        }

        [[nodiscard]] static constexpr bool _Is_leap(const int _Year) {
            return _Year % 4 == 0 && (_Year % 100 != 0 || _Year % 400 == 0);
        }

        [[nodiscard]] static constexpr int _Days_in_year(const int _Year) {
            return _Is_leap(_Year) ? 366 : 365;
        }

        [[nodiscard]] static constexpr int _Next_weekday(const int _Wday, const int _Shift) {
            
            int _Result = _Wday + _Shift;
            if (_Result >= 7) {
                _Result -= 7;
            }
            return _Result;
        }

        [[nodiscard]] static constexpr int _Prev_weekday(const int _Wday, const int _Shift) {
            
            return (_Wday >= _Shift ? 0 : 7) + (_Wday - _Shift);
        }

        [[nodiscard]] bool _Calculate_ymd_from_week_date(const int _Starting_wday, const int _Week, const int _Year) {
            
            
            const int _Jan1_wday = _Jan1_weekday(_Year);
            const int _Yday      = 1 + _Prev_weekday(_Starting_wday, _Jan1_wday) 
                            + _Prev_weekday(*_Weekday, _Starting_wday) 
                            + 7 * (_Week - 1); 
            return _Update(_Day_of_year, _Yday) && !_Out_of_range(_Day_of_year, 1, _Days_in_year(_Year))
                && _Yday_to_month_day(*_Day_of_year, _Year);
        }

        [[nodiscard]] bool _Calculate_ymd() {
            bool _No_err = true;
            
            
            bool _Check_u    = true;
            bool _Check_w    = true;
            bool _Check_iso  = true;
            bool _Check_wday = true;

            if (_Day_of_year && _Out_of_range(_Day_of_year, 1, 366)) {
                return false;
            }

            bool _Have_year = false;
            int _Year{0};
            if (_Two_dig_year) {
                _Year      = *_Century + *_Two_dig_year;
                _Have_year = true;
                if (_Day_of_year) {
                    _No_err = _No_err && _Yday_to_month_day(*_Day_of_year, _Year);
                } else if (_Week_u || _Week_w) {
                    _Check_wday = false;
                    if (_Week_u) {
                        _Check_u = false;
                        _No_err  = _No_err && _Calculate_ymd_from_week_date(0 , *_Week_u, _Year);
                    }

                    if (_Week_w) {
                        _Check_w = false;
                        _No_err  = _No_err && _Calculate_ymd_from_week_date(1 , *_Week_w, _Year);
                    }
                }
            }

            if (_Iso_year) {
                
                
                _Check_wday = false;
                _Check_iso  = false;
                _Year       = *_Iso_year;
                _Have_year  = true;

                
                const int _Jan4_wday        = _Next_weekday(_Jan1_weekday(_Year), 3 - 1);
                const int _Offset_from_jan4 = _Prev_weekday(*_Weekday, 1) - _Jan4_wday;
                int _Trial_yday             = 4 + 7 * (*_Iso_week - 1) + _Offset_from_jan4;
                const int _Ref_num_days     = _Trial_yday < 1 ? _Days_in_year(_Year - 1) : _Days_in_year(_Year);
                if (_Trial_yday < 1) {
                    _Trial_yday += _Ref_num_days;
                    --_Year;
                } else if (_Trial_yday > _Ref_num_days) {
                    _Trial_yday -= _Ref_num_days;
                    ++_Year;
                }

                const auto _Year_parts = _Decompose_year(_Year);
                _No_err = _No_err && _Update(_Day_of_year, _Trial_yday) && _Yday_to_month_day(*_Day_of_year, _Year)
                       && _Update(_Century, _Year_parts.first) && _Update(_Two_dig_year, _Year_parts.second);
            }

            
            if (!_Have_year || !_Month || !_Day || !_No_err) {
                return false;
            }

            
            if (_Check_wday && _Weekday) {
                const auto _Era_year = _Year - (*_Month <= 2);
                const int _Era       = (_Era_year >= 0 ? _Era_year : _Era_year - 399) / 400;
                const int _Yoe       = _Era_year - _Era * 400;
                const int _Yday_era  = ((979 * (*_Month + (*_Month > 2 ? -3 : 9)) + 19) >> 5) + *_Day - 1;
                const int _Doe       = ((1461 * _Yoe) >> 2) - _Yoe / 100 + _Yday_era;
                _No_err              = _No_err && _Update(_Weekday, (_Doe + _Era_begin_wday) % 7);
            }

            if (_Check_u && _Week_u) {
                _No_err = _No_err && _Update(_Week_u, (*_Day_of_year + 6 - *_Weekday) / 7);
            }

            if (_Check_w && _Week_w) {
                _No_err = _No_err && _Update(_Week_w, (*_Day_of_year + 6 - _Prev_weekday(*_Weekday, 1)) / 7);
            }

            if (_Check_iso && _Iso_week) {
                _No_err = _No_err && _Update(_Iso_week, _Iso8601_week(*_Day_of_year, *_Weekday, _Year));
            }

            return _No_err;
        }

        [[nodiscard]] bool _Calculate_hour24() {
            if (_Hour_12) {
                return _Update(
                    _Hour_24, ::std::chrono:: make24(hours{*_Hour_12}, static_cast<bool>(_Ampm.value_or(0))).count());
            } else {
                return true;
            }
        }

        [[nodiscard]] bool _Calculate_year_fields() {
            bool _No_err = true;
            
            
            if (_Two_dig_year && !_Century) {
                _No_err = _No_err && _Update(_Century, _Two_dig_year >= 69 ? 1900 : 2000);
            }

            
            if (_Two_dig_iso_year && _Century && !_Iso_year) {
                _No_err = _No_err && _Update(_Iso_year, *_Century + *_Two_dig_iso_year);
            }

            return _No_err;
        }

        [[nodiscard]] static bool _Out_of_range(const optional<int>& _Field, const int _Min, const int _Max) {
            return _Field && (_Field < _Min || _Max < _Field);
        }

        [[nodiscard]] bool _Is_complete() const {
            
            
            if (_Out_of_range(_Hour_12, 1, 12) 
                || _Out_of_range(_Weekday, 0, 6) 
                || _Out_of_range(_Day, 1, 31) 
                || _Out_of_range(_Month, 1, 12)) {
                return false;
            }

            if (_Iso_year || _Two_dig_iso_year || _Iso_week) {
                
                const bool _Has_complete_year{_Iso_year || ((_Century || _Two_dig_year) && _Two_dig_iso_year)};
                if (!_Has_complete_year || !_Iso_week || !_Weekday || _Out_of_range(_Iso_week, 1, 53)) {
                    return false;
                }
            }

            if (_Week_u || _Week_w) {
                
                if (!_Weekday || !_Two_dig_year) {
                    return false;
                }

                if (_Out_of_range(_Week_u, 0, 53) || _Out_of_range(_Week_w, 0, 53)) {
                    return false;
                }
            }

            return true;
        }

        template <class _Duration1, class _Duration2>
        [[nodiscard]] static constexpr bool _Can_represent() {
            using _Rep1    = typename _Duration1::rep;
            using _Period1 = typename _Duration1::period;
            using _Period2 = typename _Duration2::period;

            
            if constexpr (is_integral_v<_Rep1>) {
                
                
                constexpr auto _Max_tick = static_cast<intmax_t>((numeric_limits<make_signed_t<_Rep1>>::max)());

                return ratio_less_equal_v<_Period1, _Period2> 
                    && ratio_greater_equal_v<ratio<_Max_tick, _Period2::num>, ratio_divide<ratio<1>, _Period1>>;
            } else if (is_floating_point_v<_Rep1>) {
                
                
                return true;
            } else {
                
                return true;
            }
        }

        enum class _Parse_tp_or_duration { _Time_point, _Duration };

        template <_Parse_tp_or_duration _Parse_type, class _DurationType>
        [[nodiscard]] bool _Apply_duration_fields(_DurationType& _Result) {
            constexpr bool _Can_rep_sec    = _Can_represent<_DurationType, seconds>();
            constexpr bool _Can_rep_min    = _Can_represent<_DurationType, minutes>();
            constexpr bool _Can_rep_hr     = _Can_represent<_DurationType, hours>();
            constexpr bool _Can_rep_day    = _Can_represent<_DurationType, days>();
            constexpr bool _For_time_point = _Parse_type == _Parse_tp_or_duration::_Time_point;

            const auto _Required{(_For_time_point ? _F_day | _F_mon | _F_year : 0)};
            const auto _Optional{(_For_time_point ? _F_wkday : 0) | (_Can_rep_sec ? _F_sec : 0)
                                 | (_Can_rep_min ? _F_min : 0) | (_Can_rep_hr ? _F_hr : 0)
                                 | (_Can_rep_day ? _F_doy : 0)};

            const auto _Used{_Used_fields()};
            const auto _Time_out_of_range{
                _For_time_point
                && (_Out_of_range(_Second, 0, 60) || _Out_of_range(_Minute, 0, 59) || _Out_of_range(_Hour_24, 0, 23))};

            if (_Time_out_of_range || !_Test_bits(_Used, _Required, _Optional)) {
                return false;
            }

            _Result = _DurationType::zero();
            if constexpr (_Can_rep_sec) {
                if (_Used & _F_sec) {
                    if (_Subsecond) {
                        using _CastedType = duration<int64_t, typename _DurationType::period>;
                        const _SubsecondType _Sub{*_Subsecond};
                        if (treat_as_floating_point_v<_DurationType> 
                            || ::std::chrono:: duration_cast<_CastedType>(_Sub) == _Sub) {
                            _Result += ::std::chrono:: duration_cast<_DurationType>(_Sub);
                        } else {
                            return false;
                        }
                    }

                    if (_Second) {
                        _Result += ::std::chrono:: duration_cast<_DurationType>(seconds{*_Second});
                    }
                }
            }

            if constexpr (_Can_rep_min) {
                if (_Used & _F_min) {
                    _Result += ::std::chrono:: duration_cast<_DurationType>(minutes{*_Minute});
                }

                if (_Utc_offset) {
                    _Result -= ::std::chrono:: duration_cast<_DurationType>(minutes{*_Utc_offset});
                }
            }

            if constexpr (_Can_rep_hr) {
                if (_Used & _F_hr) {
                    _Result += ::std::chrono:: duration_cast<_DurationType>(hours{*_Hour_24});
                }
            }

            if constexpr (_Can_rep_day) {
                if (_For_time_point) {
                    const year_month_day _Ymd{year{*_Century + *_Two_dig_year},
                        month{static_cast<unsigned int>(*_Month)}, day{static_cast<unsigned int>(*_Day)}};
                    _Result += ::std::chrono:: duration_cast<_DurationType>(static_cast<sys_days>(_Ymd).time_since_epoch());
                } else if (_Used & _F_doy) {
                    _Result += ::std::chrono:: duration_cast<_DurationType>(days{*_Day_of_year});
                }
            }

            return true;
        }

        template <class _Rep, class _Period>
        [[nodiscard]] bool _Make_duration(duration<_Rep, _Period>& _Duration_result) {
            const bool _Consistent = _Calculate_hour24();
            if (_Consistent) {
                return _Apply_duration_fields<_Parse_tp_or_duration::_Duration>(_Duration_result);
            }

            return false;
        }

        enum class _LeapSecondRep : unsigned int {
            _None, 
            _Negative, 
            _All, 
            _File_time 
        };

        template <class _DurationType>
        [[nodiscard]] bool _Make_time_point(_DurationType& _Dur, _LeapSecondRep _Leap) {

            const bool _Consistent{_Calculate_hour24() && _Calculate_year_fields() && _Calculate_ymd()};
            if (!_Consistent || !_Apply_duration_fields<_Parse_tp_or_duration::_Time_point>(_Dur)) {
                return false;
            }

            const _LeapSecondRep _Original_leap{_Leap};
            if (_Leap == _LeapSecondRep::_File_time) {
                const int _Year{*_Century + *_Two_dig_year};
                _Leap = _Year <= 2016 ? _LeapSecondRep::_Negative : _LeapSecondRep::_All;
            }

            if (_Second > (_Leap == _LeapSecondRep::_All ? 60 : 59)) {
                return false;
            }

            
            if (_Leap != _LeapSecondRep::_None) {
                if (_Hour_24 == 23 && _Minute == 59 && _Second >= 59) {
                    
                    
                    const auto& _Tzdb{::std::chrono:: get_tzdb()};
                    if (_Leap == _LeapSecondRep::_Negative && _Tzdb._All_ls_positive) {
                        return true;
                    }

                    const bool _Possible_insertion{_Second == 60};
                    const sys_seconds _Target_sys_time{
                        ::std::chrono:: floor<seconds>(_Dur) + (_Possible_insertion ? seconds{0} : seconds{1})};
                    const auto& _Ls_vector{_Tzdb.leap_seconds};
                    const auto _It{::std:: lower_bound(_Ls_vector.begin(), _Ls_vector.end(), _Target_sys_time)};
                    const bool _Match_leap{_It != _Ls_vector.end() && *_It == _Target_sys_time};

                    
                    if (!(_Match_leap ? _It->_Positive() : !_Possible_insertion)) {
                        return false;
                    }
                }

                if (_Leap == _LeapSecondRep::_All) {
                    constexpr bool _Can_rep_sec = _Can_represent<_DurationType, seconds>();
                    if constexpr (_Can_rep_sec) {
                        _Dur = utc_clock::from_sys(sys_time<_DurationType>{_Dur}).time_since_epoch();
                        
                        
                        if (_Second == 60) {
                            _Dur -= ::std::chrono:: duration_cast<_DurationType>(seconds{1});
                        }

                        if (_Original_leap == _LeapSecondRep::_File_time) {
                            _Dur -= ::std::chrono:: duration_cast<_DurationType>(
                                filesystem::_File_time_clock::_Skipped_filetime_leap_seconds);
                        }
                    } else {
                        
                        return false;
                    }
                }
            }

            return true;
        }

        [[nodiscard]] bool _Make_day(day& _Day_result) {
            if (_Used_fields() == _F_day) {
                _Day_result = day{static_cast<unsigned int>(*_Day)};
                return true;
            } else {
                return false;
            }
        }

        [[nodiscard]] bool _Make_weekday(weekday& _Weekday_result) {
            if (_Used_fields() == _F_wkday) {
                _Weekday_result = weekday{static_cast<unsigned int>(*_Weekday)};
                return true;
            } else {
                return false;
            }
        }

        [[nodiscard]] bool _Make_month(month& _Month_result) {
            if (_Used_fields() == _F_mon) {
                _Month_result = month{static_cast<unsigned int>(*_Month)};
                return true;
            } else {
                return false;
            }
        }

        [[nodiscard]] bool _Make_month_day(month_day& _Month_day_result) {
            if (_Day_of_year && !_Yday_to_month_day(*_Day_of_year, 0)) {
                return false;
            }

            constexpr auto _Required = _F_mon | _F_day;
            constexpr auto _Optional = _F_doy;
            if (_Test_bits(_Used_fields(), _Required, _Optional)) {
                _Month_day_result =
                    month_day{month{static_cast<unsigned int>(*_Month)}, day{static_cast<unsigned int>(*_Day)}};
                return true;
            } else {
                return false;
            }
        }

        [[nodiscard]] bool _Make_year(year& _Year_result) {
            if (_Calculate_year_fields() && _Used_fields() == _F_year) {
                _Year_result = year{*_Century + *_Two_dig_year};
                return true;
            } else {
                return false;
            }
        }

        [[nodiscard]] bool _Make_year_month(year_month& _Year_month_result) {
            if (_Calculate_year_fields() && _Used_fields() == (_F_mon | _F_year)) {
                _Year_month_result =
                    year_month{year{*_Century + *_Two_dig_year}, month{static_cast<unsigned int>(*_Month)}};
                return true;
            } else {
                return false;
            }
        }

        [[nodiscard]] bool _Make_year_month_day(
            year_month_day& _Year_month_day_result, const bool _For_time_point = false) {
            const bool _Consistent   = _Calculate_year_fields() && _Calculate_ymd();
            constexpr auto _Required = _F_day | _F_mon | _F_year;
            auto _Optional           = _F_wkday | _F_doy;
            if (_For_time_point) {
                
                _Optional |= _F_sec | _F_min | _F_hr;
            }

            if (_Consistent && _Test_bits(_Used_fields(), _Required, _Optional)) {
                _Year_month_day_result = year_month_day{year{*_Century + *_Two_dig_year},
                    month{static_cast<unsigned int>(*_Month)}, day{static_cast<unsigned int>(*_Day)}};
                return true;
            } else {
                return false;
            }
        }

        template <class _InIt>
        [[nodiscard]] _InIt _Parse_time_field(_InIt _First, ios_base& _Iosbase, ios_base::iostate& _State,
            const char _Flag, const char _Modifier, const unsigned int _Width,
            const unsigned int _Subsecond_precision) {
            using _CharT = typename _InIt::value_type;

            const auto& _Ctype_fac = ::std:: use_facet<ctype<_CharT>>(_Iosbase.getloc());
            const auto& _Time_fac  = ::std:: use_facet<time_get<_CharT>>(_Iosbase.getloc());
            constexpr _InIt _Last{};

            int _Val{0};
            switch (_Flag) {
            case 'a':
            case 'A':
                {
                    tm _Tp;
                    _Tp.tm_wday = _Invalid_time_field<int>;
                    _First      = _Time_fac.get(_First, _Last, _Iosbase, _State, &_Tp, 'a');
                    if (!_Update(_Weekday, _Tp.tm_wday)) {
                        _State |= ios_base::failbit;
                    }
                    break;
                }

            case 'b':
            case 'B':
            case 'h':
                {
                    tm _Tp;
                    _Tp.tm_mon = _Invalid_time_field<int>;
                    _First     = _Time_fac.get(_First, _Last, _Iosbase, _State, &_Tp, 'b');
                    if (_Tp.tm_mon == _Invalid_time_field<int> || !_Update(_Month, ++_Tp.tm_mon)) {
                        _State |= ios_base::failbit;
                    }
                    break;
                }

            case 'C':
                if (_Modifier != 'E') {
                    _State |= _Get_int(_First, _Width == 0 ? 2u : _Width, _Val, _Ctype_fac);
                    _Val *= 100;
                } else {
                    tm _Tp;
                    _Tp.tm_year = _Invalid_time_field<int>;
                    _First      = _Time_fac.get(_First, _Last, _Iosbase, _State, &_Tp, 'C', 'E');
                    _Val        = _Tp.tm_year;
                    if (_Tp.tm_year != _Invalid_time_field<int>) {
                        _Val += 1900;
                    }
                }

                if (!_Update(_Century, _Val)) {
                    _State |= ios_base::failbit;
                }
                break;

            case 'd':
            case 'e':
                if (_Modifier != 'O') {
                    _State |= _Get_int(_First, _Width == 0 ? 2u : _Width, _Val, _Ctype_fac);
                } else {
                    tm _Tp;
                    _Tp.tm_mday = _Invalid_time_field<int>;
                    _First      = _Time_fac.get(_First, _Last, _Iosbase, _State, &_Tp, 'd', 'O');
                    _Val        = _Tp.tm_mday;
                }

                if (!_Update(_Day, _Val)) {
                    _State |= ios_base::failbit;
                }
                break;

            case 'D':
                _First = _Parse_time_field_restricted(_First, _Iosbase, _State, "%m/%d/%y");
                break;

            case 'F':
                {
                    
                    _State |= _Get_int(_First, _Width == 0 ? 4u : _Width, _Val, _Ctype_fac);
                    const auto _Year_parts = _Decompose_year(_Val);
                    if (_Update(_Century, _Year_parts.first) && _Update(_Two_dig_year, _Year_parts.second)) {
                        _First = _Parse_time_field_restricted(_First, _Iosbase, _State, "-%m-%d");
                    } else {
                        _State |= ios_base::failbit;
                    }
                    break;
                }

            case 'g':
                _State |= _Get_int(_First, _Width == 0 ? 2u : _Width, _Val, _Ctype_fac);
                if (!_Update(_Two_dig_iso_year, _Val)) {
                    _State |= ios_base::failbit;
                }
                break;

            case 'G':
                {
                    _State |= _Get_int(_First, _Width == 0 ? 4u : _Width, _Val, _Ctype_fac);
                    const auto _Year_parts = _Decompose_year(_Val);
                    if (!_Update(_Iso_year, _Val) || !_Update(_Two_dig_iso_year, _Year_parts.second)) {
                        _State |= ios_base::failbit;
                    }
                    break;
                }

            case 'H':
                if (_Modifier != 'O') {
                    _State |= _Get_int(_First, _Width == 0 ? 2u : _Width, _Val, _Ctype_fac);
                } else {
                    tm _Tp;
                    _Tp.tm_hour = _Invalid_time_field<int>;
                    _First      = _Time_fac.get(_First, _Last, _Iosbase, _State, &_Tp, 'H', 'O');
                    _Val        = _Tp.tm_hour;
                }

                if (!_Update(_Hour_24, _Val)
                    || (_Val < 24
                        && (!_Update(_Ampm, _Val >= 12 ? 1 : 0)
                            || !_Update(_Hour_12, ::std::chrono:: make12(hours{_Val}).count())))) {
                    _State |= ios_base::failbit;
                }
                break;

            case 'I':
                if (_Modifier != 'O') {
                    _State |= _Get_int(_First, _Width == 0 ? 2u : _Width, _Val, _Ctype_fac);
                } else {
                    tm _Tp;
                    _Tp.tm_hour = _Invalid_time_field<int>;
                    _First      = _Time_fac.get(_First, _Last, _Iosbase, _State, &_Tp, 'I', 'O');
                    _Val        = (_Tp.tm_hour == 0) ? 12 : _Tp.tm_hour;
                }

                if (!_Update(_Hour_12, _Val)) {
                    _State |= ios_base::failbit;
                }
                break;

            case 'j':
                _State |= _Get_int(_First, _Width == 0 ? 3u : _Width, _Val, _Ctype_fac);
                if (!_Update(_Day_of_year, _Val)) {
                    _State |= ios_base::failbit;
                }
                break;

            case 'M':
                if (_Modifier != 'O') {
                    _State |= _Get_int(_First, _Width == 0 ? 2u : _Width, _Val, _Ctype_fac);
                } else {
                    tm _Tp;
                    _Tp.tm_min = _Invalid_time_field<int>;
                    _First     = _Time_fac.get(_First, _Last, _Iosbase, _State, &_Tp, 'M', 'O');
                    _Val       = _Tp.tm_min;
                }

                if (!_Update(_Minute, _Val)) {
                    _State |= ios_base::failbit;
                }
                break;

            case 'm':
                if (_Modifier != 'O') {
                    _State |= _Get_int(_First, _Width == 0 ? 2u : _Width, _Val, _Ctype_fac);
                } else {
                    tm _Tp;
                    _Initialize_time_point(_Tp);
                    _First = _Time_fac.get(_First, _Last, _Iosbase, _State, &_Tp, 'm', 'O');
                    _Val   = _Tp.tm_mon;
                    if (_Tp.tm_mon != _Invalid_time_field<int>) {
                        ++_Val;
                    }
                }

                if (!_Update(_Month, _Val)) {
                    _State |= ios_base::failbit;
                }
                break;

            case 'p':
                {
                    tm _Tp;
                    _Tp.tm_hour = 0;
                    _First      = _Time_fac.get(_First, _Last, _Iosbase, _State, &_Tp, 'p');
                    if (!_Update(_Ampm, _Tp.tm_hour == 0 ? 0 : 1)) {
                        _State |= ios_base::failbit;
                    }
                    break;
                }

            case 'c':
            case 'r':
            case 'x':
            case 'X':
                {
                    tm _Tp;
                    _Initialize_time_point(_Tp);
                    const bool _Full_year = (_Flag == 'c'); 
                    _First                = _Time_fac.get(_First, _Last, _Iosbase, _State, &_Tp, _Flag, _Modifier);
                    if (!_Update_if_valid(_Tp, _Full_year)) {
                        _State |= ios_base::failbit;
                    }
                    break;
                }

            case 'R':
                _First = _Parse_time_field_restricted(_First, _Iosbase, _State, "%H:%M");
                break;

            case 'T':
                _First = _Parse_time_field_restricted(_First, _Iosbase, _State, "%H:%M:%S", _Subsecond_precision);
                break;

            case 'S':
                if (_Subsecond_precision == 0) {
                    _State |= _Get_int(_First, _Width == 0 ? 2u : _Width, _Val, _Ctype_fac);
                    if (!_Update(_Second, _Val)) {
                        _State |= ios_base::failbit;
                    }
                } else {
                    const auto& _Numpunct_fac = ::std:: use_facet<numpunct<_CharT>>(_Iosbase.getloc());
                    _State |=
                        _Get_fixed(_First, _Width == 0 ? 3 + _Subsecond_precision : _Width, _Ctype_fac, _Numpunct_fac);
                }
                break;

            case 'u':
            case 'w':
                if (_Flag == 'w' && _Modifier == 'O') {
                    tm _Tp;
                    _Tp.tm_wday = _Invalid_time_field<int>;
                    _First      = _Time_fac.get(_First, _Last, _Iosbase, _State, &_Tp, 'w', 'O');
                    _Val        = _Tp.tm_wday;
                } else {
                    _State |= _Get_int(_First, _Width == 0 ? 1u : _Width, _Val, _Ctype_fac);
                    if (_Flag == 'u') {
                        
                        if (_Val == 7) {
                            _Val = 0;
                        } else if (_Val == 0) {
                            _Val = 7; 
                        }
                    }
                }

                if (!_Update(_Weekday, _Val)) {
                    _State |= ios_base::failbit;
                }
                break;

            case 'U':
            case 'V':
            case 'W':
                {
                    _State |= _Get_int(_First, _Width == 0 ? 2u : _Width, _Val, _Ctype_fac);
                    auto& _Field{(_Flag == 'U') ? _Week_u : (_Flag == 'W' ? _Week_w : _Iso_week)};
                    if (!_Update(_Field, _Val)) {
                        _State |= ios_base::failbit;
                    }
                    break;
                }

            case 'y':
                if (_Modifier == '\0') {
                    _State |= _Get_int(_First, _Width == 0 ? 2u : _Width, _Val, _Ctype_fac);
                } else {
                    tm _Tp;
                    _Tp.tm_year = _Invalid_time_field<int>;
                    _First      = _Time_fac.get(_First, _Last, _Iosbase, _State, &_Tp, 'y', _Modifier);
                    if (_Modifier == 'E') {
                        _Val = _Tp.tm_year + 1900; 
                    } else {
                        const auto _Year_parts = _Decompose_year(_Tp.tm_year);
                        _Val                   = _Year_parts.second;
                    }
                }

                if (!_Update(_Two_dig_year, _Val)) {
                    _State |= ios_base::failbit;
                }
                break;

            case 'Y':
                {
                    if (_Modifier == 'E') {
                        tm _Tp;
                        _Tp.tm_year = _Invalid_time_field<int>;
                        _First      = _Time_fac.get(_First, _Last, _Iosbase, _State, &_Tp, 'Y', 'E');
                        _Val        = _Tp.tm_year + 1900;
                    } else {
                        _State |= _Get_int(_First, _Width == 0 ? 4u : _Width, _Val, _Ctype_fac);
                    }

                    const auto _Year_parts = _Decompose_year(_Val);
                    if (!_Update(_Century, _Year_parts.first) || !_Update(_Two_dig_year, _Year_parts.second)) {
                        _State |= ios_base::failbit;
                    }
                    break;
                }

            case 'z':
                _State |= _Get_tz_offset(_First, _Ctype_fac, _Modifier == 'E' || _Modifier == 'O', _Val);
                if (!_Update(_Utc_offset, _Val)) {
                    _State |= ios_base::failbit;
                }
                break;

            case 'Z':
                {
                    string _Name;
                    _State |= _Get_tz_name(_First, _Ctype_fac, _Name);
                    if (!_Update(_Tz_name, _Name)) {
                        _State |= ios_base::failbit;
                    }
                    break;
                }

            default:
                
                _State |= ios_base::failbit;
                break;
            }

            return _First;
        }

        template <class _InIt>
        [[nodiscard]] _InIt _Parse_time_field_restricted(_InIt _First, ios_base& _Iosbase, ios_base::iostate& _State,
            const char* _Fmt, const unsigned int _Subsecond_precision = 0) {
            using _Ctype = ctype<typename _InIt::value_type>;
            
            
            const _Ctype& _Ctype_fac{::std:: use_facet<_Ctype>(_Iosbase.getloc())};
            constexpr _InIt _Last{};

            while (*_Fmt != '\0' && _First != _Last && _State == ios_base::goodbit) {
                if (*_Fmt == '%') {
                    _First = _Parse_time_field(_First, _Iosbase, _State, *++_Fmt, '\0', 0, _Subsecond_precision);
                } else if (_Ctype_fac.narrow(*_First++) != *_Fmt) {
                    _State |= ios_base::failbit;
                }
                ++_Fmt;
            }
            return _First;
        }

        template <class _InIt>
        [[nodiscard]] ios_base::iostate _Get_fixed(_InIt& _First, unsigned int _Width,
            const ctype<typename _InIt::value_type>& _Ctype_fac,
            const numpunct<typename _InIt::value_type>& _Numpunct_fac) {
            constexpr _InIt _Last{};

            while (_First != _Last && _Ctype_fac.is(ctype_base::space, *_First) && _Width > 0) {
                ++_First;
                --_Width;
            }

            int _Second_        = 0;
            int64_t _Subsecond_ = 0;
            int64_t _Multiplier = _SubsecondType::period::den;
            bool _Found_point   = false;
            bool _Found_digit   = false;

            while (_First != _Last && _Width > 0 && _Multiplier >= 10) {
                const auto _Ch = *_First;
                if (_Ch == _Numpunct_fac.decimal_point() && !_Found_point) {
                    _Found_point = true;
                } else if (_Ctype_fac.is(ctype_base::digit, _Ch)) {
                    _Found_digit      = true;
                    const auto _Digit = _Ctype_fac.narrow(_Ch) - '0';
                    if (_Found_point) {
                        _Multiplier /= 10;
                        _Subsecond_ += _Digit * _Multiplier;
                    } else {
                        if (_Second_ > ((numeric_limits<int>::max)() - _Digit) / 10) {
                            return ios_base::failbit;
                        }

                        _Second_ = _Second_ * 10 + _Digit;
                    }
                } else {
                    break;
                }
                ++_First;
                --_Width;
            }

            ios_base::iostate _State = ios_base::goodbit;
            if (_First == _Last) {
                _State |= ios_base::eofbit;
            }

            if (!(_Found_digit && _Update(_Second, _Second_) && _Update(_Subsecond, _Subsecond_))) {
                _State |= ios_base::failbit;
            }

            return _State;
        }

        template <class _InIt>
        [[nodiscard]] ios_base::iostate _Get_int(
            _InIt& _First, unsigned int _Width, int& _Val, const ctype<typename _InIt::value_type>& _Ctype_fac) {
            constexpr _InIt _Last{};

            while (_First != _Last && _Ctype_fac.is(ctype_base::space, *_First) && _Width > 0) {
                ++_First;
                --_Width;
            }

            char _Ac[32];
            char* _Ptr = _Ac;
            if (_First != _Last && _Width > 0) {
                const char _Ch = _Ctype_fac.narrow(*_First);
                if (_Ch == '+' || _Ch == '-') { 
                    *_Ptr++ = _Ch;
                    ++_First;
                    --_Width;
                }
            }

            bool _Has_leading_zero = false;
            while (_First != _Last && _Width > 0 && _Ctype_fac.narrow(*_First) == '0') { 
                ++_First;
                --_Width;
                _Has_leading_zero = true;
            }

            if (_Has_leading_zero) {
                *_Ptr++ = '0';
            }

            char _Ch;
            while (_First != _Last && _Width > 0 && '0' <= (_Ch = _Ctype_fac.narrow(*_First))
                   && _Ch <= '9') { 
                *_Ptr = _Ch;
                if (_Ptr < ::std:: cend(_Ac)) {
                    ++_Ptr; 
                }
                ++_First;
                --_Width;
            }

            *_Ptr      = '\0';
            int _Errno = 0;
            char* _Ep;
            const long _Ans          = :: _Stolx(_Ac, &_Ep, 10, &_Errno);
            ios_base::iostate _State = ios_base::goodbit;

            if (_First == _Last) {
                _State |= ios_base::eofbit;
            }

            if (_Ep == _Ac || _Errno != 0) {
                _State |= ios_base::failbit; 
            } else {
                _Val = _Ans; 
            }

            return _State;
        }

        template <class _InIt>
        [[nodiscard]] ios_base::iostate _Get_tz_offset(
            _InIt& _First, const ctype<typename _InIt::value_type>& _Ctype_fac, const bool _Is_modified, int& _Offset) {
            constexpr _InIt _Last{};
            if (_First == _Last) {
                return ios_base::eofbit;
            }

            bool _Negative = false;
            switch (_Ctype_fac.narrow(*_First)) {
            case '-':
                _Negative = true;
                [[fallthrough]];
            case '+':
                ++_First;
                break;
            }

            
            int _Tz_hours        = 0;
            int _Tz_minutes      = 0;
            int _Optional_digits = 1;
            for (int _Count = 0; _Count < 4; ++_Count) {
                const bool _Allow_match_fail{_Count == (_Is_modified ? 1 : 2)};

                if (_First == _Last) {
                    if (_Allow_match_fail) {
                        break;
                    } else {
                        return ios_base::eofbit | ios_base::failbit;
                    }
                }

                const char _Ch       = _Ctype_fac.narrow(*_First++);
                const bool _Is_digit = ('0' <= _Ch && _Ch <= '9');
                if (_Is_modified && _Count == 1) {
                    if (_Ch == ':') {
                        continue;
                    } else if (_Is_digit && _Optional_digits > 0) {
                        _Tz_hours = 10 * _Tz_hours + (_Ch - '0');
                        --_Optional_digits;
                        --_Count;
                    } else {
                        if (_Allow_match_fail) {
                            break;
                        } else {
                            return ios_base::failbit;
                        }
                    }
                } else if (_Is_digit) {
                    auto& _Part = _Count < 2 ? _Tz_hours : _Tz_minutes;
                    _Part       = 10 * _Part + (_Ch - '0');
                } else {
                    if (_Allow_match_fail) {
                        break;
                    } else {
                        return ios_base::failbit;
                    }
                }
            }

            _Offset = 60 * _Tz_hours + _Tz_minutes;
            if (_Negative) {
                _Offset = -_Offset;
            }
            return ios_base::goodbit;
        }

        template <class _InIt>
        [[nodiscard]] ios_base::iostate _Get_tz_name(
            _InIt& _First, const ctype<typename _InIt::value_type>& _Ctype_fac, string& _Tz_name) {
            constexpr _InIt _Last{};
            _Tz_name.clear();
            while (_First != _Last) {
                const char _Ch{_Ctype_fac.narrow(*_First)};
                if (::std:: isalnum(static_cast<unsigned char>(_Ch)) || _Ch == '_' || _Ch == '/' || _Ch == '-'
                    || _Ch == '+') {
                    _Tz_name.push_back(_Ch);
                    ++_First;
                } else {
                    break;
                }
            }
            return _First == _Last ? ios_base::eofbit : ios_base::goodbit;
        }

        template <class _CharT, class _Traits, class _Alloc = allocator<_CharT>>
        _Time_parse_fields(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _FmtFirst,
            basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr, minutes* _Offset = nullptr,
            unsigned int _Subsecond_precision = 0) {

            using _Myis = basic_istream<_CharT, _Traits>;

            const auto& _Ctype_fac       = ::std:: use_facet<ctype<_CharT>>(_Istr.getloc());
            ios_base::iostate _State     = ios_base::goodbit;
            const _CharT* const _FmtLast = _FmtFirst + _Traits::length(_FmtFirst);
            const typename _Myis::sentry _Ok{_Istr, true};

            istreambuf_iterator _First{_Istr};
            constexpr decltype(_First) _Last{};

            if (_Ok) {
                try {
                for (; _FmtFirst != _FmtLast && _State == ios_base::goodbit; ++_FmtFirst) {
                    if (_First == _Last) {
                        
                        for (; _FmtFirst != _FmtLast; ++_FmtFirst) {
                            char _Flag{};
                            if (_Ctype_fac.is(ctype_base::space, *_FmtFirst)) {
                                _Flag = ' ';
                            } else {
                                if (_Ctype_fac.narrow(*_FmtFirst) == '%' && ++_FmtFirst != _FmtLast) {
                                    _Flag = _Ctype_fac.narrow(*_FmtFirst);
                                }
                            }

                            if (_Flag != ' ' && _Flag != 't') {
                                _State |= ios_base::failbit | ios_base::eofbit;
                                break;
                            }
                        }
                        break;
                    } else if (_Ctype_fac.narrow(*_FmtFirst) != '%') { 
                        if (_Ctype_fac.is(ctype_base::space, *_FmtFirst)) {
                            while (_First != _Last && _Ctype_fac.is(ctype_base::space, *_First)) {
                                ++_First;
                            }
                        } else if (*_First == *_FmtFirst) {
                            ++_First;
                        } else {
                            _State |= ios_base::failbit; 
                        }
                    } else if (++_FmtFirst == _FmtLast) { 
                        _State |= ios_base::failbit;
                    } else { 
                        char _Flag          = _Ctype_fac.narrow(*_FmtFirst);
                        char _Modifier      = '\0';
                        unsigned int _Width = 0;

                        if (_Flag == 'E' || _Flag == 'O') {
                            if (++_FmtFirst == _FmtLast) {
                                _State |= ios_base::failbit;
                                break;
                            }
                            _Modifier = ::std:: exchange(_Flag, _Ctype_fac.narrow(*_FmtFirst));
                        } else if ('0' <= _Flag && _Flag <= '9') {
                            _Width = static_cast<unsigned int>(_Flag - '0');
                            while (++_FmtFirst != _FmtLast && _Ctype_fac.is(ctype_base::digit, *_FmtFirst)) {
                                const auto _Digit = static_cast<unsigned int>(_Ctype_fac.narrow(*_FmtFirst) - '0');
                                if (_Width > ((numeric_limits<unsigned int>::max)() - _Digit) / 10) {
                                    _State |= ios_base::failbit;
                                    break;
                                }
                                _Width = 10 * _Width + _Digit;
                            }
                            if (_FmtFirst == _FmtLast) {
                                _State |= ios_base::failbit;
                                break;
                            }
                            _Flag = _Ctype_fac.narrow(*_FmtFirst);
                        }

                        switch (_Flag) {
                        case 'n': 
                            if (!_Ctype_fac.is(ctype_base::space, *_First++)) {
                                _State |= ios_base::failbit;
                            }
                            break;

                        case 't': 
                            if (_Ctype_fac.is(ctype_base::space, *_First)) {
                                ++_First;
                            }
                            break;

                        case '%':
                            if (_Ctype_fac.narrow(*_First++) != '%') {
                                _State |= ios_base::failbit;
                            }
                            break;

                        default:
                            _First = _Parse_time_field(_First, _Istr, _State, _Flag, _Modifier, _Width,
                                _Subsecond_precision); 
                            break;
                        }
                    }
                }

                } catch (...) { (_Istr) .setstate(_Myis::badbit, true); }
            }

            if (!_Is_complete()) {
                _State |= ios_base::failbit;
            }

            if (!(_State & ios_base::failbit)) {
                if (_Offset != nullptr && _Utc_offset) {
                    *_Offset = minutes{*_Utc_offset};
                }

                if (_Abbrev != nullptr && _Tz_name) {
                    if constexpr (is_same_v<decltype(_Abbrev), string*>) {
                        *_Abbrev = ::std:: move(*_Tz_name);
                    } else {
                        _Abbrev->clear();
                        for (const char& _Ch : *_Tz_name) {
                            _Abbrev->push_back(_Ctype_fac.widen(_Ch));
                        }
                    }
                }
            }

            _Istr.setstate(_State);
        }
    };

    template <class _CharT, class _Traits, class _Rep, class _Period, class _Alloc = allocator<_CharT>>
    basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
        duration<_Rep, _Period>& _Duration, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr,
        minutes* _Offset = nullptr) {
        _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset, hh_mm_ss<duration<_Rep, _Period>>::fractional_width};
        if (_Istr && !_Time._Make_duration(_Duration)) {
            _Istr.setstate(ios_base::failbit);
        }
        return _Istr;
    }

    template <class _CharT, class _Traits, class _Alloc = allocator<_CharT>>
    basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt, weekday& _Wd,
        basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr, minutes* _Offset = nullptr) {
        _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset};
        if (_Istr && !_Time._Make_weekday(_Wd)) {
            _Istr.setstate(ios_base::failbit);
        }
        return _Istr;
    }

    template <class _CharT, class _Traits, class _Alloc = allocator<_CharT>>
    basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt, day& _Day,
        basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr, minutes* _Offset = nullptr) {
        _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset};
        if (_Istr && !_Time._Make_day(_Day)) {
            _Istr.setstate(ios_base::failbit);
        }
        return _Istr;
    }

    template <class _CharT, class _Traits, class _Alloc = allocator<_CharT>>
    basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
        month& _Month, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr, minutes* _Offset = nullptr) {
        _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset};
        if (_Istr && !_Time._Make_month(_Month)) {
            _Istr.setstate(ios_base::failbit);
        }
        return _Istr;
    }

    template <class _CharT, class _Traits, class _Alloc = allocator<_CharT>>
    basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
        month_day& _Md, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr, minutes* _Offset = nullptr) {
        _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset};
        if (_Istr && !_Time._Make_month_day(_Md)) {
            _Istr.setstate(ios_base::failbit);
        }
        return _Istr;
    }

    template <class _CharT, class _Traits, class _Alloc = allocator<_CharT>>
    basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt, year& _Year,
        basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr, minutes* _Offset = nullptr) {
        _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset};
        if (_Istr && !_Time._Make_year(_Year)) {
            _Istr.setstate(ios_base::failbit);
        }
        return _Istr;
    }

    template <class _CharT, class _Traits, class _Alloc = allocator<_CharT>>
    basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
        year_month& _Ym, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr, minutes* _Offset = nullptr) {
        _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset};
        if (_Istr && !_Time._Make_year_month(_Ym)) {
            _Istr.setstate(ios_base::failbit);
        }
        return _Istr;
    }

    template <class _CharT, class _Traits, class _Alloc = allocator<_CharT>>
    basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
        year_month_day& _Ymd, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr, minutes* _Offset = nullptr) {
        _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset};
        if (_Istr && !_Time._Make_year_month_day(_Ymd)) {
            _Istr.setstate(ios_base::failbit);
        }
        return _Istr;
    }

    template <class _CharT, class _Traits, class _Duration, class _Alloc = allocator<_CharT>>
    basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
        utc_time<_Duration>& _Tp, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr,
        minutes* _Offset = nullptr) {
        constexpr auto _Subsecond_precision{hh_mm_ss<_Duration>::fractional_width};
        _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset, _Subsecond_precision};
        _Duration _Dur;
        if (_Istr && _Time._Make_time_point(_Dur, _Time_parse_fields::_LeapSecondRep::_All)) {
            _Tp = utc_time<_Duration>{_Dur};
        } else {
            _Istr.setstate(ios_base::failbit);
        }
        return _Istr;
    }

    template <class _CharT, class _Traits, class _Duration, class _Alloc = allocator<_CharT>>
    basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
        sys_time<_Duration>& _Tp, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr,
        minutes* _Offset = nullptr) {
        constexpr auto _Subsecond_precision{hh_mm_ss<_Duration>::fractional_width};
        _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset, _Subsecond_precision};
        _Duration _Dur;
        if (_Istr && _Time._Make_time_point(_Dur, _Time_parse_fields::_LeapSecondRep::_Negative)) {
            _Tp = sys_time<_Duration>{_Dur};
        } else {
            _Istr.setstate(ios_base::failbit);
        }
        return _Istr;
    }

    template <class _CharT, class _Traits, class _Duration, class _Alloc = allocator<_CharT>>
    basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
        tai_time<_Duration>& _Tp, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr,
        minutes* _Offset = nullptr) {
        constexpr auto _Subsecond_precision{hh_mm_ss<_Duration>::fractional_width};
        _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset, _Subsecond_precision};
        _Duration _Dur;
        if (_Istr && _Time._Make_time_point(_Dur, _Time_parse_fields::_LeapSecondRep::_None)) {
            _Tp = tai_time<_Duration>{_Dur + ::std::chrono:: duration_cast<_Duration>(days{4383})};
        } else {
            _Istr.setstate(ios_base::failbit);
        }
        return _Istr;
    }

    template <class _CharT, class _Traits, class _Duration, class _Alloc = allocator<_CharT>>
    basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
        gps_time<_Duration>& _Tp, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr,
        chrono::minutes* _Offset = nullptr) {
        constexpr auto _Subsecond_precision{hh_mm_ss<_Duration>::fractional_width};
        _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset, _Subsecond_precision};
        _Duration _Dur;
        if (_Istr && _Time._Make_time_point(_Dur, _Time_parse_fields::_LeapSecondRep::_None)) {
            _Tp = gps_time<_Duration>{_Dur - ::std::chrono:: duration_cast<_Duration>(days{3657})};
        } else {
            _Istr.setstate(ios_base::failbit);
        }
        return _Istr;
    }

    template <class _CharT, class _Traits, class _Duration, class _Alloc = allocator<_CharT>>
    basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
        file_time<_Duration>& _Tp, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr,
        chrono::minutes* _Offset = nullptr) {
        constexpr auto _Subsecond_precision{hh_mm_ss<_Duration>::fractional_width};
        _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset, _Subsecond_precision};
        _Duration _Dur;
        if (_Istr && _Time._Make_time_point(_Dur, _Time_parse_fields::_LeapSecondRep::_File_time)) {
            constexpr auto _File_clock_adj{::std::chrono:: duration_cast<_Duration>(
                filesystem::_File_time_clock::duration{filesystem::__std_fs_file_time_epoch_adjustment})};
            _Tp = file_time<_Duration>{_Dur} + _File_clock_adj;
        } else {
            _Istr.setstate(ios_base::failbit);
        }
        return _Istr;
    }

    template <class _CharT, class _Traits, class _Duration, class _Alloc = allocator<_CharT>>
    basic_istream<_CharT, _Traits>& from_stream(basic_istream<_CharT, _Traits>& _Istr, const _CharT* _Fmt,
        local_time<_Duration>& _Tp, basic_string<_CharT, _Traits, _Alloc>* _Abbrev = nullptr,
        minutes* _Offset = nullptr) {
        constexpr auto _Subsecond_precision{hh_mm_ss<_Duration>::fractional_width};
        _Time_parse_fields _Time{_Istr, _Fmt, _Abbrev, _Offset, _Subsecond_precision};
        
        _Time._Utc_offset.reset();
        _Duration _Dur;
        if (_Istr && _Time._Make_time_point(_Dur, _Time_parse_fields::_LeapSecondRep::_None)) {
            _Tp = local_time<_Duration>{_Dur};
        } else {
            _Istr.setstate(ios_base::failbit);
        }
        return _Istr;
    }

    template <class _CharT, class _Traits, class _Alloc, class _Parsable>
    struct _Time_parse_iomanip_c_str {
        _Time_parse_iomanip_c_str(const _CharT* _Fmt_, _Parsable& _Tp_,
            basic_string<_CharT, _Traits, _Alloc>* _Abbrev_ = nullptr, minutes* _Offset_ = nullptr)
            : _Fmt{_Fmt_}, _Tp{_Tp_}, _Abbrev{_Abbrev_}, _Offset{_Offset_} {}

        _Time_parse_iomanip_c_str(_Time_parse_iomanip_c_str&&) = delete;

        const _CharT* _Fmt;
        _Parsable& _Tp;
        basic_string<_CharT, _Traits, _Alloc>* _Abbrev;
        minutes* _Offset;
    };

    template <class _CharT, class _Traits, class _Alloc, class _Parsable>
    struct _Time_parse_iomanip {
        _Time_parse_iomanip(const basic_string<_CharT, _Traits, _Alloc>& _Fmt_, _Parsable& _Tp_,
            basic_string<_CharT, _Traits, _Alloc>* _Abbrev_ = nullptr, minutes* _Offset_ = nullptr)
            : _Fmt{_Fmt_}, _Tp{_Tp_}, _Abbrev{_Abbrev_}, _Offset{_Offset_} {}

        _Time_parse_iomanip(_Time_parse_iomanip&&) = delete;

        const basic_string<_CharT, _Traits, _Alloc>& _Fmt;
        _Parsable& _Tp;
        basic_string<_CharT, _Traits, _Alloc>* _Abbrev;
        minutes* _Offset;
    };

    template <class _CharT, class _Traits, class _Parsable, class... _Rest>
    using _Has_from_stream =
        decltype(static_cast<void>(from_stream(::std:: declval<basic_istream<_CharT, _Traits>&>(),
                     ::std:: declval<const _CharT*>(), ::std:: declval<_Parsable&>(), ::std:: declval<_Rest>()...)),
            0); 

    template <class _CharT, class _Parsable, _Has_from_stream<_CharT, char_traits<_CharT>, _Parsable> = 0>
    [[nodiscard]] auto parse(const _CharT* _Fmt, _Parsable& _Tp) {
        return _Time_parse_iomanip_c_str<_CharT, char_traits<_CharT>, allocator<_CharT>, _Parsable>{_Fmt, _Tp};
    }

    template <class _CharT, class _Traits, class _Alloc, class _Parsable,
        _Has_from_stream<_CharT, _Traits, _Parsable> = 0>
    [[nodiscard]] auto parse(const basic_string<_CharT, _Traits, _Alloc>& _Fmt, _Parsable& _Tp) {
        return _Time_parse_iomanip{_Fmt, _Tp};
    }

    template <class _CharT, class _Traits, class _Alloc, class _Parsable,
        _Has_from_stream<_CharT, _Traits, _Parsable, basic_string<_CharT, _Traits, _Alloc>*> = 0>
    [[nodiscard]] auto parse(const _CharT* _Fmt, _Parsable& _Tp, basic_string<_CharT, _Traits, _Alloc>& _Abbrev) {
        return _Time_parse_iomanip_c_str{_Fmt, _Tp, ::std:: addressof(_Abbrev)};
    }

    template <class _CharT, class _Traits, class _Alloc, class _Parsable,
        _Has_from_stream<_CharT, _Traits, _Parsable, basic_string<_CharT, _Traits, _Alloc>*> = 0>
    [[nodiscard]] auto parse(const basic_string<_CharT, _Traits, _Alloc>& _Fmt, _Parsable& _Tp,
        basic_string<_CharT, _Traits, _Alloc>& _Abbrev) {
        return _Time_parse_iomanip{_Fmt, _Tp, ::std:: addressof(_Abbrev)};
    }

    template <class _CharT, class _Parsable,
        _Has_from_stream<_CharT, char_traits<_CharT>, _Parsable, basic_string<_CharT>*, minutes*> = 0>
    [[nodiscard]] auto parse(const _CharT* _Fmt, _Parsable& _Tp, minutes& _Offset) {
        return _Time_parse_iomanip_c_str{_Fmt, _Tp, static_cast<basic_string<_CharT>*>(nullptr), &_Offset};
    }

    template <class _CharT, class _Traits, class _Alloc, class _Parsable,
        _Has_from_stream<_CharT, _Traits, _Parsable, basic_string<_CharT, _Traits, _Alloc>*, minutes*> = 0>
    [[nodiscard]] auto parse(const basic_string<_CharT, _Traits, _Alloc>& _Fmt, _Parsable& _Tp, minutes& _Offset) {
        return _Time_parse_iomanip{_Fmt, _Tp, static_cast<basic_string<_CharT, _Traits, _Alloc>*>(nullptr), &_Offset};
    }

    template <class _CharT, class _Traits, class _Alloc, class _Parsable,
        _Has_from_stream<_CharT, _Traits, _Parsable, basic_string<_CharT, _Traits, _Alloc>*, minutes*> = 0>
    [[nodiscard]] auto parse(
        const _CharT* _Fmt, _Parsable& _Tp, basic_string<_CharT, _Traits, _Alloc>& _Abbrev, minutes& _Offset) {
        return _Time_parse_iomanip_c_str{_Fmt, _Tp, ::std:: addressof(_Abbrev), &_Offset};
    }

    template <class _CharT, class _Traits, class _Alloc, class _Parsable,
        _Has_from_stream<_CharT, _Traits, _Parsable, basic_string<_CharT, _Traits, _Alloc>*, minutes*> = 0>
    [[nodiscard]] auto parse(const basic_string<_CharT, _Traits, _Alloc>& _Fmt, _Parsable& _Tp,
        basic_string<_CharT, _Traits, _Alloc>& _Abbrev, minutes& _Offset) {
        return _Time_parse_iomanip{_Fmt, _Tp, ::std:: addressof(_Abbrev), &_Offset};
    }

    template <class _CharT, class _Traits, class _Alloc, class _Parsable>
    basic_istream<_CharT, _Traits>& operator>>(
        basic_istream<_CharT, _Traits>& _Is, _Time_parse_iomanip_c_str<_CharT, _Traits, _Alloc, _Parsable>&& _Tpi) {
        from_stream(_Is, _Tpi._Fmt, _Tpi._Tp, _Tpi._Abbrev, _Tpi._Offset); 
        return _Is;
    }

    template <class _CharT, class _Traits, class _Alloc, class _Parsable>
    basic_istream<_CharT, _Traits>& operator>>(
        basic_istream<_CharT, _Traits>& _Is, _Time_parse_iomanip<_CharT, _Traits, _Alloc, _Parsable>&& _Tpi) {
        from_stream(_Is, _Tpi._Fmt.c_str(), _Tpi._Tp, _Tpi._Abbrev, _Tpi._Offset); 
        return _Is;
    }

#line 5238 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"
} 


template <class _CharT>
[[nodiscard]] constexpr const _CharT* _Choose_literal(const char* const _Str, const wchar_t* const _WStr) noexcept {
    if constexpr (is_same_v<_CharT, char>) {
        return _Str;
    } else {
        return _WStr;
    }
}


template <class _Ty, class _CharT>
concept _Chrono_parse_spec_callbacks = _Parse_align_callbacks<_Ty, _CharT>
                                        && _Parse_width_callbacks<_Ty, _CharT>
                                        && _Parse_precision_callbacks<_Ty, _CharT>
                                        && _Width_adapter_callbacks<_Ty, _CharT>
                                        && _Precision_adapter_callbacks<_Ty, _CharT>
                                        && requires(_Ty _At, basic_string_view<_CharT> _Sv, _Fmt_align _Aln) {
    { _At._On_conversion_spec(char{}, _CharT{}) } -> same_as<void>;
    { _At._On_lit_char(_CharT{}) } -> same_as<void>;
};


template <class _Ty>
concept _Has_ok = requires(_Ty _At) {
    { _At.ok() } -> same_as<bool>;
};


template <class _CharT>
struct _Chrono_spec {
    _CharT _Lit_char = _CharT{'\0'}; 
    char _Modifier   = '\0'; 
    char _Type       = '\0';
};

template <class _CharT>
struct _Chrono_format_specs {
    int _Width                   = 0;
    int _Precision               = -1;
    int _Dynamic_width_index     = -1;
    int _Dynamic_precision_index = -1;
    _Fmt_align _Alignment        = _Fmt_align::_None;
    uint8_t _Fill_length         = 1;
    bool _Localized              = false;
    
    _CharT _Fill[4 / sizeof(_CharT)] = {_CharT{' '}};
    
    vector<_Chrono_spec<_CharT>> _Chrono_specs_list;
};


template <class _CharT, class _ParseContext>
class _Chrono_specs_setter {
public:
    constexpr explicit _Chrono_specs_setter(_Chrono_format_specs<_CharT>& _Specs_, _ParseContext& _Parse_ctx_)
        : _Specs(_Specs_), _Parse_ctx(_Parse_ctx_) {}

    
    constexpr void _On_align(_Fmt_align _Aln) {
        _Specs._Alignment = _Aln;
    }

    
    constexpr void _On_fill(basic_string_view<_CharT> _Sv) {
        if (_Sv.size() > ::std:: size(_Specs._Fill)) {
            throw format_error("Invalid fill (too long).");
        }

        const auto _Pos = ::std:: _Copy_unchecked(_Sv._Unchecked_begin(), _Sv._Unchecked_end(), _Specs._Fill);
        ::std:: fill(_Pos, ::std:: end(_Specs._Fill), _CharT{});
        _Specs._Fill_length = static_cast<uint8_t>(_Sv.size());
    }

    constexpr void _On_width(int _Width) {
        _Specs._Width = _Width;
    }

    constexpr void _On_precision(int _Prec) {
        _Specs._Precision = _Prec;
    }

    constexpr void _On_dynamic_width(const size_t _Arg_id) {
        _Parse_ctx.check_arg_id(_Arg_id);
        _Specs._Dynamic_width_index = _Verify_dynamic_arg_index_in_range(_Arg_id);
    }

    constexpr void _On_dynamic_width(_Auto_id_tag) {
        _Specs._Dynamic_width_index = _Verify_dynamic_arg_index_in_range(_Parse_ctx.next_arg_id());
    }

    constexpr void _On_dynamic_precision(const size_t _Arg_id) {
        _Parse_ctx.check_arg_id(_Arg_id);
        _Specs._Dynamic_precision_index = _Verify_dynamic_arg_index_in_range(_Arg_id);
    }

    constexpr void _On_dynamic_precision(_Auto_id_tag) {
        _Specs._Dynamic_precision_index = _Verify_dynamic_arg_index_in_range(_Parse_ctx.next_arg_id());
    }

    constexpr void _On_localized() {
        _Specs._Localized = true;
    }

    constexpr void _On_conversion_spec(char _Modifier, _CharT _Type) {
        
        if (_Modifier != '\0' && _Modifier != 'E' && _Modifier != 'O') {
            throw format_error("Invalid modifier specification.");
        }

        if (_Type < 0 || _Type > (numeric_limits<signed char>::max)()) {
            throw format_error("Invalid type specification.");
        }

        _Chrono_spec<_CharT> _Conv_spec{._Modifier = _Modifier, ._Type = static_cast<char>(_Type)};
        _Specs._Chrono_specs_list.push_back(_Conv_spec);
    }

    constexpr void _On_lit_char(_CharT _Lit_ch) {
        _Chrono_spec<_CharT> _Lit_char_spec{._Lit_char = _Lit_ch};
        _Specs._Chrono_specs_list.push_back(_Lit_char_spec);
    }

private:
    _Chrono_format_specs<_CharT>& _Specs;
    _ParseContext& _Parse_ctx;

    [[nodiscard]] static constexpr int _Verify_dynamic_arg_index_in_range(const size_t _Idx) {
        if (_Idx > static_cast<size_t>((numeric_limits<int>::max)())) {
            throw format_error("Dynamic width or precision index too large.");
        }

        return static_cast<int>(_Idx);
    }
};


template <class _CharT, _Chrono_parse_spec_callbacks<_CharT> _Callbacks_type>
[[nodiscard]] constexpr const _CharT* _Parse_conversion_specs(
    const _CharT* _Begin, const _CharT* _End, _Callbacks_type&& _Callbacks) {
    if (_Begin == _End || *_Begin == '}') {
        throw format_error("Invalid format string.");
    }

    char _Mod  = '\0';
    _CharT _Ch = *_Begin;

    if (_Ch == 'E' || _Ch == 'O') { 
        _Mod = static_cast<char>(_Ch);
        ++_Begin;
        if (_Begin == _End || *_Begin == '}') {
            throw format_error("Invalid format string - missing type after modifier.");
        }
    }

    _CharT _Type = *_Begin;
    _Callbacks._On_conversion_spec(_Mod, _Type);

    return ++_Begin;
}

template <class _CharT, _Chrono_parse_spec_callbacks<_CharT> _Callbacks_type>
[[nodiscard]] constexpr const _CharT* _Parse_chrono_format_specs(
    const _CharT* _Begin, const _CharT* _End, _Callbacks_type&& _Callbacks) {
    if (_Begin == _End || *_Begin == '}') {
        return _Begin;
    }

    _Begin = _Parse_align(_Begin, _End, _Callbacks);
    if (_Begin == _End) {
        return _Begin;
    }

    _Begin = _Parse_width(_Begin, _End, _Callbacks);
    if (_Begin == _End) {
        return _Begin;
    }

    if (*_Begin == '.') {
        _Begin = _Parse_precision(_Begin, _End, _Callbacks);
        if (_Begin == _End) {
            return _Begin;
        }
    }

    if (*_Begin == 'L') {
        _Callbacks._On_localized();
        ++_Begin;
        if (_Begin == _End) {
            return _Begin;
        }
    }

    if (*_Begin != '}' && *_Begin != '%') {
        throw format_error("Invalid format string - chrono-specs must begin with conversion-spec");
    }

    
    while (_Begin != _End && *_Begin != '}') {
        if (*_Begin == '%') { 
            if (++_Begin == _End) {
                throw format_error("Invalid format string - missing type after %");
            }

            switch (*_Begin) {
            case 'n':
                _Callbacks._On_lit_char('\n');
                ++_Begin;
                break;
            case 't':
                _Callbacks._On_lit_char('\t');
                ++_Begin;
                break;
            case '%':
                _Callbacks._On_lit_char('%');
                ++_Begin;
                break;
            default: 
                _Begin = _Parse_conversion_specs(_Begin, _End, _Callbacks);
                break;
            }
        } else { 
            _Callbacks._On_lit_char(*_Begin);
            ++_Begin;
        }
    }

    return _Begin;
}

namespace chrono {
    template <class _Duration>
    struct _Local_time_format_t {
        local_time<_Duration> _Time;
        const string* _Abbrev      = nullptr;
        const seconds* _Offset_sec = nullptr;
    };

    template <class _Duration>
    [[nodiscard]] _Local_time_format_t<_Duration> local_time_format(const local_time<_Duration> _Time,
        const string* const _Abbrev = nullptr, const seconds* const _Offset_sec = nullptr) {
        return {_Time, _Abbrev, _Offset_sec};
    }

    
    template <class _CharT, class _Traits, class _Ty>
    void _Write_seconds(basic_ostream<_CharT, _Traits>&, const _Ty&) {
        ;
    }

    template <unsigned int _Fractional_width, class _CharT, class _Traits, class _Precision>
    void _Write_fractional_seconds(
        basic_ostream<_CharT, _Traits>& _Os, const seconds& _Seconds, const _Precision& _Subseconds) {
        _Os << ::std:: format((_Choose_literal<_CharT>("{:02}", L"{:02}")), _Seconds.count());
        if constexpr (_Fractional_width > 0) {
            _Os << ::std:: use_facet<numpunct<_CharT>>(_Os.getloc()).decimal_point();
            if constexpr (treat_as_floating_point_v<typename _Precision::rep>) {
                _Os << ::std:: format(
                    (_Choose_literal<_CharT>("{:0{}.0f}", L"{:0{}.0f}")), ::std:: floor(_Subseconds.count()), _Fractional_width);
            } else {
                _Os << ::std:: format((_Choose_literal<_CharT>("{:0{}}", L"{:0{}}")), _Subseconds.count(), _Fractional_width);
            }
        }
    }

    template <class _CharT, class _Traits, class _Duration>
    void _Write_seconds(basic_ostream<_CharT, _Traits>& _Os, const hh_mm_ss<_Duration>& _Val) {
        _Write_fractional_seconds<hh_mm_ss<_Duration>::fractional_width>(_Os, _Val.seconds(), _Val.subseconds());
    }

    template <class _CharT, class _Traits, class _Clock, class _Duration>
    void _Write_seconds(basic_ostream<_CharT, _Traits>& _Os, const time_point<_Clock, _Duration>& _Val) {
        if constexpr (is_same_v<_Clock, utc_clock>) {
            const auto _Lsi = ::std::chrono:: get_leap_second_info(_Val);
            const auto _Dp =
                ::std::chrono:: floor<days>(_Val - _Lsi.elapsed) + _Lsi.elapsed - seconds{_Lsi.is_leap_second ? 1 : 0};
            const hh_mm_ss _Hms{_Val - _Dp};
            constexpr auto _Fractional_width = decltype(_Hms)::fractional_width;
            if (_Lsi.is_leap_second) {
                _Write_fractional_seconds<_Fractional_width>(_Os, _Hms.seconds() + seconds{60}, _Hms.subseconds());
            } else {
                _Write_fractional_seconds<_Fractional_width>(_Os, _Hms.seconds(), _Hms.subseconds());
            }
        } else {
            const auto _Dp = ::std::chrono:: floor<days>(_Val);
            _Write_seconds(_Os, hh_mm_ss{_Val - _Dp});
        }
    }

    template <class _CharT, class _Traits, class _Duration>
    void _Write_seconds(basic_ostream<_CharT, _Traits>& _Os, const _Local_time_format_t<_Duration>& _Val) {
        _Write_seconds(_Os, _Val._Time);
    }

    template <class _CharT, class _Traits, class _Rep, class _Period>
    void _Write_seconds(basic_ostream<_CharT, _Traits>& _Os, const duration<_Rep, _Period>& _Val) {
        const auto _Dp = ::std::chrono:: duration_cast<days>(_Val);
        _Write_seconds(_Os, hh_mm_ss{_Val - _Dp});
    }

    template <class _Ty>
    [[nodiscard]] tm _Fill_tm(const _Ty& _Val) {
        unsigned int _Day   = 0;
        unsigned int _Month = 0;
        int _Year           = 0;
        int _Yearday        = 0;
        int _Weekday        = 0;
        int _Hours          = 0;
        int _Minutes        = 0;
        int _Seconds        = 0;

        if constexpr (_Is_specialization_v<_Ty, duration>) {
            const auto _Dp = ::std::chrono:: duration_cast<days>(_Val);
            return _Fill_tm(hh_mm_ss{_Val - _Dp});
        } else if constexpr (_Is_specialization_v<_Ty, _Local_time_format_t>) {
            return _Fill_tm(_Val._Time);
        } else if constexpr (is_same_v<_Ty, day>) {
            _Day = static_cast<unsigned int>(_Val);
        } else if constexpr (is_same_v<_Ty, month>) {
            _Month = static_cast<unsigned int>(_Val);
        } else if constexpr (is_same_v<_Ty, year>) {
            _Year = static_cast<int>(_Val);
        } else if constexpr (is_same_v<_Ty, weekday>) {
            _Weekday = static_cast<int>(_Val.c_encoding());
        } else if constexpr (_Is_any_of_v<_Ty, weekday_indexed, weekday_last>) {
            _Weekday = static_cast<int>(_Val.weekday().c_encoding());
        } else if constexpr (is_same_v<_Ty, month_day>) {
            _Day   = static_cast<unsigned int>(_Val.day());
            _Month = static_cast<unsigned int>(_Val.month());
            if (_Val.month() == January) {
                _Yearday = static_cast<int>(_Day) - 1;
            } else if (_Val.month() == February) {
                _Yearday = 31 + static_cast<int>(_Day) - 1;
            }
        } else if constexpr (is_same_v<_Ty, month_day_last>) {
            _Month = static_cast<unsigned int>(_Val.month());
            _Day   = static_cast<unsigned int>(_Last_day_table[(_Month - 1) & 0xF]);
            if (_Val.month() == January) {
                _Yearday = 30;
            }
        } else if constexpr (is_same_v<_Ty, month_weekday>) {
            _Month   = static_cast<unsigned int>(_Val.month());
            _Weekday = static_cast<int>(_Val.weekday_indexed().weekday().c_encoding());
        } else if constexpr (is_same_v<_Ty, month_weekday_last>) {
            _Month   = static_cast<unsigned int>(_Val.month());
            _Weekday = static_cast<int>(_Val.weekday_last().weekday().c_encoding());
        } else if constexpr (is_same_v<_Ty, year_month>) {
            _Month = static_cast<unsigned int>(_Val.month());
            _Year  = static_cast<int>(_Val.year());
        } else if constexpr (_Is_any_of_v<_Ty, year_month_day, year_month_day_last>) {
            _Day   = static_cast<unsigned int>(_Val.day());
            _Month = static_cast<unsigned int>(_Val.month());
            _Year  = static_cast<int>(_Val.year());
            if (_Val.ok()) {
                const year_month_day& _Ymd = _Val;
                _Weekday                   = _Ymd._Calculate_weekday();
                _Yearday = (static_cast<sys_days>(_Val) - static_cast<sys_days>(_Val.year() / January / 1)).count();
            }
        } else if constexpr (_Is_any_of_v<_Ty, year_month_weekday, year_month_weekday_last>) {
            auto _Tm    = _Fill_tm(year_month_day{_Val});
            _Tm.tm_wday = static_cast<int>(_Val.weekday().c_encoding());
            return _Tm;
        } else if constexpr (_Is_specialization_v<_Ty, hh_mm_ss>) {
            _Hours   = _Val.hours().count();
            _Minutes = _Val.minutes().count();
            _Seconds = static_cast<int>(_Val.seconds().count());
        } else if constexpr (_Is_any_of_v<_Ty, sys_info, local_info>) {
            return {}; 
        } else if constexpr (_Is_specialization_v<_Ty, time_point>) {
            const auto _Dp = ::std::chrono:: floor<days>(_Val);
            const year_month_day _Ymd{_Dp};
            const hh_mm_ss _Time{_Val - _Dp};
            const auto _Hms = _Fill_tm(_Time);
            auto _Tm        = _Fill_tm(_Ymd);
            _Tm.tm_sec      = _Hms.tm_sec;
            _Tm.tm_min      = _Hms.tm_min;
            _Tm.tm_hour     = _Hms.tm_hour;
            return _Tm;
        }

        tm _Time;
        _Time.tm_sec  = _Seconds;
        _Time.tm_min  = _Minutes;
        _Time.tm_hour = _Hours;
        _Time.tm_mday = static_cast<int>(_Day);
        _Time.tm_mon  = static_cast<int>(_Month) - 1;
        _Time.tm_year = _Year - 1900;
        _Time.tm_yday = _Yearday;
        _Time.tm_wday = _Weekday;
        return _Time;
    }

    template <class _CharT, class _Traits>
    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const day& _Val) {
        return _Os << (_Val.ok() ? ::std:: format((_Choose_literal<_CharT>("{:%d}", L"{:%d}")), _Val)
                                 : ::std:: format((_Choose_literal<_CharT>("{:%d} is not a valid day", L"{:%d} is not a valid day")), _Val));
    }

    template <class _CharT, class _Traits>
    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const month& _Val) {
        return _Os << (_Val.ok() ? ::std:: format(_Os.getloc(), (_Choose_literal<_CharT>("{:L%b}", L"{:L%b}")), _Val)
                                 : ::std:: format(_Os.getloc(), (_Choose_literal<_CharT>("{} is not a valid month", L"{} is not a valid month")),
                                     static_cast<unsigned int>(_Val)));
    }

    template <class _CharT, class _Traits>
    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const year& _Val) {
        return _Os << (_Val.ok() ? ::std:: format((_Choose_literal<_CharT>("{:%Y}", L"{:%Y}")), _Val)
                                 : ::std:: format((_Choose_literal<_CharT>("{:%Y} is not a valid year", L"{:%Y} is not a valid year")), _Val));
    }

    template <class _CharT, class _Traits>
    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const weekday& _Val) {
        return _Os << (_Val.ok() ? ::std:: format(_Os.getloc(), (_Choose_literal<_CharT>("{:L%a}", L"{:L%a}")), _Val)
                                 : ::std:: format(_Os.getloc(), (_Choose_literal<_CharT>("{} is not a valid weekday", L"{} is not a valid weekday")),
                                     _Val.c_encoding()));
    }

    template <class _CharT, class _Traits>
    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const weekday_indexed& _Val) {
        const auto _Idx = _Val.index();
        return _Os << (_Idx >= 1 && _Idx <= 5
                           ? ::std:: format(_Os.getloc(), (_Choose_literal<_CharT>("{:L}[{}]", L"{:L}[{}]")), _Val.weekday(), _Idx)
                           : ::std:: format(_Os.getloc(), (_Choose_literal<_CharT>("{:L}[{} is not a valid index]", L"{:L}[{} is not a valid index]")),
                               _Val.weekday(), _Idx));
    }

    template <class _CharT, class _Traits>
    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const weekday_last& _Val) {
        return _Os << ::std:: format(_Os.getloc(), (_Choose_literal<_CharT>("{:L}[last]", L"{:L}[last]")), _Val.weekday());
    }

    template <class _CharT, class _Traits>
    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const month_day& _Val) {
        return _Os << ::std:: format(_Os.getloc(), (_Choose_literal<_CharT>("{:L}/{}", L"{:L}/{}")), _Val.month(), _Val.day());
    }

    template <class _CharT, class _Traits>
    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const month_day_last& _Val) {
        return _Os << ::std:: format(_Os.getloc(), (_Choose_literal<_CharT>("{:L}/last", L"{:L}/last")), _Val.month());
    }

    template <class _CharT, class _Traits>
    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const month_weekday& _Val) {
        return _Os << ::std:: format(
                   _Os.getloc(), (_Choose_literal<_CharT>("{:L}/{:L}", L"{:L}/{:L}")), _Val.month(), _Val.weekday_indexed());
    }

    template <class _CharT, class _Traits>
    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const month_weekday_last& _Val) {
        return _Os << ::std:: format(
                   _Os.getloc(), (_Choose_literal<_CharT>("{:L}/{:L}", L"{:L}/{:L}")), _Val.month(), _Val.weekday_last());
    }

    template <class _CharT, class _Traits>
    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const year_month& _Val) {
        return _Os << ::std:: format(_Os.getloc(), (_Choose_literal<_CharT>("{}/{:L}", L"{}/{:L}")), _Val.year(), _Val.month());
    }

    template <class _CharT, class _Traits>
    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const year_month_day& _Val) {
        return _Os << (_Val.ok() ? ::std:: format((_Choose_literal<_CharT>("{:%F}", L"{:%F}")), _Val)
                                 : ::std:: format((_Choose_literal<_CharT>("{:%F} is not a valid date", L"{:%F} is not a valid date")), _Val));
    }

    template <class _CharT, class _Traits>
    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const year_month_day_last& _Val) {
        return _Os << ::std:: format(
                   _Os.getloc(), (_Choose_literal<_CharT>("{}/{:L}", L"{}/{:L}")), _Val.year(), _Val.month_day_last());
    }

    template <class _CharT, class _Traits>
    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const year_month_weekday& _Val) {
        return _Os << ::std:: format(_Os.getloc(), (_Choose_literal<_CharT>("{}/{:L}/{:L}", L"{}/{:L}/{:L}")), _Val.year(), _Val.month(),
                   _Val.weekday_indexed());
    }

    template <class _CharT, class _Traits>
    basic_ostream<_CharT, _Traits>& operator<<(
        basic_ostream<_CharT, _Traits>& _Os, const year_month_weekday_last& _Val) {
        return _Os << ::std:: format(_Os.getloc(), (_Choose_literal<_CharT>("{}/{:L}/{:L}", L"{}/{:L}/{:L}")), _Val.year(), _Val.month(),
                   _Val.weekday_last());
    }

    template <class _CharT, class _Traits, class _Duration>
    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const hh_mm_ss<_Duration>& _Val) {
        return _Os << ::std:: format(_Os.getloc(), (_Choose_literal<_CharT>("{:L%T}", L"{:L%T}")), _Val);
    }

#pragma warning(push)
#pragma warning(disable : 4365) 
    template <class _CharT>
    [[nodiscard]] decltype(auto) _Widen_string(const string& _Str) {
        if constexpr (is_same_v<_CharT, char>) {
            return _Str;
        } else {
            return wstring{_Str.begin(), _Str.end()}; 
        }
    }
#pragma warning(pop)

    template <class _CharT, class _Traits>
    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const sys_info& _Val) {
        return _Os << ::std:: format(_Os.getloc(),
                   (_Choose_literal<_CharT>("begin: {}, end: {}, offset: {}, save: {}, abbrev: {}", L"begin: {}, end: {}, offset: {}, save: {}, abbrev: {}")), 
                   _Val.begin, _Val.end, _Val.offset, _Val.save, _Widen_string<_CharT>(_Val.abbrev));
    }

    template <class _CharT, class _Traits>
    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const local_info& _Val) {
        switch (_Val.result) {
        case local_info::unique:
            return _Os << ::std:: format(_Os.getloc(), 
                       (_Choose_literal<_CharT>("result: unique, first: ({})", L"result: unique, first: ({})")), 
                       _Val.first);
        case local_info::nonexistent:
            return _Os << ::std:: format(_Os.getloc(),
                       (_Choose_literal<_CharT>("result: nonexistent, first: ({}), second: ({})", L"result: nonexistent, first: ({}), second: ({})")), 
                       _Val.first, _Val.second);
        case local_info::ambiguous:
            return _Os << ::std:: format(_Os.getloc(),
                       (_Choose_literal<_CharT>("result: ambiguous, first: ({}), second: ({})", L"result: ambiguous, first: ({}), second: ({})")), 
                       _Val.first, _Val.second);
        default:
            return _Os << ::std:: format(_Os.getloc(), 
                       (_Choose_literal<_CharT>("result: {}, first: ({}), second: ({})", L"result: {}, first: ({}), second: ({})")), 
                       _Val.result, _Val.first, _Val.second);
        }
    }

    template <class _CharT, class _Traits, class _Duration>
        
        requires (!treat_as_floating_point_v<typename _Duration::rep> && _Duration{1} < days{1})
    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const sys_time<_Duration>& _Val) {
        
        return _Os << ::std:: format(_Os.getloc(), (_Choose_literal<_CharT>("{:L%F %T}", L"{:L%F %T}")), _Val);
    }

    template <class _CharT, class _Traits>
    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const sys_days& _Val) {
        return _Os << year_month_day{_Val};
    }

    template <class _CharT, class _Traits, class _Duration>
    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const utc_time<_Duration>& _Val) {
        return _Os << ::std:: format(_Os.getloc(), (_Choose_literal<_CharT>("{:L%F %T}", L"{:L%F %T}")), _Val);
    }

    template <class _CharT, class _Traits, class _Duration>
    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const tai_time<_Duration>& _Val) {
        return _Os << ::std:: format(_Os.getloc(), (_Choose_literal<_CharT>("{:L%F %T}", L"{:L%F %T}")), _Val);
    }

    template <class _CharT, class _Traits, class _Duration>
    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const gps_time<_Duration>& _Val) {
        return _Os << ::std:: format(_Os.getloc(), (_Choose_literal<_CharT>("{:L%F %T}", L"{:L%F %T}")), _Val);
    }

    template <class _CharT, class _Traits, class _Duration>
    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const file_time<_Duration>& _Val) {
        return _Os << ::std:: format(_Os.getloc(), (_Choose_literal<_CharT>("{:L%F %T}", L"{:L%F %T}")), _Val);
    }

    template <class _CharT, class _Traits, class _Duration>
    basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& _Os, const local_time<_Duration>& _Val) {
        return _Os << sys_time<_Duration>{_Val.time_since_epoch()};
    }

    template <class _CharT, class _Traits, class _Duration>
    basic_ostream<_CharT, _Traits>& operator<<(
        basic_ostream<_CharT, _Traits>& _Os, const _Local_time_format_t<_Duration>& _Val) {
        
        
        return _Os << ::std:: format(_Os.getloc(), (_Choose_literal<_CharT>("{:L%F %T %Z}", L"{:L%F %T %Z}")), _Val);
    }

    template <class _CharT, class _Traits, class _Duration, class _TimeZonePtr>
    basic_ostream<_CharT, _Traits>& operator<<(
        basic_ostream<_CharT, _Traits>& _Os, const zoned_time<_Duration, _TimeZonePtr>& _Val) {
        const auto _Info = _Val.get_info();
        return _Os << _Local_time_format_t<_Duration>{_Val.get_local_time(), &_Info.abbrev};
    }

    template <class _CharT>
    struct _Chrono_formatter {
        _Chrono_formatter() = default;

        constexpr explicit _Chrono_formatter(const basic_string_view<_CharT> _Time_zone_abbreviation_)
            : _Time_zone_abbreviation{_Time_zone_abbreviation_} {}

        template <class _Ty>
        [[nodiscard]] constexpr auto _Parse(basic_format_parse_context<_CharT>& _Parse_ctx) {
            _Chrono_specs_setter<_CharT, basic_format_parse_context<_CharT>> _Callback{_Specs, _Parse_ctx};
            const auto _It =
                _Parse_chrono_format_specs(_Parse_ctx._Unchecked_begin(), _Parse_ctx._Unchecked_end(), _Callback);
            const auto _Res_iter = _Parse_ctx.begin() + (_It - _Parse_ctx._Unchecked_begin());

            if (_It != _Parse_ctx._Unchecked_end() && *_It != '}') {
                throw format_error("Missing '}' in format string.");
            }

            if constexpr (_Is_specialization_v<_Ty, duration>) {
                if constexpr (!treat_as_floating_point_v<typename _Ty::rep>) {
                    if (_Specs._Precision != -1) {
                        throw format_error("Precision specification invalid for chrono::duration type with " "integral representation type, see N4885 [time.format]/1.");
#line 5851 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"
                    }
                }
            } else {
                if (_Specs._Precision != -1) {
                    throw format_error("Precision specification invalid for non-chrono::duration type, " "see N4885 [time.format]/1.");
#line 5857 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"
                }
            }

            for (const auto& _Spec : _Specs._Chrono_specs_list) {
                if (_Spec._Type != '\0' && !_Is_valid_type<_Ty>(_Spec._Type)) {
                    throw format_error("Invalid type.");
                }
                _Check_modifier(_Spec._Type, _Spec._Modifier);
            }

            return _Res_iter;
        }

        enum _Allowed_bit : uint8_t { _E_mod = 1, _O_mod = 2, _EO_mod = _E_mod | _O_mod };

        struct _Table_entry {
            char _Type;
            _Allowed_bit _Allowed;
        };

        static constexpr _Table_entry _Table[] = {
            {'c', _E_mod},
            {'C', _E_mod},
            {'d', _O_mod},
            {'e', _O_mod},
            {'H', _O_mod},
            {'I', _O_mod},
            {'m', _O_mod},
            {'M', _O_mod},
            {'S', _O_mod},
            {'u', _O_mod},
            {'U', _O_mod},
            {'V', _O_mod},
            {'w', _O_mod},
            {'W', _O_mod},
            {'x', _E_mod},
            {'X', _E_mod},
            {'y', _EO_mod},
            {'Y', _E_mod},
            {'z', _EO_mod},
        };

        static constexpr void _Check_modifier(const char _Type, const char _Modifier) {
            if (_Modifier == '\0') {
                return;
            }

            const _Allowed_bit _Mod = _Modifier == 'E' ? _E_mod : _O_mod;

            if (auto _It = ::std::ranges:: find(_Table, _Type, &_Table_entry::_Type); _It != ::std:: end(_Table)) {
                if (_It->_Allowed & _Mod) {
                    return;
                }
            }

            throw format_error("Incompatible modifier for type");
        }

        template <class _Ty>
        [[nodiscard]] static constexpr bool _Is_valid_type(const char _Type) noexcept {
            if constexpr (_Is_specialization_v<_Ty, duration>) {
                return _Type == 'j' || _Type == 'q' || _Type == 'Q' || _Is_valid_type<hh_mm_ss<seconds>>(_Type);
            } else if constexpr (is_same_v<_Ty, day>) {
                return _Type == 'd' || _Type == 'e';
            } else if constexpr (is_same_v<_Ty, month>) {
                return _Type == 'b' || _Type == 'B' || _Type == 'h' || _Type == 'm';
            } else if constexpr (is_same_v<_Ty, year>) {
                return _Type == 'Y' || _Type == 'y' || _Type == 'C';
            } else if constexpr (_Is_any_of_v<_Ty, weekday, weekday_indexed, weekday_last>) {
                return _Type == 'a' || _Type == 'A' || _Type == 'u' || _Type == 'w';
            } else if constexpr (_Is_any_of_v<_Ty, month_day, month_day_last>) {
                return _Type == 'j' || _Is_valid_type<month>(_Type) || _Is_valid_type<day>(_Type);
            } else if constexpr (_Is_any_of_v<_Ty, month_weekday, month_weekday_last>) {
                return _Is_valid_type<month>(_Type) || _Is_valid_type<weekday>(_Type);
            } else if constexpr (is_same_v<_Ty, year_month>) {
                return _Type == 'g' || _Type == 'G' || _Is_valid_type<year>(_Type) || _Is_valid_type<month>(_Type);
            } else if constexpr (_Is_any_of_v<_Ty, year_month_day, year_month_day_last, year_month_weekday,
                                     year_month_weekday_last>) {
                return _Type == 'D' || _Type == 'F' || _Type == 'g' || _Type == 'G' || _Type == 'j' || _Type == 'U'
                    || _Type == 'V' || _Type == 'W' || _Is_valid_type<year>(_Type) || _Is_valid_type<month>(_Type)
                    || _Is_valid_type<day>(_Type) || _Is_valid_type<weekday>(_Type);
            } else if constexpr (_Is_specialization_v<_Ty, hh_mm_ss>) {
                return _Type == 'H' || _Type == 'I' || _Type == 'M' || _Type == 'S' || _Type == 'r' || _Type == 'R'
                    || _Type == 'T' || _Type == 'p';
            } else if constexpr (_Is_any_of_v<_Ty, sys_info, local_info>) {
                return _Type == 'z' || _Type == 'Z';
            } else if constexpr (_Is_specialization_v<_Ty, time_point>) {
                if constexpr (!is_same_v<typename _Ty::clock, local_t>) {
                    if (_Type == 'z' || _Type == 'Z') {
                        return true;
                    }
                }
                return _Type == 'c' || _Type == 'x' || _Type == 'X' || _Is_valid_type<year_month_day>(_Type)
                    || _Is_valid_type<hh_mm_ss<seconds>>(_Type);
            } else if constexpr (_Is_specialization_v<_Ty, _Local_time_format_t>) {
                return _Type == 'z' || _Type == 'Z' || _Is_valid_type<decltype(_Ty::_Time)>(_Type);
            } else {
                static_assert(_Always_false<_Ty>, "should be unreachable");
            }
        }

        template <class _FormatContext, class _Ty>
        [[nodiscard]] auto _Write(_FormatContext& _FormatCtx, const _Ty& _Val, const tm& _Time) const {
            basic_ostringstream<_CharT> _Stream;

            _Stream.imbue(_Specs._Localized ? _FormatCtx.locale() : locale::classic());
            if (_Specs._Chrono_specs_list.empty()) {
                _Stream << _Val; 
            } else {
                if constexpr (_Is_specialization_v<_Ty, hh_mm_ss>) {
                    if (_Val.is_negative()) {
                        _Stream << _CharT{'-'};
                    }
                } else if constexpr (_Is_specialization_v<_Ty, duration>) {
                    if (_Val < _Ty::zero()) {
                        _Stream << _CharT{'-'};
                    }
                }

                for (const auto& _Spec : _Specs._Chrono_specs_list) {
                    if (_Spec._Lit_char != _CharT{'\0'}) {
                        _Stream << _Spec._Lit_char;
                        continue;
                    }

                    
                    if (_Custom_write(_Stream, _Spec, _Time, _Val)) {
                        continue;
                    }

                    _Validate_specifiers(_Spec, _Val);

                    _CharT _Fmt_str[4];
                    _Stream << ::std:: put_time<_CharT>(&_Time, _Fmt_string(_Spec, _Fmt_str));
                }
            }

            int _Estimated_width = -1;
            (void) _Measure_string_prefix(_Stream.view(), _Estimated_width);
            return _Write_aligned(::std:: move(_FormatCtx.out()), _Estimated_width, _Specs, _Fmt_align::_Left,
                [&](auto _Out) { return _Fmt_write(::std:: move(_Out), _Stream.view()); });
        }

        
        template <class _Ty>
        bool _Custom_write(
            basic_ostream<_CharT>& _Os, const _Chrono_spec<_CharT>& _Spec, const tm& _Time, const _Ty& _Val) const {
            if constexpr (is_same_v<_Ty, local_info>) {
                if (_Val.result != local_info::unique) {
                    throw format_error("Cannot print non-unique local_info");
                }
            }

            const auto _Year         = _Time.tm_year + 1900;
            const auto _Month        = _Time.tm_mon + 1;
            const bool _Has_modifier = _Spec._Modifier != '\0';
            switch (_Spec._Type) {
            case 'd': 
            case 'e':
                
                if constexpr (is_same_v<_Ty, month_day_last>) {
                    if (_Val.month() == February) {
                        throw format_error("Cannot print the last day of February without a year");
                    }

                    if (!_Val.ok()) {
                        return false;
                    }
                }

                if (_Has_modifier) {
                    return false;
                }

                if (_Time.tm_mday < 10) {
                    _Os << (_Spec._Type == 'd' ? _CharT{'0'} : _CharT{' '});
                }
                _Os << _Time.tm_mday;
                return true;
            case 'g':
            case 'G':
                if constexpr (is_same_v<_Ty, year_month>) {
                    if (_Val.month() == January || _Val.month() == December) {
                        throw format_error( "The ISO week-based year for a year_month of January or December is ambiguous.");
#line 6046 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"
                    }

                    if (!_Val.ok()) {
                        throw format_error("The ISO week-based year for an out-of-bounds year_month is ambiguous.");
                    }

                    const char _Gregorian_type = _Spec._Type == 'g' ? 'y' : 'Y';
                    _CharT _Fmt_str[4];
                    _Os << ::std:: put_time(&_Time, _Fmt_string({._Type = _Gregorian_type}, _Fmt_str));
                    return true;
                }

                return false;
            case 'r':
                
                
                if (_Os.getloc() == locale::classic()) {
                    _Os << ::std:: put_time(&_Time, (_Choose_literal<_CharT>("%I:%M:%S %p", L"%I:%M:%S %p")));
                    return true;
                }

                return false;
            case 'j':
                if constexpr (_Is_specialization_v<_Ty, duration>) {
                    _Os << ::std:: abs(::std::chrono:: duration_cast<days>(_Val).count());
                    return true;
                }
                return false;
            case 'q':
                if constexpr (_Is_specialization_v<_Ty, duration>) {
                    _Write_unit_suffix<typename _Ty::period>(_Os);
                }
                return true;
            case 'Q':
                if constexpr (_Is_specialization_v<_Ty, duration>) {
                    _Os << ::std:: abs(_Val.count());
                }
                return true;
            case 'm': 
                if (_Has_modifier) {
                    return false;
                }

                if (_Month < 10) {
                    _Os << _CharT{'0'};
                }
                _Os << _Month;
                return true;
            case 'Y': 
                if (_Has_modifier) {
                    return false;
                }

                if (_Year < 0) {
                    _Os << _CharT{'-'};
                }
                _Os << ::std:: format((_Choose_literal<_CharT>("{:04}", L"{:04}")), ::std:: abs(_Year));
                return true;
            case 'y': 
                if (_Has_modifier) {
                    return false;
                }
                _Os << ::std:: format(
                    (_Choose_literal<_CharT>("{:02}", L"{:02}")), _Time_parse_fields::_Decompose_year(_Year).second);
                return true;
            case 'C': 
                if (_Has_modifier) {
                    return false;
                }

                if (_Year < 0) {
                    _Os << _CharT{'-'};
                }
                _Os << ::std:: format((_Choose_literal<_CharT>("{:02}", L"{:02}")),
                    ::std:: abs(_Time_parse_fields::_Decompose_year(_Year).first) / 100);
                return true;
            case 'F': 
                _Custom_write(_Os, {._Type = 'Y'}, _Time, _Val);
                _Os << _CharT{'-'};
                _Custom_write(_Os, {._Type = 'm'}, _Time, _Val);
                _Os << _CharT{'-'};
                _Custom_write(_Os, {._Type = 'd'}, _Time, _Val);
                return true;
            case 'D': 
                _Custom_write(_Os, {._Type = 'm'}, _Time, _Val);
                _Os << _CharT{'/'};
                _Custom_write(_Os, {._Type = 'd'}, _Time, _Val);
                _Os << _CharT{'/'};
                _Custom_write(_Os, {._Type = 'y'}, _Time, _Val);
                return true;
            case 'T':
                
                _Validate_specifiers({._Type = 'H'}, _Val);
                _Os << ::std:: put_time(&_Time, (_Choose_literal<_CharT>("%H:%M:", L"%H:%M:")));
                [[fallthrough]];
            case 'S':
                if (_Has_modifier) {
                    return false;
                }
                _Write_seconds(_Os, _Val);
                return true;
            case 'Z':
                if constexpr (is_same_v<_Ty, sys_info>) {
                    _Os << _Widen_string<_CharT>(_Val.abbrev);
                } else if constexpr (is_same_v<_Ty, local_info>) {
                    _Os << _Widen_string<_CharT>(_Val.first.abbrev);
                } else if constexpr (_Is_specialization_v<_Ty, _Local_time_format_t>) {
                    if (_Val._Abbrev == nullptr) {
                        throw format_error("Cannot print local-time-format-t with null abbrev.");
                    }
                    _Os << _Widen_string<_CharT>(*_Val._Abbrev);
                } else {
                    _Os << _Time_zone_abbreviation;
                }
                return true;
            case 'z':
                {
                    hh_mm_ss<seconds> _Offset;

                    if constexpr (is_same_v<_Ty, sys_info>) {
                        _Offset = hh_mm_ss<seconds>{_Val.offset};
                    } else if constexpr (is_same_v<_Ty, local_info>) {
                        _Offset = hh_mm_ss<seconds>{_Val.first.offset};
                    } else if constexpr (_Is_specialization_v<_Ty, _Local_time_format_t>) {
                        if (_Val._Offset_sec == nullptr) {
                            throw format_error("Cannot print local-time-format-t with null offset_sec.");
                        }
                        _Offset = hh_mm_ss<seconds>{*_Val._Offset_sec};
                    } else {
                        _Offset = hh_mm_ss<seconds>{};
                    }

                    const auto _Sign = _Offset.is_negative() ? _CharT{'-'} : _CharT{'+'};
                    const auto _Separator =
                        _Has_modifier ? (_Choose_literal<_CharT>(":", L":")) : (_Choose_literal<_CharT>("", L""));

                    _Os << ::std:: format((_Choose_literal<_CharT>("{}{:02}{}{:02}", L"{}{:02}{}{:02}")), _Sign, _Offset.hours().count(),
                        _Separator, _Offset.minutes().count());
                    return true;
                }
            default:
                return false;
            }
        }

        template <class _Ty>
        static void _Validate_specifiers(const _Chrono_spec<_CharT>& _Spec, const _Ty& _Val) {
            if constexpr (_Is_specialization_v<_Ty, duration> || is_same_v<_Ty, sys_info> 
                          || _Is_specialization_v<_Ty, time_point> || _Is_specialization_v<_Ty, _Local_time_format_t>) {
                return;
            }

            if constexpr (_Is_specialization_v<_Ty, hh_mm_ss>) {
                if (_Spec._Type == 'H' && _Val.hours() >= hours{24}) {
                    throw format_error("Cannot localize hh_mm_ss with an absolute value of 24 hours or more.");
                }
                return;
            }

            constexpr bool _Is_ymd =
                _Is_any_of_v<_Ty, year_month_day, year_month_day_last, year_month_weekday, year_month_weekday_last>;

            const auto _Validate = [&] {
                switch (_Spec._Type) {
                case 'a':
                case 'A':
                case 'u':
                case 'w':
                    if constexpr (_Is_any_of_v<_Ty, weekday, weekday_last>) {
                        return _Val.ok();
                    } else if constexpr (_Is_any_of_v<_Ty, weekday_indexed, year_month_weekday,
                                             year_month_weekday_last>) {
                        return _Val.weekday().ok();
                    } else if constexpr (is_same_v<_Ty, month_weekday>) {
                        return _Val.weekday_indexed().weekday().ok();
                    } else if constexpr (is_same_v<_Ty, month_weekday_last>) {
                        return _Val.weekday_last().ok();
                    } else if constexpr (_Is_any_of_v<_Ty, year_month_day, year_month_day_last>) {
                        return _Val.ok();
                    }
                    break;

                case 'b':
                case 'B':
                case 'h':
                case 'm':
                    if constexpr (is_same_v<_Ty, month>) {
                        return _Val.ok();
                    } else if constexpr (_Is_any_of_v<_Ty, month_day, month_day_last, month_weekday, month_weekday_last,
                                             year_month> || _Is_ymd) {
                        return _Val.month().ok();
                    }
                    break;

                case 'C':
                case 'y':
                case 'Y':
                    if constexpr (is_same_v<_Ty, year>) {
                        return _Val.ok();
                    } else if constexpr (_Is_any_of_v<_Ty, year_month> || _Is_ymd) {
                        return _Val.year().ok();
                    }
                    break;

                case 'd':
                case 'e':
                    if constexpr (_Is_any_of_v<_Ty, day, month_day_last>) {
                        return _Val.ok();
                    } else if constexpr (is_same_v<_Ty, month_day>) {
                        return _Val.day().ok();
                    } else if constexpr (_Is_ymd) {
                        const year_month_day& _Ymd{_Val};
                        return _Ymd.day().ok();
                    }
                    break;

                case 'D':
                case 'F':
                    if constexpr (_Has_ok<_Ty>) {
                        return _Val.ok();
                    }
                    break;

                case 'j':
                    if constexpr (is_same_v<_Ty, month_day>) {
                        if (_Val.month() > February) {
                            throw format_error("The day of year for a month_day past February is ambiguous.");
                        }
                        return true;
                    } else if constexpr (is_same_v<_Ty, month_day_last>) {
                        if (_Val.month() >= February) {
                            throw format_error("The day of year for a month_day_last other than January is ambiguous");
#line 6283 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"
                        }
                        return true;
                    } else if constexpr (_Is_ymd) {
                        return _Val.ok();
                    }
                    break;

                case 'g':
                case 'G':
                case 'U':
                case 'V':
                case 'W':
                    if constexpr (_Is_ymd) {
                        return _Val.ok();
                    }
                    break;

                default:
                    if constexpr (_Has_ok<_Ty>) {
                        return _Val.ok();
                    }
                    return true;
                }
                ;
                return false;
            };
            if (!_Validate()) {
                throw format_error("Cannot localize out-of-bounds time point.");
            }
        }

        [[nodiscard]] static const _CharT* _Fmt_string(const _Chrono_spec<_CharT>& _Spec, _CharT (&_Fmt_str)[4]) {
            size_t _Next_idx      = 0;
            _Fmt_str[_Next_idx++] = _CharT{'%'};
            if (_Spec._Modifier != '\0') {
                _Fmt_str[_Next_idx++] = static_cast<_CharT>(_Spec._Modifier);
            }
            _Fmt_str[_Next_idx++] = static_cast<_CharT>(_Spec._Type);
            _Fmt_str[_Next_idx]   = _CharT{'\0'};
            return _Fmt_str;
        }

        _Chrono_format_specs<_CharT> _Specs{};
        basic_string_view<_CharT> _Time_zone_abbreviation{};
    };
} 

template <class _Ty, class _CharT>
struct _Fill_tm_formatter {
    constexpr auto parse(basic_format_parse_context<_CharT>& _Parse_ctx) {
        return _Impl.template _Parse<_Ty>(_Parse_ctx);
    }

    template <class _FormatContext>
    auto format(const _Ty& _Val, _FormatContext& _FormatCtx) const {
        return _Impl._Write(_FormatCtx, _Val, _Fill_tm(_Val));
    }

private:
    ::std::chrono:: _Chrono_formatter<_CharT> _Impl;
};

template <class _Rep, class _Period, class _CharT>
struct formatter<::std::chrono:: duration<_Rep, _Period>, _CharT>
    : _Fill_tm_formatter<::std::chrono:: duration<_Rep, _Period>, _CharT> {};

template <class _CharT>
struct formatter<::std::chrono:: day, _CharT> 
    : _Fill_tm_formatter<::std::chrono:: day, _CharT> {};

template <class _CharT>
struct formatter<::std::chrono:: month, _CharT> 
    : _Fill_tm_formatter<::std::chrono:: month, _CharT> {};

template <class _CharT>
struct formatter<::std::chrono:: year, _CharT> 
    : _Fill_tm_formatter<::std::chrono:: year, _CharT> {};

template <class _CharT>
struct formatter<::std::chrono:: weekday, _CharT> 
    : _Fill_tm_formatter<::std::chrono:: weekday, _CharT> {};

template <class _CharT>
struct formatter<::std::chrono:: weekday_indexed, _CharT> 
    : _Fill_tm_formatter<::std::chrono:: weekday_indexed, _CharT> {};

template <class _CharT>
struct formatter<::std::chrono:: weekday_last, _CharT> 
    : _Fill_tm_formatter<::std::chrono:: weekday_last, _CharT> {};

template <class _CharT>
struct formatter<::std::chrono:: month_day, _CharT> 
    : _Fill_tm_formatter<::std::chrono:: month_day, _CharT> {};

template <class _CharT>
struct formatter<::std::chrono:: month_day_last, _CharT> 
    : _Fill_tm_formatter<::std::chrono:: month_day_last, _CharT> {};

template <class _CharT>
struct formatter<::std::chrono:: month_weekday, _CharT> 
    : _Fill_tm_formatter<::std::chrono:: month_weekday, _CharT> {};

template <class _CharT>
struct formatter<::std::chrono:: month_weekday_last, _CharT> 
    : _Fill_tm_formatter<::std::chrono:: month_weekday_last, _CharT> {};

template <class _CharT>
struct formatter<::std::chrono:: year_month, _CharT> 
    : _Fill_tm_formatter<::std::chrono:: year_month, _CharT> {};

template <class _CharT>
struct formatter<::std::chrono:: year_month_day, _CharT> 
    : _Fill_tm_formatter<::std::chrono:: year_month_day, _CharT> {};

template <class _CharT>
struct formatter<::std::chrono:: year_month_day_last, _CharT> 
    : _Fill_tm_formatter<::std::chrono:: year_month_day_last, _CharT> {};

template <class _CharT>
struct formatter<::std::chrono:: year_month_weekday, _CharT> 
    : _Fill_tm_formatter<::std::chrono:: year_month_weekday, _CharT> {};

template <class _CharT>
struct formatter<::std::chrono:: year_month_weekday_last, _CharT>
    : _Fill_tm_formatter<::std::chrono:: year_month_weekday_last, _CharT> {};

template <class _Rep, class _Period, class _CharT>
struct formatter<::std::chrono:: hh_mm_ss<::std::chrono:: duration<_Rep, _Period>>, _CharT>
    : _Fill_tm_formatter<::std::chrono:: hh_mm_ss<::std::chrono:: duration<_Rep, _Period>>, _CharT> {};

template <class _CharT>
struct formatter<::std::chrono:: sys_info, _CharT> 
    : _Fill_tm_formatter<::std::chrono:: sys_info, _CharT> {};

template <class _CharT>
struct formatter<::std::chrono:: local_info, _CharT> 
    : _Fill_tm_formatter<::std::chrono:: local_info, _CharT> {};

template <class _Duration, class _CharT>
struct formatter<::std::chrono:: sys_time<_Duration>, _CharT> {
    constexpr auto parse(basic_format_parse_context<_CharT>& _Parse_ctx) {
        return _Impl.template _Parse<::std::chrono:: sys_time<_Duration>>(_Parse_ctx);
    }

    template <class _FormatContext>
    auto format(const ::std::chrono:: sys_time<_Duration>& _Val, _FormatContext& _FormatCtx) const {
        return _Impl._Write(_FormatCtx, _Val, _Fill_tm(_Val));
    }

private:
    ::std::chrono:: _Chrono_formatter<_CharT> _Impl{(_Choose_literal<_CharT>("UTC", L"UTC"))};
};

template <class _Duration, class _CharT>
struct formatter<::std::chrono:: utc_time<_Duration>, _CharT> {
    constexpr auto parse(basic_format_parse_context<_CharT>& _Parse_ctx) {
        return _Impl.template _Parse<::std::chrono:: utc_time<_Duration>>(_Parse_ctx);
    }

    template <class _FormatContext>
    auto format(const ::std::chrono:: utc_time<_Duration>& _Val, _FormatContext& _FormatCtx) const {
        const auto _Sys = ::std::chrono:: utc_clock::to_sys(_Val);
        return _Impl._Write(_FormatCtx, _Val, _Fill_tm(_Sys));
    }

private:
    ::std::chrono:: _Chrono_formatter<_CharT> _Impl{(_Choose_literal<_CharT>("UTC", L"UTC"))};
};

template <class _Duration, class _CharT>
struct formatter<::std::chrono:: tai_time<_Duration>, _CharT> {
    constexpr auto parse(basic_format_parse_context<_CharT>& _Parse_ctx) {
        return _Impl.template _Parse<::std::chrono:: tai_time<_Duration>>(_Parse_ctx);
    }

    template <class _FormatContext>
    auto format(const ::std::chrono:: tai_time<_Duration>& _Val, _FormatContext& _FormatCtx) const {
        using namespace chrono;
        using _Common = common_type_t<_Duration, days>; 
        constexpr _Common _Offset{sys_days{year{1970} / January / 1} - sys_days{year{1958} / January / 1}};
        const auto _Sys = sys_time<_Duration>{_Val.time_since_epoch()} - _Offset;
        return _Impl._Write(_FormatCtx, _Val, _Fill_tm(_Sys));
    }

private:
    ::std::chrono:: _Chrono_formatter<_CharT> _Impl{(_Choose_literal<_CharT>("TAI", L"TAI"))};
};

template <class _Duration, class _CharT>
struct formatter<::std::chrono:: gps_time<_Duration>, _CharT> {
    constexpr auto parse(basic_format_parse_context<_CharT>& _Parse_ctx) {
        return _Impl.template _Parse<::std::chrono:: gps_time<_Duration>>(_Parse_ctx);
    }

    template <class _FormatContext>
    auto format(const ::std::chrono:: gps_time<_Duration>& _Val, _FormatContext& _FormatCtx) const {
        using namespace chrono;
        using _Common = common_type_t<_Duration, days>; 
        constexpr _Common _Offset{sys_days{year{1980} / January / Sunday[1]} - sys_days{year{1970} / January / 1}};
        const auto _Sys = sys_time<_Duration>{_Val.time_since_epoch()} + _Offset;
        return _Impl._Write(_FormatCtx, _Val, _Fill_tm(_Sys));
    }

private:
    ::std::chrono:: _Chrono_formatter<_CharT> _Impl{(_Choose_literal<_CharT>("GPS", L"GPS"))};
};

template <class _Duration, class _CharT>
struct formatter<::std::chrono:: file_time<_Duration>, _CharT> {
    constexpr auto parse(basic_format_parse_context<_CharT>& _Parse_ctx) {
        return _Impl.template _Parse<::std::chrono:: file_time<_Duration>>(_Parse_ctx);
    }

    template <class _FormatContext>
    auto format(const ::std::chrono:: file_time<_Duration>& _Val, _FormatContext& _FormatCtx) const {
        const auto _Utc = ::std::chrono:: file_clock::to_utc(_Val);
        const auto _Sys = ::std::chrono:: utc_clock::to_sys(_Utc);
        return _Impl._Write(_FormatCtx, _Utc, _Fill_tm(_Sys));
    }

private:
    ::std::chrono:: _Chrono_formatter<_CharT> _Impl{(_Choose_literal<_CharT>("UTC", L"UTC"))};
};

template <class _Duration, class _CharT>
struct formatter<::std::chrono:: local_time<_Duration>, _CharT> 
    : _Fill_tm_formatter<::std::chrono:: local_time<_Duration>, _CharT> {};

template <class _Duration, class _CharT>
struct formatter<::std::chrono:: _Local_time_format_t<_Duration>, _CharT>
    : _Fill_tm_formatter<::std::chrono:: _Local_time_format_t<_Duration>, _CharT> {};

template <class _Duration, class _TimeZonePtr, class _CharT>
struct formatter<::std::chrono:: zoned_time<_Duration, _TimeZonePtr>, _CharT>
    : formatter<::std::chrono:: _Local_time_format_t<_Duration>, _CharT> {

    template <class _FormatContext>
    auto format(const ::std::chrono:: zoned_time<_Duration, _TimeZonePtr>& _Val, _FormatContext& _FormatCtx) const {
        using _Mybase    = formatter<::std::chrono:: _Local_time_format_t<_Duration>, _CharT>;
        const auto _Info = _Val.get_info();
        return _Mybase::format({_Val.get_local_time(), &_Info.abbrev, &_Info.offset}, _FormatCtx);
    }
};

namespace chrono {
    template <class _Duration>
    [[nodiscard]] string nonexistent_local_time::_Make_string(const local_time<_Duration>& _Tp, const local_info& _Info) {
        ostringstream _Os;
        _Os << _Tp << " is in a gap between\n"
            << local_seconds{_Info.first.end.time_since_epoch()} + _Info.first.offset << ' ' << _Info.first.abbrev
            << " and\n"
            << local_seconds{_Info.second.begin.time_since_epoch()} + _Info.second.offset << ' ' << _Info.second.abbrev
            << " which are both equivalent to\n"
            << _Info.first.end << " UTC";
        return ::std:: move(_Os).str();
    }

    template <class _Duration>
    [[nodiscard]] string ambiguous_local_time::_Make_string(const local_time<_Duration>& _Tp, const local_info& _Info) {
        ostringstream _Os;
        _Os << _Tp << " is ambiguous. It could be\n"
            << _Tp << ' ' << _Info.first.abbrev << " == " << _Tp - _Info.first.offset << " UTC or\n"
            << _Tp << ' ' << _Info.second.abbrev << " == " << _Tp - _Info.second.offset << " UTC";
        return ::std:: move(_Os).str();
    }
} 

#line 6551 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"

template <class _Rep, class _Period>
[[nodiscard]] bool _To_xtime_10_day_clamped(:: xtime& _Xt, const ::std::chrono:: duration<_Rep, _Period>& _Rel_time) noexcept(
    is_arithmetic_v<_Rep>) {
    
    
    constexpr ::std::chrono:: nanoseconds _Ten_days{::std::chrono:: hours{24} * 10};
    constexpr ::std::chrono:: duration<double> _Ten_days_d{_Ten_days};
    ::std::chrono:: nanoseconds _Tx0 = ::std::chrono:: system_clock::now().time_since_epoch();
    const bool _Clamped      = _Ten_days_d < _Rel_time;
    if (_Clamped) {
        _Tx0 += _Ten_days;
    } else {
        _Tx0 += ::std::chrono:: duration_cast<::std::chrono:: nanoseconds>(_Rel_time);
    }

    const auto _Whole_seconds = ::std::chrono:: duration_cast<::std::chrono:: seconds>(_Tx0);
    _Xt.sec                   = _Whole_seconds.count();
    _Tx0 -= _Whole_seconds;
    _Xt.nsec = static_cast<long>(_Tx0.count());
    return _Clamped;
}

inline namespace literals {
    inline namespace chrono_literals {
        [[nodiscard]] constexpr ::std::chrono:: hours operator"" h(unsigned long long _Val) noexcept  {
            return ::std::chrono:: hours(_Val);
        }

        [[nodiscard]] constexpr ::std::chrono:: duration<double, ratio<3600>> operator"" h(long double _Val) noexcept
         {
            return ::std::chrono:: duration<double, ratio<3600>>(_Val);
        }

        [[nodiscard]] constexpr ::std::chrono:: minutes(operator"" min)(unsigned long long _Val) noexcept  {
            return ::std::chrono:: minutes(_Val);
        }

        [[nodiscard]] constexpr ::std::chrono:: duration<double, ratio<60>>(operator"" min)(long double _Val) noexcept
         {
            return ::std::chrono:: duration<double, ratio<60>>(_Val);
        }

        [[nodiscard]] constexpr ::std::chrono:: seconds operator"" s(unsigned long long _Val) noexcept  {
            return ::std::chrono:: seconds(_Val);
        }

        [[nodiscard]] constexpr ::std::chrono:: duration<double> operator"" s(long double _Val) noexcept  {
            return ::std::chrono:: duration<double>(_Val);
        }

        [[nodiscard]] constexpr ::std::chrono:: milliseconds operator"" ms(unsigned long long _Val) noexcept  {
            return ::std::chrono:: milliseconds(_Val);
        }

        [[nodiscard]] constexpr ::std::chrono:: duration<double, milli> operator"" ms(long double _Val) noexcept
         {
            return ::std::chrono:: duration<double, milli>(_Val);
        }

        [[nodiscard]] constexpr ::std::chrono:: microseconds operator"" us(unsigned long long _Val) noexcept  {
            return ::std::chrono:: microseconds(_Val);
        }

        [[nodiscard]] constexpr ::std::chrono:: duration<double, micro> operator"" us(long double _Val) noexcept
         {
            return ::std::chrono:: duration<double, micro>(_Val);
        }

        [[nodiscard]] constexpr ::std::chrono:: nanoseconds operator"" ns(unsigned long long _Val) noexcept  {
            return ::std::chrono:: nanoseconds(_Val);
        }

        [[nodiscard]] constexpr ::std::chrono:: duration<double, nano> operator"" ns(long double _Val) noexcept
         {
            return ::std::chrono:: duration<double, nano>(_Val);
        }

        [[nodiscard]] constexpr ::std::chrono:: day operator"" d(unsigned long long _Day) noexcept {
            return ::std::chrono:: day{static_cast<unsigned int>(_Day)};
        }
        [[nodiscard]] constexpr ::std::chrono:: year operator"" y(unsigned long long _Year) noexcept {
            return ::std::chrono:: year{static_cast<int>(_Year)};
        }
#line 6638 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"
    } 
} 

namespace chrono {
    using namespace literals::chrono_literals;
} 


}


#pragma warning(pop)
#pragma pack(pop)
#line 6653 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"
#line 6654 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\chrono"
#line 15 "all-std.cxx"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\csetjmp"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\setjmp.h"


#pragma once


#pragma warning(push)
#pragma warning(disable:   4514 4820 )

__pragma(pack(push, 8)) extern "C" {


    typedef struct __JUMP_BUFFER
    {
        unsigned long Ebp;
        unsigned long Ebx;
        unsigned long Edi;
        unsigned long Esi;
        unsigned long Esp;
        unsigned long Eip;
        unsigned long Registration;
        unsigned long TryLevel;
        unsigned long Cookie;
        unsigned long UnwindFunc;
        unsigned long UnwindData[6];
    } _JUMP_BUFFER;


#line 142 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\setjmp.h"


    typedef int jmp_buf[16];
#line 150 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\setjmp.h"


#line 156 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\setjmp.h"


int __cdecl _setjmp(
      jmp_buf _Buf
    );


    __declspec(noreturn) void __cdecl longjmp(
          jmp_buf _Buf,
          int     _Value
        ) noexcept(false);


#line 175 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\setjmp.h"


} __pragma(pack(pop))

#pragma warning(pop) 
#line 13 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\csetjmp"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
using ::jmp_buf;
using ::longjmp;
using ::_setjmp;
}


#pragma warning(pop)
#pragma pack(pop)

#line 33 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\csetjmp"
#line 34 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\csetjmp"
#line 17 "all-std.cxx"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\csignal"


#pragma once


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\signal.h"


#pragma once


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


typedef int sig_atomic_t;

typedef void (__cdecl* _crt_signal_t)(int);


 void** __cdecl __pxcptinfoptrs(void);


     _crt_signal_t __cdecl signal(  int _Signal,   _crt_signal_t _Function);
#line 64 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\signal.h"

 int __cdecl raise(  int _Signal);


} __pragma(pack(pop))

#pragma warning(pop) 
#line 73 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\signal.h"
#line 13 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\csignal"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {

using :: sig_atomic_t;
using :: raise;
using :: signal;


#line 31 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\csignal"
}


#pragma warning(pop)
#pragma pack(pop)

#line 39 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\csignal"
#line 40 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\csignal"
#line 18 "all-std.cxx"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cstdarg"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stdarg.h"


#pragma once


#pragma warning(push)
#pragma warning(disable:   4514 4820 )

__pragma(pack(push, 8)) extern "C" {


} __pragma(pack(pop))

#pragma warning(pop) 
#line 13 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cstdarg"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
using ::va_list;
}


#pragma warning(pop)
#pragma pack(pop)

#line 31 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cstdarg"
#line 32 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cstdarg"
#line 19 "all-std.cxx"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\unordered_map"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xhash"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"


#pragma once


#line 16 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
template <class _Mylist, class _Base = _Iterator_base0>
class _List_unchecked_const_iterator : public _Base {
public:
    using iterator_category = bidirectional_iterator_tag;

    using _Nodeptr        = typename _Mylist::_Nodeptr;
    using value_type      = typename _Mylist::value_type;
    using difference_type = typename _Mylist::difference_type;
    using pointer         = typename _Mylist::const_pointer;
    using reference       = const value_type&;

    _List_unchecked_const_iterator() noexcept : _Ptr() {}

    _List_unchecked_const_iterator(_Nodeptr _Pnode, const _Mylist* _Plist) noexcept : _Ptr(_Pnode) {
        this->_Adopt(_Plist);
    }

    [[nodiscard]] reference operator*() const noexcept {
        return _Ptr->_Myval;
    }

    [[nodiscard]] pointer operator->() const noexcept {
        return pointer_traits<pointer>::pointer_to(**this);
    }

    _List_unchecked_const_iterator& operator++() noexcept {
        _Ptr = _Ptr->_Next;
        return *this;
    }

    _List_unchecked_const_iterator operator++(int) noexcept {
        _List_unchecked_const_iterator _Tmp = *this;
        _Ptr                                = _Ptr->_Next;
        return _Tmp;
    }

    _List_unchecked_const_iterator& operator--() noexcept {
        _Ptr = _Ptr->_Prev;
        return *this;
    }

    _List_unchecked_const_iterator operator--(int) noexcept {
        _List_unchecked_const_iterator _Tmp = *this;
        _Ptr                                = _Ptr->_Prev;
        return _Tmp;
    }

    [[nodiscard]] bool operator==(const _List_unchecked_const_iterator& _Right) const noexcept {
        return _Ptr == _Right._Ptr;
    }


#line 81 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"

    _Nodeptr _Ptr; 
};

template <class _Mylist>
class _List_unchecked_iterator : public _List_unchecked_const_iterator<_Mylist> {
public:
    using _Mybase           = _List_unchecked_const_iterator<_Mylist>;
    using iterator_category = bidirectional_iterator_tag;

    using _Nodeptr        = typename _Mylist::_Nodeptr;
    using value_type      = typename _Mylist::value_type;
    using difference_type = typename _Mylist::difference_type;
    using pointer         = typename _Mylist::pointer;
    using reference       = value_type&;

    using _Mybase::_Mybase;

    [[nodiscard]] reference operator*() const noexcept {
        return const_cast<reference>(_Mybase::operator*());
    }

    [[nodiscard]] pointer operator->() const noexcept {
        return pointer_traits<pointer>::pointer_to(**this);
    }

    _List_unchecked_iterator& operator++() noexcept {
        _Mybase::operator++();
        return *this;
    }

    _List_unchecked_iterator operator++(int) noexcept {
        _List_unchecked_iterator _Tmp = *this;
        _Mybase::operator++();
        return _Tmp;
    }

    _List_unchecked_iterator& operator--() noexcept {
        _Mybase::operator--();
        return *this;
    }

    _List_unchecked_iterator operator--(int) noexcept {
        _List_unchecked_iterator _Tmp = *this;
        _Mybase::operator--();
        return _Tmp;
    }
};

template <class _Mylist>
class _List_const_iterator : public _List_unchecked_const_iterator<_Mylist, _Iterator_base> {
public:
    using _Mybase           = _List_unchecked_const_iterator<_Mylist, _Iterator_base>;
    using iterator_category = bidirectional_iterator_tag;

    using _Nodeptr        = typename _Mylist::_Nodeptr;
    using value_type      = typename _Mylist::value_type;
    using difference_type = typename _Mylist::difference_type;
    using pointer         = typename _Mylist::const_pointer;
    using reference       = const value_type&;

    using _Mybase::_Mybase;

    [[nodiscard]] reference operator*() const noexcept {


#line 150 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"

        return this->_Ptr->_Myval;
    }

    [[nodiscard]] pointer operator->() const noexcept {
        return pointer_traits<pointer>::pointer_to(**this);
    }

    _List_const_iterator& operator++() noexcept {


#line 164 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"

        this->_Ptr = this->_Ptr->_Next;
        return *this;
    }

    _List_const_iterator operator++(int) noexcept {
        _List_const_iterator _Tmp = *this;
        ++*this;
        return _Tmp;
    }

    _List_const_iterator& operator--() noexcept {
        const auto _New_ptr = this->_Ptr->_Prev;


#line 182 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"

        this->_Ptr = _New_ptr;
        return *this;
    }

    _List_const_iterator operator--(int) noexcept {
        _List_const_iterator _Tmp = *this;
        --*this;
        return _Tmp;
    }

    [[nodiscard]] bool operator==(const _List_const_iterator& _Right) const noexcept {


#line 197 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"

        return this->_Ptr == _Right._Ptr;
    }


#line 206 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"


#line 212 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"

    using _Prevent_inheriting_unwrap = _List_const_iterator;

    [[nodiscard]] _List_unchecked_const_iterator<_Mylist> _Unwrapped() const noexcept {
        return _List_unchecked_const_iterator<_Mylist>(this->_Ptr, static_cast<const _Mylist*>(this->_Getcont()));
    }

    void _Seek_to(const _List_unchecked_const_iterator<_Mylist> _It) noexcept {
        this->_Ptr = _It._Ptr;
    }
};

template <class _Mylist>
class _List_iterator : public _List_const_iterator<_Mylist> {
public:
    using _Mybase           = _List_const_iterator<_Mylist>;
    using iterator_category = bidirectional_iterator_tag;

    using _Nodeptr        = typename _Mylist::_Nodeptr;
    using value_type      = typename _Mylist::value_type;
    using difference_type = typename _Mylist::difference_type;
    using pointer         = typename _Mylist::pointer;
    using reference       = value_type&;

    using _Mybase::_Mybase;

    [[nodiscard]] reference operator*() const noexcept {
        return const_cast<reference>(_Mybase::operator*());
    }

    [[nodiscard]] pointer operator->() const noexcept {
        return pointer_traits<pointer>::pointer_to(**this);
    }

    _List_iterator& operator++() noexcept {
        _Mybase::operator++();
        return *this;
    }

    _List_iterator operator++(int) noexcept {
        _List_iterator _Tmp = *this;
        _Mybase::operator++();
        return _Tmp;
    }

    _List_iterator& operator--() noexcept {
        _Mybase::operator--();
        return *this;
    }

    _List_iterator operator--(int) noexcept {
        _List_iterator _Tmp = *this;
        _Mybase::operator--();
        return _Tmp;
    }

    using _Prevent_inheriting_unwrap = _List_iterator;

    [[nodiscard]] _List_unchecked_iterator<_Mylist> _Unwrapped() const noexcept {
        return _List_unchecked_iterator<_Mylist>(this->_Ptr, static_cast<const _Mylist*>(this->_Getcont()));
    }
};

template <class _Value_type, class _Size_type, class _Difference_type, class _Pointer, class _Const_pointer,
    class _Reference, class _Const_reference, class _Nodeptr_type>
struct _List_iter_types {
    using value_type      = _Value_type;
    using size_type       = _Size_type;
    using difference_type = _Difference_type;
    using pointer         = _Pointer;
    using const_pointer   = _Const_pointer;
    using _Nodeptr        = _Nodeptr_type;
};

template <class _Value_type, class _Voidptr>
struct _List_node { 
    using value_type = _Value_type;
    using _Nodeptr   = _Rebind_pointer_t<_Voidptr, _List_node>;
    _Nodeptr _Next; 
    _Nodeptr _Prev; 
    _Value_type _Myval; 

    _List_node(const _List_node&) = delete;
    _List_node& operator=(const _List_node&) = delete;

    template <class _Alnode>
    static _Nodeptr _Buyheadnode(_Alnode& _Al) {
        const auto _Result = _Al.allocate(1);
        _Construct_in_place(_Result->_Next, _Result);
        _Construct_in_place(_Result->_Prev, _Result);
        return _Result;
    }

    template <class _Alnode>
    static void _Freenode0(_Alnode& _Al, _Nodeptr _Ptr) noexcept {
        
        static_assert(is_same_v<typename _Alnode::value_type, _List_node>, "Bad _Freenode0 call");
        _Destroy_in_place(_Ptr->_Next);
        _Destroy_in_place(_Ptr->_Prev);
        allocator_traits<_Alnode>::deallocate(_Al, _Ptr, 1);
    }

    template <class _Alnode>
    static void _Freenode(_Alnode& _Al, _Nodeptr _Ptr) noexcept { 
        allocator_traits<_Alnode>::destroy(_Al, ::std:: addressof(_Ptr->_Myval));
        _Freenode0(_Al, _Ptr);
    }

    template <class _Alnode>
    static void _Free_non_head(
        _Alnode& _Al, _Nodeptr _Head) noexcept { 
        _Head->_Prev->_Next = nullptr;

        auto _Pnode = _Head->_Next;
        for (_Nodeptr _Pnext; _Pnode; _Pnode = _Pnext) {
            _Pnext = _Pnode->_Next;
            _Freenode(_Al, _Pnode);
        }
    }
};

template <class _Ty>
struct _List_simple_types : _Simple_types<_Ty> {
    using _Node    = _List_node<_Ty, void*>;
    using _Nodeptr = _Node*;
};

template <class _Val_types>
class _List_val : public _Container_base {
public:
    using _Nodeptr = typename _Val_types::_Nodeptr;

    using value_type      = typename _Val_types::value_type;
    using size_type       = typename _Val_types::size_type;
    using difference_type = typename _Val_types::difference_type;
    using pointer         = typename _Val_types::pointer;
    using const_pointer   = typename _Val_types::const_pointer;
    using reference       = value_type&;
    using const_reference = const value_type&;

    _List_val() noexcept : _Myhead(), _Mysize(0) {} 

    void _Orphan_ptr2(_Nodeptr _Ptr) noexcept { 


#line 371 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"
        (void) _Ptr;
#line 373 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"
    }

    void _Orphan_non_end() noexcept { 


#line 390 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"
    }

    _Nodeptr _Unlinknode(_Nodeptr _Pnode) noexcept { 
        _Orphan_ptr2(_Pnode);
        _Pnode->_Prev->_Next = _Pnode->_Next;
        _Pnode->_Next->_Prev = _Pnode->_Prev;
        --_Mysize;
        return _Pnode;
    }


#line 466 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"

    static _Nodeptr _Unchecked_splice(const _Nodeptr _Before, const _Nodeptr _First, const _Nodeptr _Last) noexcept {
        
        ;
        

        const auto _First_prev  = _First->_Prev;
        _First_prev->_Next      = _Last;
        const auto _Last_prev   = _Last->_Prev;
        _Last_prev->_Next       = _Before;
        const auto _Before_prev = _Before->_Prev;
        _Before_prev->_Next     = _First;

        
        _Before->_Prev = _Last_prev;
        _Last->_Prev   = _First_prev;
        _First->_Prev  = _Before_prev;

        return _Last;
    }

    static _Nodeptr _Unchecked_splice(const _Nodeptr _Before, const _Nodeptr _First) noexcept {
        
        ;
        
        const auto _Last = _First->_Next;

        
        const auto _First_prev = _First->_Prev;
        _First_prev->_Next     = _Last;
        
        _First->_Next           = _Before;
        const auto _Before_prev = _Before->_Prev;
        _Before_prev->_Next     = _First;

        
        _Before->_Prev = _First;
        _Last->_Prev   = _First_prev;
        _First->_Prev  = _Before_prev;

        return _Last;
    }

    template <class _Pr2>
    static _Nodeptr _Merge_same(_Nodeptr _First, _Nodeptr _Mid, const _Nodeptr _Last, _Pr2 _Pred) {
        
        
        ;
        _Nodeptr _Newfirst;
        if (static_cast<bool>(_Pred(_Mid->_Myval, _First->_Myval))) {
            
            _Newfirst = _Mid;
        } else {
            
            
            _Newfirst = _First;
            do {
                _First = _First->_Next;
                if (_First == _Mid) {
                    return _Newfirst;
                }
            } while (!static_cast<bool>(_Pred(_Mid->_Myval, _First->_Myval)));
        }

        for (;;) { 
            auto _Run_start = _Mid;
            do { 
                _Mid = _Mid->_Next;
            } while (_Mid != _Last && static_cast<bool>(_Pred(_Mid->_Myval, _First->_Myval)));

            
            _Unchecked_splice(_First, _Run_start, _Mid);
            if (_Mid == _Last) {
                return _Newfirst;
            }

            
            do {
                _First = _First->_Next;
                if (_First == _Mid) {
                    return _Newfirst;
                }
            } while (!static_cast<bool>(_Pred(_Mid->_Myval, _First->_Myval)));
        }
    }

    template <class _Pr2>
    static _Nodeptr _Sort(_Nodeptr& _First, const size_type _Size, _Pr2 _Pred) {
        
        switch (_Size) {
        case 0:
            return _First;
        case 1:
            return _First->_Next;
        default:
            break;
        }

        auto _Mid        = _Sort(_First, _Size / 2, _Pred);
        const auto _Last = _Sort(_Mid, _Size - _Size / 2, _Pred);
        _First           = _Merge_same(_First, _Mid, _Last, _Pred);
        return _Last;
    }

    _Nodeptr _Myhead; 
    size_type _Mysize; 
};

template <class _Alnode>
struct _List_node_emplace_op2 : _Alloc_construct_ptr<_Alnode> {
    using _Alnode_traits = allocator_traits<_Alnode>;
    using pointer        = typename _Alnode_traits::pointer;

    template <class... _Valtys>
    explicit _List_node_emplace_op2(_Alnode& _Al_, _Valtys&&... _Vals) : _Alloc_construct_ptr<_Alnode>(_Al_) {
        this->_Allocate();
        _Alnode_traits::construct(this->_Al, ::std:: addressof(this->_Ptr->_Myval), ::std:: forward<_Valtys>(_Vals)...);
    }

    ~_List_node_emplace_op2() {
        if (this->_Ptr != pointer{}) {
            _Alnode_traits::destroy(this->_Al, ::std:: addressof(this->_Ptr->_Myval));
        }
    }

    _List_node_emplace_op2(const _List_node_emplace_op2&) = delete;
    _List_node_emplace_op2& operator=(const _List_node_emplace_op2&) = delete;

    pointer _Transfer_before(const pointer _Insert_before) noexcept {
        const pointer _Insert_after = _Insert_before->_Prev;
        _Construct_in_place(this->_Ptr->_Next, _Insert_before);
        _Construct_in_place(this->_Ptr->_Prev, _Insert_after);
        const auto _Result    = this->_Ptr;
        this->_Ptr            = pointer{};
        _Insert_before->_Prev = _Result;
        _Insert_after->_Next  = _Result;
        return _Result;
    }
};

template <class _Alnode>
struct _List_node_insert_op2 {
    
    using _Alnode_traits = allocator_traits<_Alnode>;
    using pointer        = typename _Alnode_traits::pointer;
    using size_type      = typename _Alnode_traits::size_type;
    using value_type     = typename _Alnode_traits::value_type;

    explicit _List_node_insert_op2(_Alnode& _Al_) : _Al(_Al_), _Added(0) {}

    _List_node_insert_op2(const _List_node_insert_op2&) = delete;
    _List_node_insert_op2& operator=(const _List_node_insert_op2&) = delete;

    template <class... _CArgT>
    void _Append_n(size_type _Count, const _CArgT&... _Carg) {
        
        if (_Count <= 0) {
            return;
        }

        _Alloc_construct_ptr<_Alnode> _Newnode(_Al);
        if (_Added == 0) {
            _Newnode._Allocate(); 
            _Alnode_traits::construct(_Al, ::std:: addressof(_Newnode._Ptr->_Myval), _Carg...); 
            _Head = _Newnode._Ptr;
            _Tail = _Newnode._Ptr;
            ++_Added;
            --_Count;
        }

        for (; 0 < _Count; --_Count) {
            _Newnode._Allocate(); 
            _Alnode_traits::construct(_Al, ::std:: addressof(_Newnode._Ptr->_Myval), _Carg...); 
            _Construct_in_place(_Tail->_Next, _Newnode._Ptr);
            _Construct_in_place(_Newnode._Ptr->_Prev, _Tail);
            _Tail = _Newnode._Ptr;
            ++_Added;
        }

        _Newnode._Ptr = pointer{};
    }

    template <class _InIt, class _Sentinel>
    void _Append_range_unchecked(_InIt _First, const _Sentinel _Last) {
        
        if (_First == _Last) { 
            return;
        }

        _Alloc_construct_ptr<_Alnode> _Newnode(_Al);
        if (_Added == 0) {
            _Newnode._Allocate(); 
            _Alnode_traits::construct(_Al, ::std:: addressof(_Newnode._Ptr->_Myval), *_First); 
            const auto _Newhead = ::std:: exchange(_Newnode._Ptr, pointer{});
            _Head               = _Newhead;
            _Tail               = _Newhead;
            ++_Added;
            ++_First; 
        }

        while (_First != _Last) { 
            _Newnode._Allocate(); 
            _Alnode_traits::construct(_Al, ::std:: addressof(_Newnode._Ptr->_Myval), *_First); 
            _Construct_in_place(_Tail->_Next, _Newnode._Ptr);
            _Construct_in_place(_Newnode._Ptr->_Prev, _Tail);
            _Tail = ::std:: exchange(_Newnode._Ptr, pointer{});
            ++_Added;
            ++_First; 
        }
    }

    template <class _Val_types>
    pointer _Attach_before(_List_val<_Val_types>& _List_data, const pointer _Insert_before) noexcept {
        
        
        const auto _Local_added = _Added;
        if (_Local_added == 0) {
            return _Insert_before;
        }

        const auto _Local_head   = _Head;
        const auto _Local_tail   = _Tail;
        const auto _Insert_after = _Insert_before->_Prev;

        _Construct_in_place(_Local_head->_Prev, _Insert_after);
        _Insert_after->_Next = _Local_head;
        _Construct_in_place(_Local_tail->_Next, _Insert_before);
        _Insert_before->_Prev = _Local_tail;

        _List_data._Mysize += _Local_added;
        _Added = 0;
        return _Local_head;
    }

    template <class _Val_types>
    void _Attach_at_end(_List_val<_Val_types>& _List_data) noexcept {
        _Attach_before(_List_data, _List_data._Myhead);
    }

    template <class _Val_types>
    void _Attach_head(_List_val<_Val_types>& _List_data) {
        _Alloc_construct_ptr<_Alnode> _Newnode(_Al);
        _Newnode._Allocate(); 
        const auto _Local_added = ::std:: exchange(_Added, size_type{0});
        if (_Local_added == 0) {
            _Construct_in_place(_Newnode._Ptr->_Next, _Newnode._Ptr);
            _Construct_in_place(_Newnode._Ptr->_Prev, _Newnode._Ptr);
        } else {
            const auto _Local_head = _Head;
            const auto _Local_tail = _Tail;
            _Construct_in_place(_Newnode._Ptr->_Next, _Local_head);
            _Construct_in_place(_Newnode._Ptr->_Prev, _Local_tail);
            _Construct_in_place(_Local_head->_Prev, _Newnode._Ptr);
            _Construct_in_place(_Local_tail->_Next, _Newnode._Ptr);
        }

        _List_data._Mysize = _Local_added;
        _List_data._Myhead = _Newnode._Release();
    }

    ~_List_node_insert_op2() {
        if (_Added == 0) {
            return;
        }

        _Construct_in_place(_Head->_Prev, pointer{});
        _Construct_in_place(_Tail->_Next, pointer{});
        pointer _Subject = _Head;
        while (_Subject) {
            value_type::_Freenode(_Al, ::std:: exchange(_Subject, _Subject->_Next));
        }
    }

private:
    _Alnode& _Al;
    size_type _Added; 
    pointer _Tail; 
    pointer _Head; 
};

template <class _Traits>
class _Hash;

template <class _Ty, class _Alloc = allocator<_Ty>>
class list { 
private:
    template <class>
    friend class _Hash;
    template <class _Traits>
    friend bool _Hash_equal(const _Hash<_Traits>&, const _Hash<_Traits>&);

    using _Alty          = _Rebind_alloc_t<_Alloc, _Ty>;
    using _Alty_traits   = allocator_traits<_Alty>;
    using _Node          = _List_node<_Ty, typename allocator_traits<_Alloc>::void_pointer>;
    using _Alnode        = _Rebind_alloc_t<_Alloc, _Node>;
    using _Alnode_traits = allocator_traits<_Alnode>;
    using _Nodeptr       = typename _Alnode_traits::pointer;

    using _Val_types = conditional_t<_Is_simple_alloc_v<_Alnode>, _List_simple_types<_Ty>,
        _List_iter_types<_Ty, typename _Alty_traits::size_type, typename _Alty_traits::difference_type,
            typename _Alty_traits::pointer, typename _Alty_traits::const_pointer, _Ty&, const _Ty&, _Nodeptr>>;

    using _Scary_val = _List_val<_Val_types>;

public:
    static_assert(!1 || is_same_v<_Ty, typename _Alloc::value_type>,
        "list<T, Allocator>" " requires that Allocator's value_type match " "T" " (See N4659 26.2.1 [container.requirements.general]/16 allocator_type)" " Either fix the allocator value_type or define _ENFORCE_MATCHING_ALLOCATORS=0" " to suppress this diagnostic.");

    using value_type      = _Ty;
    using allocator_type  = _Alloc;
    using size_type       = typename _Alty_traits::size_type;
    using difference_type = typename _Alty_traits::difference_type;
    using pointer         = typename _Alty_traits::pointer;
    using const_pointer   = typename _Alty_traits::const_pointer;
    using reference       = value_type&;
    using const_reference = const value_type&;

    using iterator                  = _List_iterator<_Scary_val>;
    using const_iterator            = _List_const_iterator<_Scary_val>;
    using _Unchecked_iterator       = _List_unchecked_iterator<_Scary_val>;
    using _Unchecked_const_iterator = _List_unchecked_const_iterator<_Scary_val>;

    using reverse_iterator       = ::std:: reverse_iterator<iterator>;
    using const_reverse_iterator = ::std:: reverse_iterator<const_iterator>;

    list() : _Mypair(_Zero_then_variadic_args_t{}) {
        _Alloc_sentinel_and_proxy();
    }

    explicit list(const _Alloc& _Al) : _Mypair(_One_then_variadic_args_t{}, _Al) {
        _Alloc_sentinel_and_proxy();
    }

private:
    template <class _Any_alloc>
    explicit list(_Move_allocator_tag, _Any_alloc& _Al) : _Mypair(_One_then_variadic_args_t{}, ::std:: move(_Al)) {
        _Alloc_sentinel_and_proxy();
    }

    void _Construct_n( size_type _Count) {
        auto&& _Alproxy = _Fake_alloc;
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
        _List_node_insert_op2<_Alnode> _Appended(_Getal());
        _Appended._Append_n(_Count);
        _Appended._Attach_head(_Mypair._Myval2);
        _Proxy._Release();
    }

public:
    explicit list( size_type _Count)
        : _Mypair(_Zero_then_variadic_args_t{}) { 
        _Construct_n(_Count);
    }

    explicit list( size_type _Count, const _Alloc& _Al)
        : _Mypair(_One_then_variadic_args_t{}, _Al) { 
        _Construct_n(_Count);
    }

private:
    void _Construct_n( size_type _Count, const _Ty& _Val) {
        auto&& _Alproxy = _Fake_alloc;
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
        _List_node_insert_op2<_Alnode> _Appended(_Getal());
        _Appended._Append_n(_Count, _Val);
        _Appended._Attach_head(_Mypair._Myval2);
        _Proxy._Release();
    }

public:
    list( size_type _Count, const _Ty& _Val)
        : _Mypair(_Zero_then_variadic_args_t{}) { 
        _Construct_n(_Count, _Val);
    }

    list( size_type _Count, const _Ty& _Val, const _Alloc& _Al)
        : _Mypair(_One_then_variadic_args_t{}, _Al) { 
        _Construct_n(_Count, _Val);
    }

private:
    template <class _Iter>
    void _Construct_range_unchecked(_Iter _First, _Iter _Last) {
        auto&& _Alproxy = _Fake_alloc;
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
        _List_node_insert_op2<_Alnode> _Appended(_Getal());
        _Appended._Append_range_unchecked(_First, _Last);
        _Appended._Attach_head(_Mypair._Myval2);
        _Proxy._Release();
    }

public:
    list(const list& _Right)
        : _Mypair(_One_then_variadic_args_t{}, _Alnode_traits::select_on_container_copy_construction(_Right._Getal())) {
        _Construct_range_unchecked(_Right._Unchecked_begin(), _Right._Unchecked_end());
    }

    list(const list& _Right, const _Identity_t<_Alloc>& _Al) : _Mypair(_One_then_variadic_args_t{}, _Al) {
        _Construct_range_unchecked(_Right._Unchecked_begin(), _Right._Unchecked_end());
    }

    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
    list(_Iter _First, _Iter _Last) : _Mypair(_Zero_then_variadic_args_t{}) {
        _Adl_verify_range(_First, _Last);
        _Construct_range_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last));
    }

    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
    list(_Iter _First, _Iter _Last, const _Alloc& _Al) : _Mypair(_One_then_variadic_args_t{}, _Al) {
        _Adl_verify_range(_First, _Last);
        _Construct_range_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last));
    }

    list(list&& _Right) : _Mypair(_One_then_variadic_args_t{}, ::std:: move(_Right._Getal())) {
        _Alloc_sentinel_and_proxy();
        _Swap_val(_Right);
    }

    list(list&& _Right, const _Identity_t<_Alloc>& _Al) : _Mypair(_One_then_variadic_args_t{}, _Al) {
        if constexpr (!_Alnode_traits::is_always_equal::value) {
            if (_Getal() != _Right._Getal()) {
                _Construct_range_unchecked(::std:: make_move_iterator(_Right._Unchecked_begin()),
                    ::std:: make_move_iterator(_Right._Unchecked_end()));
                return;
            }
        }

        _Alloc_sentinel_and_proxy();
        _Swap_val(_Right);
    }

public:
    list& operator=(list&& _Right) noexcept(
        _Choose_pocma_v<_Alnode> == _Pocma_values::_Equal_allocators)  {
        if (this == ::std:: addressof(_Right)) {
            return *this;
        }

        auto& _Al                 = _Getal();
        auto& _Right_al           = _Right._Getal();
        constexpr auto _Pocma_val = _Choose_pocma_v<_Alnode>;
        if constexpr (_Pocma_val == _Pocma_values::_Propagate_allocators) {
            if (_Al != _Right_al) {
                auto&& _Alproxy       = _Fake_alloc;
                auto&& _Right_alproxy = _Fake_alloc;
                _Container_proxy_ptr<_Alty> _Proxy(_Right_alproxy, _Leave_proxy_unbound{});
                auto& _My_data      = _Mypair._Myval2;
                auto& _Right_data   = _Right._Mypair._Myval2;
                const auto _Newhead = ::std:: exchange(_Right_data._Myhead, _Node::_Buyheadnode(_Right_al));
                const auto _Newsize = ::std:: exchange(_Right_data._Mysize, size_type{0});
                _Tidy();
                _Pocma(_Al, _Right_al);
                _My_data._Myhead = _Newhead;
                _My_data._Mysize = _Newsize;
                _Proxy._Bind(_Alproxy, ::std:: addressof(_My_data));
                _My_data._Swap_proxy_and_iterators(_Right_data);
                return *this;
            }
        } else if constexpr (_Pocma_val == _Pocma_values::_No_propagate_allocators) {
            if (_Al != _Right_al) {
                assign(::std:: make_move_iterator(_Right._Unchecked_begin()),
                    ::std:: make_move_iterator(_Right._Unchecked_end()));
                return *this;
            }
        }

        clear();
        _Pocma(_Al, _Right_al);
        _Swap_val(_Right);

        return *this;
    }

private:
    void _Swap_val(list& _Right) noexcept { 
        auto& _My_data    = _Mypair._Myval2;
        auto& _Right_data = _Right._Mypair._Myval2;
        _My_data._Swap_proxy_and_iterators(_Right_data);
        _Swap_adl(_My_data._Myhead, _Right_data._Myhead);
        ::std:: swap(_My_data._Mysize, _Right_data._Mysize);
    }

public:
    void push_front(_Ty&& _Val) { 
        _Emplace(_Mypair._Myval2._Myhead->_Next, ::std:: move(_Val));
    }

    void push_back(_Ty&& _Val) { 
        _Emplace(_Mypair._Myval2._Myhead, ::std:: move(_Val));
    }

    iterator insert(const_iterator _Where, _Ty&& _Val) { 
        return emplace(_Where, ::std:: move(_Val));
    }

    template <class... _Valty>
    decltype(auto) emplace_front(_Valty&&... _Val) { 
        reference _Result = _Emplace(_Mypair._Myval2._Myhead->_Next, ::std:: forward<_Valty>(_Val)...)->_Myval;


        return _Result;


#line 974 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"
    }

    template <class... _Valty>
    decltype(auto) emplace_back(_Valty&&... _Val) { 
        reference _Result = _Emplace(_Mypair._Myval2._Myhead, ::std:: forward<_Valty>(_Val)...)->_Myval;


        return _Result;


#line 985 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"
    }

    template <class... _Valty>
    iterator emplace(const const_iterator _Where, _Valty&&... _Val) { 


#line 992 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"

        return _Make_iter(_Emplace(_Where._Ptr, ::std:: forward<_Valty>(_Val)...));
    }

    template <class... _Valty>
    _Nodeptr _Emplace(const _Nodeptr _Where, _Valty&&... _Val) { 
        size_type& _Mysize = _Mypair._Myval2._Mysize;
        if (_Mysize == max_size()) {
            _Xlength_error("list too long");
        }

        _List_node_emplace_op2<_Alnode> _Op{_Getal(), ::std:: forward<_Valty>(_Val)...};
        ++_Mysize;
        return _Op._Transfer_before(_Where);
    }

    list(initializer_list<_Ty> _Ilist) : _Mypair(_Zero_then_variadic_args_t{}) {
        _Construct_range_unchecked(_Ilist.begin(), _Ilist.end());
    }

    list(initializer_list<_Ty> _Ilist, const _Alloc& _Al) : _Mypair(_One_then_variadic_args_t{}, _Al) {
        _Construct_range_unchecked(_Ilist.begin(), _Ilist.end());
    }

    list& operator=(initializer_list<_Ty> _Ilist) {
        assign(_Ilist.begin(), _Ilist.end());
        return *this;
    }

    void assign(initializer_list<_Ty> _Ilist) {
        assign(_Ilist.begin(), _Ilist.end());
    }

    iterator insert(const_iterator _Where,
        initializer_list<_Ty> _Ilist) { 
        return insert(_Where, _Ilist.begin(), _Ilist.end());
    }

    ~list() noexcept {
        _Tidy();


#line 1036 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"
    }

private:
    void _Reload_sentinel_and_proxy(const list& _Right) { 
        auto& _Al             = _Getal();
        auto&& _Alproxy       = _Fake_alloc;
        auto& _Right_al       = _Right._Getal();
        auto&& _Right_alproxy = _Fake_alloc;
        _Container_proxy_ptr<_Alty> _Proxy(_Right_alproxy, _Leave_proxy_unbound{});
        auto _Right_al_non_const = _Right_al;
        auto _Newhead            = _Node::_Buyheadnode(_Right_al_non_const);
        _Tidy();
        _Pocca(_Al, _Right_al);
        _Mypair._Myval2._Myhead = _Newhead;
        _Mypair._Myval2._Mysize = 0;
        _Proxy._Bind(_Alproxy, ::std:: addressof(_Mypair._Myval2));
    }

public:
    list& operator=(const list& _Right) {
        if (this == ::std:: addressof(_Right)) {
            return *this;
        }

        auto& _Al       = _Getal();
        auto& _Right_al = _Right._Getal();
        if constexpr (_Choose_pocca_v<_Alnode>) {
            if (_Al != _Right_al) {
                _Reload_sentinel_and_proxy(_Right);
            }
        } else {
            _Pocca(_Al, _Right_al);
        }

        assign(_Right._Unchecked_begin(), _Right._Unchecked_end());
        return *this;
    }

    [[nodiscard]] iterator begin() noexcept {
        return iterator(_Mypair._Myval2._Myhead->_Next, ::std:: addressof(_Mypair._Myval2));
    }

    [[nodiscard]] const_iterator begin() const noexcept {
        return const_iterator(_Mypair._Myval2._Myhead->_Next, ::std:: addressof(_Mypair._Myval2));
    }

    [[nodiscard]] iterator end() noexcept {
        return iterator(_Mypair._Myval2._Myhead, ::std:: addressof(_Mypair._Myval2));
    }

    [[nodiscard]] const_iterator end() const noexcept {
        return const_iterator(_Mypair._Myval2._Myhead, ::std:: addressof(_Mypair._Myval2));
    }

    _Unchecked_iterator _Unchecked_begin() noexcept {
        return _Unchecked_iterator(_Mypair._Myval2._Myhead->_Next, nullptr);
    }

    _Unchecked_const_iterator _Unchecked_begin() const noexcept {
        return _Unchecked_const_iterator(_Mypair._Myval2._Myhead->_Next, nullptr);
    }

    _Unchecked_iterator _Unchecked_end() noexcept {
        return _Unchecked_iterator(_Mypair._Myval2._Myhead, nullptr);
    }

    _Unchecked_const_iterator _Unchecked_end() const noexcept {
        return _Unchecked_const_iterator(_Mypair._Myval2._Myhead, nullptr);
    }

    iterator _Make_iter(_Nodeptr _Where) const noexcept {
        return iterator(_Where, ::std:: addressof(_Mypair._Myval2));
    }

    const_iterator _Make_const_iter(_Nodeptr _Where) const noexcept {
        return const_iterator(_Where, ::std:: addressof(_Mypair._Myval2));
    }

    [[nodiscard]] reverse_iterator rbegin() noexcept {
        return reverse_iterator(end());
    }

    [[nodiscard]] const_reverse_iterator rbegin() const noexcept {
        return const_reverse_iterator(end());
    }

    [[nodiscard]] reverse_iterator rend() noexcept {
        return reverse_iterator(begin());
    }

    [[nodiscard]] const_reverse_iterator rend() const noexcept {
        return const_reverse_iterator(begin());
    }

    [[nodiscard]] const_iterator cbegin() const noexcept {
        return begin();
    }

    [[nodiscard]] const_iterator cend() const noexcept {
        return end();
    }

    [[nodiscard]] const_reverse_iterator crbegin() const noexcept {
        return rbegin();
    }

    [[nodiscard]] const_reverse_iterator crend() const noexcept {
        return rend();
    }

    void resize( size_type _Newsize) { 
        auto& _My_data = _Mypair._Myval2;
        if (_My_data._Mysize < _Newsize) { 
            _List_node_insert_op2<_Alnode> _Op(_Getal());
            _Op._Append_n(_Newsize - _My_data._Mysize);
            _Op._Attach_at_end(_My_data);
        } else {
            while (_Newsize < _My_data._Mysize) {
                pop_back();
            }
        }
    }

    void resize( size_type _Newsize, const _Ty& _Val) {
        
        auto& _My_data = _Mypair._Myval2;
        if (_My_data._Mysize < _Newsize) { 
            _List_node_insert_op2<_Alnode> _Op(_Getal());
            _Op._Append_n(_Newsize - _My_data._Mysize, _Val);
            _Op._Attach_at_end(_My_data);
        } else {
            while (_Newsize < _My_data._Mysize) {
                pop_back();
            }
        }
    }

    [[nodiscard]] size_type size() const noexcept {
        return _Mypair._Myval2._Mysize;
    }

    [[nodiscard]] size_type max_size() const noexcept {
        return (::std:: min)(
            static_cast<size_type>((numeric_limits<difference_type>::max)()), _Alnode_traits::max_size(_Getal()));
    }

    [[nodiscard]] bool empty() const noexcept {
        return _Mypair._Myval2._Mysize == 0;
    }

    [[nodiscard]] allocator_type get_allocator() const noexcept {
        return static_cast<allocator_type>(_Getal());
    }

    [[nodiscard]] reference front() noexcept  {


#line 1194 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"

        return _Mypair._Myval2._Myhead->_Next->_Myval;
    }

    [[nodiscard]] const_reference front() const noexcept  {


#line 1202 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"

        return _Mypair._Myval2._Myhead->_Next->_Myval;
    }

    [[nodiscard]] reference back() noexcept  {


#line 1210 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"

        return _Mypair._Myval2._Myhead->_Prev->_Myval;
    }

    [[nodiscard]] const_reference back() const noexcept  {


#line 1218 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"

        return _Mypair._Myval2._Myhead->_Prev->_Myval;
    }

    void push_front(const _Ty& _Val) {
        _Emplace(_Mypair._Myval2._Myhead->_Next, _Val);
    }

    void pop_front() noexcept  {


#line 1230 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"

        _Unchecked_erase(_Mypair._Myval2._Myhead->_Next);
    }

    void push_back(const _Ty& _Val) {
        _Emplace(_Mypair._Myval2._Myhead, _Val);
    }

    void pop_back() noexcept  {


#line 1242 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"

        _Unchecked_erase(_Mypair._Myval2._Myhead->_Prev);
    }

private:
    template <class _Target_ref, class _UIter>
    void _Assign_cast(_UIter _UFirst, const _UIter _ULast) {
        
        const auto _Myend = _Mypair._Myval2._Myhead;
        auto _Old         = _Myend->_Next;
        for (;;) { 
            if (_Old == _Myend) { 
                _List_node_insert_op2<_Alnode> _Op(_Getal());
                _Op._Append_range_unchecked(_UFirst, _ULast);
                _Op._Attach_at_end(_Mypair._Myval2);
                return;
            }

            if (_UFirst == _ULast) {
                
                _Unchecked_erase(_Old, _Myend);
                return;
            }

            
            reinterpret_cast<_Target_ref>(_Old->_Myval) = *_UFirst;
            _Old                                        = _Old->_Next;
            ++_UFirst;
        }
    }

public:
    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
    void assign(_Iter _First, _Iter _Last) {
        _Assign_cast<reference>(_Get_unwrapped(_First), _Get_unwrapped(_Last));
    }

    void assign( size_type _Count, const _Ty& _Val) { 
        const auto _Myend = _Mypair._Myval2._Myhead;
        auto _Old         = _Myend->_Next;
        for (;;) { 
            if (_Old == _Myend) { 
                _List_node_insert_op2<_Alnode> _Op(_Getal());
                _Op._Append_n(_Count, _Val);
                _Op._Attach_at_end(_Mypair._Myval2);
                return;
            }

            if (_Count == 0) {
                
                _Unchecked_erase(_Old, _Myend);
                return;
            }

            
            _Old->_Myval = _Val;
            _Old         = _Old->_Next;
            --_Count;
        }
    }

    iterator insert(const_iterator _Where, const _Ty& _Val) { 


#line 1307 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"
        return _Make_iter(_Emplace(_Where._Ptr, _Val));
    }

    iterator insert(const_iterator _Where,  size_type _Count,
        const _Ty& _Val) { 


#line 1315 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"
        _List_node_insert_op2<_Alnode> _Op(_Getal());
        _Op._Append_n(_Count, _Val);
        return _Make_iter(_Op._Attach_before(_Mypair._Myval2, _Where._Ptr));
    }

    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
    iterator insert(const const_iterator _Where, _Iter _First, _Iter _Last) { 


#line 1325 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"
        _Adl_verify_range(_First, _Last);
        _List_node_insert_op2<_Alnode> _Op(_Getal());
        _Op._Append_range_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last));
        return _Make_iter(_Op._Attach_before(_Mypair._Myval2, _Where._Ptr));
    }

public:
    iterator erase(const const_iterator _Where) noexcept  {


#line 1336 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"
        const auto _Result = _Where._Ptr->_Next;
        _Node::_Freenode(_Getal(), _Mypair._Myval2._Unlinknode(_Where._Ptr));
        return _Make_iter(_Result);
    }

private:
    _Nodeptr _Unchecked_erase(const _Nodeptr _Pnode) noexcept { 
        const auto _Result = _Pnode->_Next;
        _Mypair._Myval2._Orphan_ptr2(_Pnode);
        --_Mypair._Myval2._Mysize;
        _Pnode->_Prev->_Next = _Result;
        _Result->_Prev       = _Pnode->_Prev;
        _Node::_Freenode(_Getal(), _Pnode);
        return _Result;
    }

public:
    iterator erase(const const_iterator _First, const const_iterator _Last) noexcept  {
        _Adl_verify_range(_First, _Last);
        return _Make_iter(_Unchecked_erase(_First._Ptr, _Last._Ptr));
    }

private:
    _Nodeptr _Unchecked_erase(_Nodeptr _First, const _Nodeptr _Last) noexcept { 
        if (_First == _Last) {
            return _Last;
        }

        const auto _Predecessor = _First->_Prev;


#line 1389 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"

        
        _Predecessor->_Next = _Last;
        _Last->_Prev        = _Predecessor;

        
        auto& _Al           = _Getal();
        size_type _Erasures = 0;
        do {
            const auto _Next = _First->_Next;
            _Node::_Freenode(_Al, _First);
            _First = _Next;
            ++_Erasures;
        } while (_First != _Last);

        _Mypair._Myval2._Mysize -= _Erasures;
        return _Last;
    }

public:
    void clear() noexcept { 
        auto& _My_data = _Mypair._Myval2;
        _My_data._Orphan_non_end();
        _Node::_Free_non_head(_Getal(), _My_data._Myhead);
        _My_data._Myhead->_Next = _My_data._Myhead;
        _My_data._Myhead->_Prev = _My_data._Myhead;
        _My_data._Mysize        = 0;
    }

private:
    void _Tidy() noexcept {
        auto& _Al      = _Getal();
        auto& _My_data = _Mypair._Myval2;
        _My_data._Orphan_all();
        _Node::_Free_non_head(_Al, _My_data._Myhead);
        _Node::_Freenode0(_Al, _My_data._Myhead);
    }

public:
    void swap(list& _Right) noexcept  {
        if (this != ::std:: addressof(_Right)) {
            _Pocs(_Getal(), _Right._Getal());
            _Swap_val(_Right);
        }
    }

    void splice(const const_iterator _Where, list& _Right) { 
        auto& _Right_data = _Right._Mypair._Myval2;
        if (this != ::std:: addressof(_Right) && _Right_data._Mysize != 0) { 


#line 1441 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"
            const auto _Right_head = _Right_data._Myhead;
            _Splice(_Where._Ptr, _Right, _Right_head->_Next, _Right_head, _Right_data._Mysize);
        }
    }

    void splice(const const_iterator _Where, list&& _Right) { 
        splice(_Where, _Right);
    }

    void splice(const const_iterator _Where, list& _Right, const const_iterator _First) {
        

#line 1457 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"
        const auto _UWhere = _Where._Ptr;
        const auto _UFirst = _First._Ptr;


#line 1465 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"

        const auto _ULast = _UFirst->_Next;
        if (this != ::std:: addressof(_Right) || (_UWhere != _UFirst && _UWhere != _ULast)) {
            _Splice(_UWhere, _Right, _UFirst, _ULast, 1);
        }
    }

    void splice(const const_iterator _Where, list&& _Right, const const_iterator _First) {
        
        splice(_Where, _Right, _First);
    }

    void splice(const const_iterator _Where, list& _Right, const const_iterator _First, const const_iterator _Last) {
        

#line 1485 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"

        const auto _UWhere = _Where._Ptr;
        const auto _UFirst = _First._Ptr;
        const auto _ULast  = _Last._Ptr;

        if (_UFirst != _ULast && (this != ::std:: addressof(_Right) || _UWhere != _ULast)) { 
            size_type _Count = 0;

            if (this != ::std:: addressof(_Right)) {
                const auto _Right_end = _Right._Mypair._Myval2._Myhead;
                if (_UFirst == _Right_end->_Next && _ULast == _Right_end) {
                    _Count = _Right._Mypair._Myval2._Mysize; 
                } else { 
                    for (auto _To_check = _UFirst; _To_check != _ULast; _To_check = _To_check->_Next, (void) ++_Count) {


#line 1502 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"
                    }
                }
            }

            _Splice(_UWhere, _Right, _UFirst, _ULast, _Count);
        }
    }

    void splice(const const_iterator _Where, list&& _Right, const const_iterator _First, const const_iterator _Last) {
        
        splice(_Where, _Right, _First, _Last);
    }

    struct _List_node_remove_op {
        
        
        explicit _List_node_remove_op(list& _List_) noexcept : _List(_List_), _Head(), _Tail(::std:: addressof(_Head)) {}

        _List_node_remove_op(const _List_node_remove_op&) = delete;
        _List_node_remove_op& operator=(const _List_node_remove_op&) = delete;

        _Nodeptr _Transfer_back(const _Nodeptr _Removed) noexcept {
            
            
            ;

            
            --_List._Mypair._Myval2._Mysize;
            const auto _Next = ::std:: exchange(_Removed->_Next, _Nodeptr());
            const auto _Prev = _Removed->_Prev;
            _Prev->_Next     = _Next;
            _Next->_Prev     = _Prev;


#line 1540 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"

            *_Tail = _Removed;
            _Tail  = ::std:: addressof(_Removed->_Next);

            return _Next;
        }

        ~_List_node_remove_op() {
            auto& _Al = _List._Getal();


#line 1567 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"

            auto _Target = _Head;
            while (_Target) {
                auto _Next = _Target->_Next;
                _List._Mypair._Myval2._Orphan_ptr2(_Target);
                _Alnode_traits::destroy(_Al, ::std:: addressof(_Target->_Next));
                _Alnode_traits::destroy(_Al, ::std:: addressof(_Target->_Prev));
                _Alnode_traits::destroy(_Al, ::std:: addressof(_Target->_Myval));
                _Al.deallocate(_Target, 1);
                _Target = _Next;
            }
        }

        list& _List;
        _Nodeptr _Head; 
        _Nodeptr* _Tail;
    };

    auto remove(const _Ty& _Val) { 
        return remove_if([&](const _Ty& _Other) { return _Other == _Val; });
    }

    template <class _Pr1>
    auto remove_if(_Pr1 _Pred) { 
        auto& _My_data = _Mypair._Myval2;
        _List_node_remove_op _Op(*this);
        const auto _Last         = _My_data._Myhead;
        const size_type _Oldsize = _My_data._Mysize;
        for (auto _First = _Last->_Next; _First != _Last;) {
            auto _Next = _First->_Next;
            if (_Pred(_First->_Myval)) {
                _Op._Transfer_back(_First);
            }

            _First = _Next;
        }


        return _Oldsize - _My_data._Mysize;


#line 1609 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"
    }

    auto unique() { 
        return unique(equal_to<>{});
    }

    template <class _Pr2>
    auto unique(_Pr2 _Pred) { 
        _List_node_remove_op _Op(*this);
        const _Nodeptr _Phead    = _Mypair._Myval2._Myhead;
        _Nodeptr _Pprev          = _Phead->_Next;
        _Nodeptr _Pnode          = _Pprev->_Next;
        const size_type _Oldsize = _Mypair._Myval2._Mysize;
        while (_Pnode != _Phead) {
            if (_Pred(_Pprev->_Myval, _Pnode->_Myval)) { 
                _Pnode = _Op._Transfer_back(_Pnode);
            } else { 
                _Pprev = _Pnode;
                _Pnode = _Pnode->_Next;
            }
        }


        return _Oldsize - _Mypair._Myval2._Mysize;


#line 1636 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"
    }

    void merge(list& _Right) { 
        _Merge1(_Right, less<>{});
    }

    void merge(list&& _Right) { 
        _Merge1(_Right, less<>{});
    }

    template <class _Pr2>
    void merge(list& _Right, _Pr2 _Pred) { 
        _Merge1(_Right, _Pass_fn(_Pred));
    }

    template <class _Pr2>
    void merge(list&& _Right, _Pr2 _Pred) { 
        _Merge1(_Right, _Pass_fn(_Pred));
    }

private:
    template <class _Pr2>
    void _Merge1(list& _Right, _Pr2 _Pred) { 


#line 1662 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"
        if (this == ::std:: addressof(_Right)) {
            return;
        }


#line 1672 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"

        const auto _Right_size = _Right._Mypair._Myval2._Mysize;
        if (_Right_size == 0) {
            
            return;
        }

        
        const auto _Myhead     = _Mypair._Myval2._Myhead;
        const auto _Right_head = _Right._Mypair._Myval2._Myhead;
        const auto _Mid        = _Right_head->_Next;
        _Splice(_Myhead, _Right, _Mid, _Right_head, _Right_size);

        
        if (_Myhead->_Next != _Mid) {
            _Scary_val::_Merge_same(_Myhead->_Next, _Mid, _Myhead, _Pred);
        }
    }

public:
    void sort() { 
        sort(less<>{});
    }

    template <class _Pr2>
    void sort(_Pr2 _Pred) { 
        auto& _My_data = _Mypair._Myval2;
        _Scary_val::_Sort(_My_data._Myhead->_Next, _My_data._Mysize, _Pass_fn(_Pred));
    }

    void reverse() noexcept { 
        const _Nodeptr _Phead = _Mypair._Myval2._Myhead;
        _Nodeptr _Pnode       = _Phead;

        for (;;) { 
            const _Nodeptr _Pnext = _Pnode->_Next;
            _Pnode->_Next         = _Pnode->_Prev;
            _Pnode->_Prev         = _Pnext;

            if (_Pnext == _Phead) {
                break;
            }

            _Pnode = _Pnext;
        }
    }

private:
    _Nodeptr _Splice(
        const _Nodeptr _Where, list& _Right, const _Nodeptr _First, const _Nodeptr _Last, const size_type _Count) {
        
        if (this != ::std:: addressof(_Right)) { 


#line 1729 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"

            auto& _My_data = _Mypair._Myval2;
            if (max_size() - _My_data._Mysize < _Count) {
                _Xlength_error("list too long");
            }

            auto& _Right_data = _Right._Mypair._Myval2;


#line 1746 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"

            _My_data._Mysize += _Count;
            _Right_data._Mysize -= _Count;
        }

        return _Scary_val::_Unchecked_splice(_Where, _First, _Last);
    }

    void _Alloc_sentinel_and_proxy() {
        auto&& _Alproxy = _Fake_alloc;
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
        auto& _Al     = _Getal();
        auto _Newhead = _Al.allocate(1);
        _Construct_in_place(_Newhead->_Next, _Newhead);
        _Construct_in_place(_Newhead->_Prev, _Newhead);
        _Mypair._Myval2._Myhead = _Newhead;
        _Proxy._Release();
    }

    void _Orphan_all() noexcept {
        _Mypair._Myval2._Orphan_all();
    }

    _Alnode& _Getal() noexcept {
        return _Mypair._Get_first();
    }

    const _Alnode& _Getal() const noexcept {
        return _Mypair._Get_first();
    }

    _Compressed_pair<_Alnode, _Scary_val> _Mypair;
};


template <class _Iter, class _Alloc = allocator<_Iter_value_t<_Iter>>,
    enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
list(_Iter, _Iter, _Alloc = _Alloc()) -> list<_Iter_value_t<_Iter>, _Alloc>;
#line 1785 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"

template <class _Ty, class _Alloc>
void swap(list<_Ty, _Alloc>& _Left, list<_Ty, _Alloc>& _Right) noexcept  {
    _Left.swap(_Right);
}

template <class _Ty, class _Alloc>
[[nodiscard]] bool operator==(const list<_Ty, _Alloc>& _Left, const list<_Ty, _Alloc>& _Right) {
    return _Left.size() == _Right.size()
        && ::std:: equal(_Left._Unchecked_begin(), _Left._Unchecked_end(), _Right._Unchecked_begin());
}


#line 1803 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"


template <class _Ty, class _Alloc>
[[nodiscard]] _Synth_three_way_result<_Ty> operator<=>(const list<_Ty, _Alloc>& _Left, const list<_Ty, _Alloc>& _Right) {
    return ::std:: lexicographical_compare_three_way(_Left._Unchecked_begin(), _Left._Unchecked_end(),
        _Right._Unchecked_begin(), _Right._Unchecked_end(), _Synth_three_way{});
}


#line 1832 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"


template <class _Ty, class _Alloc, class _Uty>
typename list<_Ty, _Alloc>::size_type erase(list<_Ty, _Alloc>& _Cont, const _Uty& _Val) {
    return _Cont.remove_if([&](_Ty& _Elem) { return _Elem == _Val; });
}

template <class _Ty, class _Alloc, class _Pr>
typename list<_Ty, _Alloc>::size_type erase_if(list<_Ty, _Alloc>& _Cont, _Pr _Pred) {
    return _Cont.remove_if(_Pass_fn(_Pred));
}
#line 1844 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"


namespace pmr {
    template <class _Ty>
    using list = ::std:: list<_Ty, polymorphic_allocator<_Ty>>;
} 
#line 1851 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"
}


#pragma warning(pop)
#pragma pack(pop)
#line 1857 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"
#line 1858 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\list"
#line 15 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xhash"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xnode_handle.h"


#pragma once


#line 16 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xnode_handle.h"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {

template <class _Iterator, class _NodeType>
struct _Insert_return_type {
    _Iterator position;
    bool inserted;
    _NodeType node;
};

template <class _Derived_type, class _KeyTy, class _ValueTy>
struct _Node_handle_map_base { 
    using key_type    = _KeyTy;
    using mapped_type = _ValueTy;

    key_type& key() const noexcept  {
        return _Datum().first;
    }
    mapped_type& mapped() const noexcept  {
        return _Datum().second;
    }

private:
    using _Pair_type = pair<key_type, mapped_type>;
    _Pair_type& _Datum() const {
        const auto& _Self = static_cast<const _Derived_type&>(*this);
        auto& _Data       = _Self._Getptr()->_Myval;
        
        
        return reinterpret_cast<_Pair_type&>(_Data);
    }
};

template <class _Derived_type, class _ValueTy>
struct _Node_handle_set_base { 
    using value_type = _ValueTy;

    value_type& value() const noexcept  {
        const auto& _Self = static_cast<const _Derived_type&>(*this);
        return _Self._Getptr()->_Myval;
    }
};

template <class _Node, class _Alloc, template <class...> class _Base, class... _Types>
class _Node_handle : public _Base<_Node_handle<_Node, _Alloc, _Base, _Types...>, _Types...> {
    
public:
    using allocator_type = _Alloc;

private:
    using _Alty_traits   = allocator_traits<_Alloc>;
    using _Alnode        = _Rebind_alloc_t<_Alloc, _Node>;
    using _Alnode_traits = allocator_traits<_Alnode>;
    using _Nodeptr       = typename _Alnode_traits::pointer;

    _Nodeptr _Ptr{};
    aligned_union_t<0, _Alloc> _Alloc_storage; 

    void _Clear() noexcept { 
        if (_Ptr != nullptr) {
            _Alloc& _Al = _Getal();
            _Alty_traits::destroy(_Al, ::std:: addressof(_Ptr->_Myval));
            _Alnode _Node_alloc{_Al};
            _Node::_Freenode0(_Node_alloc, _Ptr);
            _Destroy_in_place(_Al);
            _Ptr = nullptr;
        }
    }

    _Node_handle(const _Nodeptr _Ptr_, const _Alloc& _Al) noexcept
        : _Ptr{_Ptr_} { 
                        
        ;
        _Construct_in_place(_Getal(), _Al);
    }

public:
    constexpr _Node_handle() noexcept : _Alloc_storage{} {}

    ~_Node_handle() noexcept {
        _Clear();
    }

    _Node_handle(_Node_handle&& _That) noexcept : _Ptr{_That._Ptr} { 
        if (_Ptr != nullptr) {
            _That._Ptr       = nullptr;
            _Alloc& _That_al = _That._Getal();
            _Construct_in_place(_Getal(), ::std:: move(_That_al));
            _Destroy_in_place(_That_al);
        }
    }

    _Node_handle& operator=(_Node_handle&& _That) noexcept  {
        
        if (_Ptr == nullptr) {
            if (_That._Ptr != nullptr) {
                _Alloc& _That_al = _That._Getal();
                _Construct_in_place(_Getal(), ::std:: move(_That_al));
                _Destroy_in_place(_That_al);
                _Ptr = ::std:: exchange(_That._Ptr, nullptr);
            }

            return *this;
        }

        if (_That._Ptr == nullptr || this == ::std:: addressof(_That)) {
            _Clear();
            return *this;
        }

        _Alloc& _Al = _Getal();
        _Alty_traits::destroy(_Al, ::std:: addressof(_Ptr->_Myval));
        _Alnode _Node_alloc{_Al};
        _Alnode_traits::deallocate(_Node_alloc, _Ptr, 1);

        _Alloc& _That_al = _That._Getal();
        _Pocma(_Al, _That_al);
        _Destroy_in_place(_That_al);

        _Ptr = ::std:: exchange(_That._Ptr, nullptr);
        return *this;
    }

    _Nodeptr _Getptr() const noexcept {
        return _Ptr;
    }

    _Alloc& _Getal() noexcept {
        return reinterpret_cast<_Alloc&>(_Alloc_storage);
    }
    const _Alloc& _Getal() const noexcept {
        ;
        return reinterpret_cast<const _Alloc&>(_Alloc_storage);
    }

    [[nodiscard]] allocator_type get_allocator() const noexcept  {
        ;
        return _Getal();
    }

    explicit operator bool() const noexcept {
        return _Ptr != nullptr;
    }

    [[nodiscard]] bool empty() const noexcept {
        return _Ptr == nullptr;
    }

    _Nodeptr _Release() noexcept { 
        ;
        _Destroy_in_place(_Getal());
        return ::std:: exchange(_Ptr, nullptr);
    }

    void swap(_Node_handle& _That) noexcept  {
        if (_Ptr != nullptr) {
            if (_That._Ptr != nullptr) {
                _Pocs(_Getal(), _That._Getal());
            } else {
                _Alloc& _Al = _Getal();
                _Construct_in_place(_That._Getal(), ::std:: move(_Al));
                _Destroy_in_place(_Al);
            }
        } else {
            if (_That._Ptr == nullptr) {
                return;
            }

            _Alloc& _That_al = _That._Getal();
            _Construct_in_place(_Getal(), ::std:: move(_That_al));
            _Destroy_in_place(_That_al);
        }
        _Swap_adl(_Ptr, _That._Ptr);
    }
    friend void swap(_Node_handle& _Left, _Node_handle& _Right) noexcept  {
        _Left.swap(_Right);
    }

    static _Node_handle _Make(const _Nodeptr _Ptr, const allocator_type& _Al) {
        
        
        ;
        return _Node_handle{_Ptr, _Al};
    }
};

}


#pragma warning(pop)
#pragma pack(pop)
#line 214 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xnode_handle.h"
#line 215 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xnode_handle.h"
#line 22 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xhash"
#line 23 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xhash"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace stdext {
    using ::std:: basic_string;
    using ::std:: less;
    using ::std:: size_t;

    template <class _Kty>
    [[nodiscard]] size_t hash_value(const _Kty& _Keyval) noexcept {
        if constexpr (::std:: is_pointer_v<_Kty> || ::std:: is_null_pointer_v<_Kty>) {
            return reinterpret_cast<size_t>(_Keyval) ^ 0xdeadbeefu;
        } else {
            return static_cast<size_t>(_Keyval) ^ 0xdeadbeefu;
        }
    }

    template <class _Elem, class _Traits, class _Alloc>
    [[nodiscard]] size_t hash_value(const basic_string<_Elem, _Traits, _Alloc>& _Str) noexcept {
        return ::std:: _Hash_array_representation(_Str.c_str(), _Str.size());
    }

    [[nodiscard]] inline size_t hash_value(  const char* _Str) noexcept {
        return ::std:: _Hash_array_representation(_Str, :: strlen(_Str));
    }

    [[nodiscard]] inline size_t hash_value(  const wchar_t* _Str) noexcept {
        return ::std:: _Hash_array_representation(_Str, :: wcslen(_Str));
    }

    template <class _Kty, class _Pr = less<_Kty>>
    class hash_compare { 
    public:
        enum { 
            bucket_size = 1 
        };

        hash_compare() = default;
        hash_compare(const _Pr& _Pred) noexcept(::std:: is_nothrow_copy_constructible_v<_Pr>) : comp(_Pred) {}

        [[nodiscard]] size_t operator()(const _Kty& _Keyval) const noexcept(noexcept(hash_value(_Keyval))) {
            long _Quot   = static_cast<long>(hash_value(_Keyval) & 2147483647L); 
            ldiv_t _Qrem = :: ldiv(_Quot, 127773);

            _Qrem.rem = 16807 * _Qrem.rem - 2836 * _Qrem.quot;
            if (_Qrem.rem < 0) {
                _Qrem.rem += 2147483647L;
            }

            return static_cast<size_t>(_Qrem.rem);
        }

        [[nodiscard]] bool operator()(const _Kty& _Keyval1, const _Kty& _Keyval2) const
            noexcept(noexcept(comp(_Keyval1, _Keyval2))) {
            
            return comp(_Keyval1, _Keyval2);
        }

        _Pr comp{}; 
    };
} 

namespace std {
using stdext::hash_compare; 

template <class _Kty, class _Hasher, class _Keyeq, class = void>
struct _Uhash_choose_transparency {
    
    template <class>
    using _Deduce_key = const _Kty&;
};


template <class _Kty, class _Hasher, class _Keyeq>
struct _Uhash_choose_transparency<_Kty, _Hasher, _Keyeq,
    void_t<typename _Hasher::is_transparent, typename _Keyeq::is_transparent>> {
    
    template <class _Keyty>
    using _Deduce_key = const _Keyty&;

    using _Transparent = void;
};
#line 111 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xhash"

template <class _Hasher, class _Kty>
inline constexpr bool _Nothrow_hash = noexcept(
    static_cast<size_t>(::std:: declval<const _Hasher&>()(::std:: declval<const _Kty&>())));

template <class _Kty, class _Hasher, class _Keyeq>
class _Uhash_compare
    : public _Uhash_choose_transparency<_Kty, _Hasher, _Keyeq> { 
public:
    enum { 
        bucket_size = 1 
    };

    _Uhash_compare() noexcept(
        conjunction_v<is_nothrow_default_constructible<_Hasher>, is_nothrow_default_constructible<_Keyeq>>)
        : _Mypair(_Zero_then_variadic_args_t{}, _Zero_then_variadic_args_t{}, 0.0f) {}

    explicit _Uhash_compare(const _Hasher& _Hasharg) noexcept(
        conjunction_v<is_nothrow_copy_constructible<_Hasher>, is_nothrow_default_constructible<_Keyeq>>)
        : _Mypair(_One_then_variadic_args_t{}, _Hasharg, _Zero_then_variadic_args_t{}, 0.0f) {}

    explicit _Uhash_compare(const _Hasher& _Hasharg, const _Keyeq& _Keyeqarg) noexcept(
        conjunction_v<is_nothrow_copy_constructible<_Hasher>, is_nothrow_copy_constructible<_Keyeq>>)
        : _Mypair(_One_then_variadic_args_t{}, _Hasharg, _One_then_variadic_args_t{}, _Keyeqarg, 0.0f) {}

    template <class _Keyty>
    [[nodiscard]] size_t operator()(const _Keyty& _Keyval) const noexcept(_Nothrow_hash<_Hasher, _Keyty>) {
        
        return static_cast<size_t>(_Mypair._Get_first()(_Keyval));
    }

    template <class _Keyty1, class _Keyty2>
    [[nodiscard]] bool operator()(const _Keyty1& _Keyval1, const _Keyty2& _Keyval2) const
        noexcept(_Nothrow_compare<_Keyeq, _Keyty1, _Keyty2>) {
        
        return !static_cast<bool>(_Mypair._Myval2._Get_first()(_Keyval1, _Keyval2));
    }

    [[nodiscard]] float& _Get_max_bucket_size() noexcept {
        return _Mypair._Myval2._Myval2;
    }

    [[nodiscard]] const float& _Get_max_bucket_size() const noexcept {
        return _Mypair._Myval2._Myval2;
    }

    void swap(_Uhash_compare& _Rhs) noexcept(
        conjunction_v<_Is_nothrow_swappable<_Hasher>, _Is_nothrow_swappable<_Keyeq>>) {
        _Swap_adl(_Mypair._Get_first(), _Rhs._Mypair._Get_first());
        auto& _Lsecond = _Mypair._Myval2;
        auto& _Rsecond = _Rhs._Mypair._Myval2;
        _Swap_adl(_Lsecond._Get_first(), _Rsecond._Get_first());
        ::std:: swap(_Lsecond._Myval2, _Rsecond._Myval2);
    }

    _Compressed_pair<_Hasher, _Compressed_pair<_Keyeq, float>> _Mypair;
};

template <class _Iter, class _Val>
struct _Reinterpret_move_iter {
    _Iter _Base;

    using iterator_category = input_iterator_tag;
    using value_type        = typename iterator_traits<_Iter>::value_type;
    using difference_type   = typename iterator_traits<_Iter>::difference_type;
    using reference         = _Val&&;
    

    reference operator*() const {
        return static_cast<reference>(reinterpret_cast<_Val&>(*_Base));
    }

    _Reinterpret_move_iter& operator++() {
        ++_Base;
        return *this;
    }

    
    [[nodiscard]] friend bool operator==(const _Reinterpret_move_iter& _Lhs, const _Reinterpret_move_iter& _Rhs) {
        return _Lhs._Base == _Rhs._Base;
    }


#line 199 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xhash"
};

template <class _Alnode>
struct _List_head_construct_ptr {
    using value_type = typename _Alnode::value_type;
    static_assert(_Is_specialization_v<value_type, _List_node>, "_List_head_construct_ptr allocator not rebound");
    using _Alnode_traits = allocator_traits<_Alnode>;
    using pointer        = typename _Alnode_traits::pointer;
    _Alnode& _Al;
    pointer _Newhead;

    explicit _List_head_construct_ptr(_Alnode& _Al_) : _Al(_Al_), _Newhead(value_type::_Buyheadnode(_Al)) {}

    template <class _Val_types>
    _List_head_construct_ptr(_Alnode& _Al_, _List_val<_Val_types>& _Mycont)
        : _Al(_Al_), _Newhead(value_type::_Buyheadnode(_Al)) {
        _Mycont._Myhead = _Newhead;
    }

    _List_head_construct_ptr(const _List_head_construct_ptr&) = delete;
    _List_head_construct_ptr& operator=(const _List_head_construct_ptr&) = delete;

    [[nodiscard]] pointer _Release() noexcept {
        return ::std:: exchange(_Newhead, nullptr);
    }

    ~_List_head_construct_ptr() {
        if (_Newhead) {
            value_type::_Freenode0(_Al, _Newhead);
        }
    }
};

template <class _Nodeptr>
struct _Hash_find_last_result {
    _Nodeptr _Insert_before;
    _Nodeptr _Duplicate;
};

template <class _Aliter>
struct _Hash_vec {
    
    using _Aliter_traits    = allocator_traits<_Aliter>;
    using value_type        = typename _Aliter::value_type;
    using size_type         = typename _Aliter_traits::size_type;
    using difference_type   = typename _Aliter_traits::difference_type;
    using pointer           = typename _Aliter_traits::pointer;
    using _Aliter_scary_val = _Vector_val<conditional_t<_Is_simple_alloc_v<_Aliter>, _Simple_types<value_type>,
        _Vec_iter_types<value_type, size_type, difference_type, pointer, typename _Aliter_traits::const_pointer,
            value_type&, const value_type&>>>;

    _Hash_vec() : _Mypair(_Zero_then_variadic_args_t{}) {
        _Mypair._Myval2._Alloc_proxy(_Fake_alloc);
    }

    template <class _Any_alloc, enable_if_t<!is_same_v<_Remove_cvref_t<_Any_alloc>, _Hash_vec>, int> = 0>
    explicit _Hash_vec(_Any_alloc&& _Al) noexcept
        : _Mypair(_One_then_variadic_args_t{}, ::std:: forward<_Any_alloc>(_Al)) { 
        _Mypair._Myval2._Alloc_proxy(_Fake_alloc);
    }

    _Hash_vec(const _Hash_vec&) = delete;
    _Hash_vec& operator=(const _Hash_vec&) = delete;

    [[nodiscard]] size_type size() const noexcept {
        return static_cast<size_type>(_Mypair._Myval2._Mylast - _Mypair._Myval2._Myfirst);
    }

    [[nodiscard]] size_type max_size() const noexcept {
        return (::std:: min)(static_cast<size_type>((numeric_limits<difference_type>::max)()),
            _Aliter_traits::max_size(_Mypair._Get_first()));
    }

    void _Assign_grow(const size_type _Cells, const value_type _Val) {
        
        const auto _Oldsize = size();
        ;
        auto& _Alvec = _Mypair._Get_first();
        if (_Oldsize < _Cells) {
            const auto _Newvec = _Alvec.allocate(_Cells); 
            
            if (_Oldsize != 0) {
                _Destroy_range(_Mypair._Myval2._Myfirst, _Mypair._Myval2._Mylast);
                _Alvec.deallocate(_Mypair._Myval2._Myfirst, _Oldsize);
            }

            _Mypair._Myval2._Myfirst = _Newvec;
            const auto _Newend       = _Newvec + _Cells;
            _Mypair._Myval2._Mylast  = _Newend;
            _Mypair._Myval2._Myend   = _Newend;
            ::std:: uninitialized_fill(_Newvec, _Newend, _Val);
        } else {
            ::std:: fill(_Mypair._Myval2._Myfirst, _Mypair._Myval2._Mylast, _Val);
        }
    }

    void _Tidy() noexcept {
        _Destroy_range(_Mypair._Myval2._Myfirst, _Mypair._Myval2._Mylast);
        _Mypair._Get_first().deallocate(_Mypair._Myval2._Myfirst, size());
        _Mypair._Myval2._Myfirst = nullptr;
        _Mypair._Myval2._Mylast  = nullptr;
        _Mypair._Myval2._Myend   = nullptr;
    }

    ~_Hash_vec() {
        _Tidy();


#line 309 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xhash"
    }

    _Compressed_pair<_Aliter, _Aliter_scary_val> _Mypair;
};

template <class _Traits>
class _Hash { 
protected:
    using _Mylist             = list<typename _Traits::value_type, typename _Traits::allocator_type>;
    using _Alnode             = typename _Mylist::_Alnode;
    using _Alnode_traits      = typename _Mylist::_Alnode_traits;
    using _Node               = typename _Mylist::_Node;
    using _Nodeptr            = typename _Mylist::_Nodeptr;
    using _Mutable_value_type = typename _Traits::_Mutable_value_type;

    using _Key_compare   = typename _Traits::key_compare;
    using _Value_compare = typename _Traits::value_compare;

public:
    using key_type = typename _Traits::key_type;

    using value_type      = typename _Mylist::value_type;
    using allocator_type  = typename _Mylist::allocator_type;
    using size_type       = typename _Mylist::size_type;
    using difference_type = typename _Mylist::difference_type;
    using pointer         = typename _Mylist::pointer;
    using const_pointer   = typename _Mylist::const_pointer;
    using reference       = value_type&;
    using const_reference = const value_type&;

    using iterator =
        conditional_t<is_same_v<key_type, value_type>, typename _Mylist::const_iterator, typename _Mylist::iterator>;
    using const_iterator = typename _Mylist::const_iterator;

    using _Unchecked_iterator       = conditional_t<is_same_v<key_type, value_type>,
        typename _Mylist::_Unchecked_const_iterator, typename _Mylist::_Unchecked_iterator>;
    using _Unchecked_const_iterator = typename _Mylist::_Unchecked_const_iterator;

    using _Aliter = _Rebind_alloc_t<_Alnode, _Unchecked_iterator>;

    static constexpr size_type _Bucket_size = _Key_compare::bucket_size;
    static constexpr size_type _Min_buckets = 8; 
    static constexpr bool _Multi            = _Traits::_Multi;

    template <class _TraitsT>
    friend bool _Hash_equal(const _Hash<_TraitsT>& _Left, const _Hash<_TraitsT>& _Right);

protected:
    _Hash(const _Key_compare& _Parg, const allocator_type& _Al)
        : _Traitsobj(_Parg), _List(_Al), _Vec(_Al), _Mask(_Min_buckets - 1), _Maxidx(_Min_buckets) {
        
        _Max_bucket_size() = _Bucket_size;
        _Vec._Assign_grow(_Min_buckets * 2, _List._Unchecked_end());


    }

    template <class _Any_alloc>
    _Hash(const _Hash& _Right, const _Any_alloc& _Al)
        : _Traitsobj(_Right._Traitsobj), _List(static_cast<allocator_type>(_Al)), _Vec(_Al), _Mask(_Right._Mask),
          _Maxidx(_Right._Maxidx) {
        
        _Vec._Assign_grow(_Right._Vec.size(), _List._Unchecked_end());
        insert(_Right._Unchecked_begin(), _Right._Unchecked_end());


    }

    _Hash(_Hash&& _Right)
        : _Traitsobj(_Right._Traitsobj), _List(_Move_allocator_tag{}, _Right._List._Getal()),
          _Vec(::std:: move(_Right._Vec._Mypair._Get_first())) {
        _Vec._Assign_grow(_Min_buckets * 2, _Unchecked_end());
        _List._Swap_val(_Right._List);
        _Vec._Mypair._Myval2._Swap_val(_Right._Vec._Mypair._Myval2);
        _Mask   = ::std:: exchange(_Right._Mask, _Min_buckets - 1);
        _Maxidx = ::std:: exchange(_Right._Maxidx, _Min_buckets);


    }

private:
    void _Move_construct_equal_alloc(_Hash& _Right) {
        _Vec._Assign_grow(_Min_buckets * 2, _Unchecked_end());
        _List._Swap_val(_Right._List);
        _Vec._Mypair._Myval2._Swap_val(_Right._Vec._Mypair._Myval2);
        _Mask   = ::std:: exchange(_Right._Mask, _Min_buckets - 1);
        _Maxidx = ::std:: exchange(_Right._Maxidx, _Min_buckets);
    }

public:
    _Hash(_Hash&& _Right, const allocator_type& _Al) : _Traitsobj(_Right._Traitsobj), _List(_Al), _Vec(_Al) {
        
        if constexpr (_Alnode_traits::is_always_equal::value) {
            _Move_construct_equal_alloc(_Right);
        } else if (_List._Getal() == _Right._List._Getal()) {
            _Move_construct_equal_alloc(_Right);
        } else {
            _Maxidx            = _Min_buckets;
            const auto _Myhead = _List._Mypair._Myval2._Myhead;
            for (auto& _Val : _Right._List) {
                _List._Emplace(_Myhead, reinterpret_cast<_Mutable_value_type&&>(_Val));
            }
            _Reinsert_with_invalid_vec();
            _Right.clear();
        }


    }

private:
    void _Swap_val(_Hash& _Right) noexcept { 
        _List._Swap_val(_Right._List);
        _Vec._Mypair._Myval2._Swap_val(_Right._Vec._Mypair._Myval2);
        ::std:: swap(_Mask, _Right._Mask);
        ::std:: swap(_Maxidx, _Right._Maxidx);
    }

    struct _Min_buckets_construct_ptr {
        using pointer = typename allocator_traits<_Aliter>::pointer;
        _Aliter& _Al;
        pointer _Base;
        _Min_buckets_construct_ptr(_Aliter& _Al_) : _Al(_Al_), _Base(_Al.allocate(_Min_buckets * 2)) {}
        _Min_buckets_construct_ptr(const _Min_buckets_construct_ptr&) = delete;
        [[nodiscard]] pointer _Release(_Unchecked_iterator _Newend) noexcept {
            ::std:: uninitialized_fill(_Base, _Base + _Min_buckets * 2, _Newend);
            return ::std:: exchange(_Base, nullptr);
        }
        ~_Min_buckets_construct_ptr() {
            if (_Base) {
                _Al.deallocate(_Base, _Min_buckets * 2);
            }
        }
    };

    void _Pocma_both(_Hash& _Right) {
        _Pocma(_List._Getal(), _Right._List._Getal());
        _Pocma(_Vec._Mypair._Get_first(), _Right._Vec._Mypair._Get_first());
    }

    struct [[nodiscard]] _Clear_guard {
        _Hash* _Target;

        explicit _Clear_guard(_Hash* const _Target_) : _Target(_Target_) {}

        _Clear_guard(const _Clear_guard&) = delete;
        _Clear_guard& operator=(const _Clear_guard&) = delete;

        ~_Clear_guard() {
            if (_Target) {
                _Target->clear();
            }
        }
    };


public:
    _Hash& operator=(_Hash&& _Right) { 
        if (this == ::std:: addressof(_Right)) {
            return *this;
        }


        auto& _Al                 = _Getal();
        auto& _Right_al           = _Right._Getal();
        constexpr auto _Pocma_val = _Choose_pocma_v<_Alnode>;
        if constexpr (_Pocma_val == _Pocma_values::_Propagate_allocators) {
            if (_Al != _Right_al) {
                
                auto&& _Alproxy       = _Fake_alloc;
                auto&& _Right_alproxy = _Fake_alloc;
                _Container_proxy_ptr<_Alnode> _List_proxy(_Right_alproxy, _Leave_proxy_unbound{});
                _Container_proxy_ptr<_Alnode> _Vec_proxy(_Right_alproxy, _Leave_proxy_unbound{});
                _List_head_construct_ptr<_Alnode> _Newhead(_Right_al);
                _Min_buckets_construct_ptr _Buckets(_Right._Vec._Mypair._Get_first());

                
                _Traitsobj = _Right._Traitsobj;

                
                _List._Tidy();
                _Vec._Tidy();
                _Pocma_both(_Right);

                
                auto& _List_data       = _List._Mypair._Myval2;
                auto& _Right_list_data = _Right._List._Mypair._Myval2;
                _List_data._Myhead     = ::std:: exchange(_Right_list_data._Myhead, _Newhead._Release());
                _List_data._Mysize     = ::std:: exchange(_Right_list_data._Mysize, size_type{0});
                _List_proxy._Bind(_Alproxy, ::std:: addressof(_List_data));
                _List_data._Swap_proxy_and_iterators(_Right_list_data);

                
                auto& _Vec_data       = _Vec._Mypair._Myval2;
                auto& _Right_vec_data = _Right._Vec._Mypair._Myval2;

                const auto _Newfirst = _Buckets._Release(_Right._Unchecked_end());
                const auto _Newlast  = _Newfirst + _Min_buckets * 2;

                _Vec_data._Myfirst = ::std:: exchange(_Right_vec_data._Myfirst, _Newfirst);
                _Vec_data._Mylast  = ::std:: exchange(_Right_vec_data._Mylast, _Newlast);
                _Vec_data._Myend   = ::std:: exchange(_Right_vec_data._Myend, _Newlast);
                _Vec_proxy._Bind(_Alproxy, ::std:: addressof(_Vec_data));
                _Vec_data._Swap_proxy_and_iterators(_Right_vec_data);

                
                _Mask   = ::std:: exchange(_Right._Mask, _Min_buckets - 1);
                _Maxidx = ::std:: exchange(_Right._Maxidx, _Min_buckets);

                return *this;
            }
        } else if constexpr (_Pocma_val == _Pocma_values::_No_propagate_allocators) {
            if (_Al != _Right_al) {
                _Clear_guard _Guard{this};
                _Traitsobj     = _Right._Traitsobj;
                using _Adapter = _Reinterpret_move_iter<typename _Mylist::_Unchecked_iterator, _Mutable_value_type>;
                _List.template _Assign_cast<_Mutable_value_type&>(
                    _Adapter{_Right._List._Unchecked_begin()}, _Adapter{_Right._List._Unchecked_end()});
                _Reinsert_with_invalid_vec();
                _Guard._Target = nullptr;

                return *this;
            }
        }

        clear();
        _Traitsobj = _Right._Traitsobj;
        _Pocma_both(_Right);
        _Swap_val(_Right);

        return *this;
    }

    template <class... _Valtys>
    conditional_t<_Multi, iterator, pair<iterator, bool>> emplace(_Valtys&&... _Vals) {
        
        using _In_place_key_extractor = typename _Traits::template _In_place_key_extractor<_Remove_cvref_t<_Valtys>...>;
        if constexpr (_Multi) {
            _Check_max_size();
            _List_node_emplace_op2<_Alnode> _Newnode(_List._Getal(), ::std:: forward<_Valtys>(_Vals)...);
            const auto& _Keyval = _Traits::_Kfn(_Newnode._Ptr->_Myval);
            const auto _Hashval = _Traitsobj(_Keyval);
            if (_Check_rehash_required_1()) {
                _Rehash_for_1();
            }

            const auto _Target = _Find_last(_Keyval, _Hashval);
            return _List._Make_iter(_Insert_new_node_before(_Hashval, _Target._Insert_before, _Newnode._Release()));
        } else if constexpr (_In_place_key_extractor::_Extractable) {
            const auto& _Keyval = _In_place_key_extractor::_Extract(_Vals...);
            const auto _Hashval = _Traitsobj(_Keyval);
            auto _Target        = _Find_last(_Keyval, _Hashval);
            if (_Target._Duplicate) {
                return {_List._Make_iter(_Target._Duplicate), false};
            }

            _Check_max_size();
            
            _List_node_emplace_op2<_Alnode> _Newnode(_List._Getal(), ::std:: forward<_Valtys>(_Vals)...);
            if (_Check_rehash_required_1()) {
                _Rehash_for_1();
                _Target = _Find_last(_Traits::_Kfn(_Newnode._Ptr->_Myval), _Hashval);
            }

            return {
                _List._Make_iter(_Insert_new_node_before(_Hashval, _Target._Insert_before, _Newnode._Release())), true};
        } else {
            _List_node_emplace_op2<_Alnode> _Newnode(_List._Getal(), ::std:: forward<_Valtys>(_Vals)...);
            const auto& _Keyval = _Traits::_Kfn(_Newnode._Ptr->_Myval);
            const auto _Hashval = _Traitsobj(_Keyval);
            auto _Target        = _Find_last(_Keyval, _Hashval);
            if (_Target._Duplicate) {
                return {_List._Make_iter(_Target._Duplicate), false};
            }

            _Check_max_size();
            if (_Check_rehash_required_1()) {
                _Rehash_for_1();
                _Target = _Find_last(_Traits::_Kfn(_Newnode._Ptr->_Myval), _Hashval);
            }

            return {
                _List._Make_iter(_Insert_new_node_before(_Hashval, _Target._Insert_before, _Newnode._Release())), true};
        }
    }

    template <class... _Valtys>
    iterator emplace_hint(const_iterator _Hint, _Valtys&&... _Vals) { 
        using _In_place_key_extractor = typename _Traits::template _In_place_key_extractor<_Remove_cvref_t<_Valtys>...>;
        if constexpr (_Multi) {
            _Check_max_size();
            _List_node_emplace_op2<_Alnode> _Newnode(_List._Getal(), ::std:: forward<_Valtys>(_Vals)...);
            const auto& _Keyval = _Traits::_Kfn(_Newnode._Ptr->_Myval);
            const auto _Hashval = _Traitsobj(_Keyval);
            if (_Check_rehash_required_1()) {
                _Rehash_for_1();
            }

            const auto _Target = _Find_hint(_Hint._Ptr, _Keyval, _Hashval);
            return _List._Make_iter(_Insert_new_node_before(_Hashval, _Target._Insert_before, _Newnode._Release()));
        } else if constexpr (_In_place_key_extractor::_Extractable) {
            const auto& _Keyval = _In_place_key_extractor::_Extract(_Vals...);
            const auto _Hashval = _Traitsobj(_Keyval);
            auto _Target        = _Find_hint(_Hint._Ptr, _Keyval, _Hashval);
            if (_Target._Duplicate) {
                return _List._Make_iter(_Target._Duplicate);
            }

            _Check_max_size();
            
            _List_node_emplace_op2<_Alnode> _Newnode(_List._Getal(), ::std:: forward<_Valtys>(_Vals)...);
            if (_Check_rehash_required_1()) {
                _Rehash_for_1();
                _Target = _Find_hint(_Hint._Ptr, _Traits::_Kfn(_Newnode._Ptr->_Myval), _Hashval);
            }

            return _List._Make_iter(_Insert_new_node_before(_Hashval, _Target._Insert_before, _Newnode._Release()));
        } else {
            _List_node_emplace_op2<_Alnode> _Newnode(_List._Getal(), ::std:: forward<_Valtys>(_Vals)...);
            const auto& _Keyval = _Traits::_Kfn(_Newnode._Ptr->_Myval);
            const auto _Hashval = _Traitsobj(_Keyval);
            auto _Target        = _Find_hint(_Hint._Ptr, _Keyval, _Hashval);
            if (_Target._Duplicate) {
                return _List._Make_iter(_Target._Duplicate);
            }

            _Check_max_size();
            if (_Check_rehash_required_1()) {
                _Rehash_for_1();
                _Target = _Find_hint(_Hint._Ptr, _Traits::_Kfn(_Newnode._Ptr->_Myval), _Hashval);
            }

            return _List._Make_iter(_Insert_new_node_before(_Hashval, _Target._Insert_before, _Newnode._Release()));
        }
    }

protected:
    template <class _Keyty, class... _Mappedty>
    pair<_Nodeptr, bool> _Try_emplace(_Keyty&& _Keyval_arg, _Mappedty&&... _Mapval) {
        const auto& _Keyval = _Keyval_arg;
        const auto _Hashval = _Traitsobj(_Keyval);
        auto _Target        = _Find_last(_Keyval, _Hashval);
        if (_Target._Duplicate) {
            return {_Target._Duplicate, false};
        }

        _Check_max_size();
        _List_node_emplace_op2<_Alnode> _Newnode(_List._Getal(), piecewise_construct,
            ::std:: forward_as_tuple(::std:: forward<_Keyty>(_Keyval_arg)),
            ::std:: forward_as_tuple(::std:: forward<_Mappedty>(_Mapval)...));
        if (_Check_rehash_required_1()) {
            _Rehash_for_1();
            _Target = _Find_last(_Traits::_Kfn(_Newnode._Ptr->_Myval), _Hashval);
        }

        return {_Insert_new_node_before(_Hashval, _Target._Insert_before, _Newnode._Release()), true};
    }

    template <class _Keyty, class... _Mappedty>
    _Nodeptr _Try_emplace_hint(const _Nodeptr _Hint, _Keyty&& _Keyval_arg, _Mappedty&&... _Mapval) {
        const auto& _Keyval = _Keyval_arg;
        const auto _Hashval = _Traitsobj(_Keyval);
        auto _Target        = _Find_hint(_Hint, _Keyval, _Hashval);
        if (_Target._Duplicate) {
            return _Target._Duplicate;
        }

        _Check_max_size();
        
        _List_node_emplace_op2<_Alnode> _Newnode(_List._Getal(), piecewise_construct,
            ::std:: forward_as_tuple(::std:: forward<_Keyty>(_Keyval_arg)),
            ::std:: forward_as_tuple(::std:: forward<_Mappedty>(_Mapval)...));
        if (_Check_rehash_required_1()) {
            _Rehash_for_1();
            _Target = _Find_hint(_Hint, _Traits::_Kfn(_Newnode._Ptr->_Myval), _Hashval);
        }

        return _Insert_new_node_before(_Hashval, _Target._Insert_before, _Newnode._Release());
    }

private:
    void _Pocca_both(const _Hash& _Right) {
        _Pocca(_List._Getal(), _Right._List._Getal());
        _Pocca(_Vec._Mypair._Get_first(), _Right._Vec._Mypair._Get_first());
    }

public:
    _Hash& operator=(const _Hash& _Right) {
        if (this == ::std:: addressof(_Right)) {
            return *this;
        }


        if constexpr (_Choose_pocca_v<_Alnode>) {
            auto& _Al             = _Getal();
            const auto& _Right_al = _Right._Getal();
            if (_Al != _Right_al) {
                auto&& _Alproxy       = _Fake_alloc;
                auto&& _Right_alproxy = _Fake_alloc;
                _Container_proxy_ptr<_Alnode> _Vec_proxy(_Right_alproxy, _Leave_proxy_unbound{});
                _List._Reload_sentinel_and_proxy(_Right._List);
                _Vec._Tidy();
                _Pocca_both(_Right);
                _Vec_proxy._Bind(_Alproxy, ::std:: addressof(_Vec._Mypair._Myval2));

                _Clear_guard _Guard{this};
                _Traitsobj = _Right._Traitsobj;
                _List.template _Assign_cast<_Mutable_value_type&>(
                    _Right._List._Unchecked_begin(), _Right._List._Unchecked_end());
                _Reinsert_with_invalid_vec();
                _Guard._Target = nullptr;

                return *this;
            }
        }

        _Clear_guard _Guard{this};
        _Traitsobj = _Right._Traitsobj;
        _Pocca_both(_Right);
        _List.template _Assign_cast<_Mutable_value_type&>(
            _Right._List._Unchecked_begin(), _Right._List._Unchecked_end());
        _Reinsert_with_invalid_vec();
        _Guard._Target = nullptr;

        return *this;
    }

    [[nodiscard]] iterator begin() noexcept {
        return _List.begin();
    }

    [[nodiscard]] const_iterator begin() const noexcept {
        return _List.begin();
    }

    [[nodiscard]] iterator end() noexcept {
        return _List.end();
    }

    [[nodiscard]] const_iterator end() const noexcept {
        return _List.end();
    }

    _Unchecked_iterator _Unchecked_begin() noexcept {
        return _List._Unchecked_begin();
    }

    _Unchecked_const_iterator _Unchecked_begin() const noexcept {
        return _List._Unchecked_begin();
    }

    _Unchecked_iterator _Unchecked_end() noexcept {
        return _List._Unchecked_end();
    }

    _Unchecked_const_iterator _Unchecked_end() const noexcept {
        return _List._Unchecked_end();
    }

    [[nodiscard]] const_iterator cbegin() const noexcept {
        return begin();
    }

    [[nodiscard]] const_iterator cend() const noexcept {
        return end();
    }

    [[nodiscard]] size_type size() const noexcept {
        return _List.size();
    }

    [[nodiscard]] size_type max_size() const noexcept {
        return _List.max_size();
    }

    [[nodiscard]] bool empty() const noexcept {
        return _List.empty();
    }

    [[nodiscard]] allocator_type get_allocator() const noexcept {
        return static_cast<allocator_type>(_List.get_allocator());
    }

    using local_iterator       = iterator;
    using const_local_iterator = const_iterator;

    [[nodiscard]] size_type bucket_count() const noexcept {
        return _Maxidx;
    }

    [[nodiscard]] size_type max_bucket_count() const noexcept {
        return _Vec.max_size() >> 1;
    }

    [[nodiscard]] size_type bucket(const key_type& _Keyval) const
        noexcept(_Nothrow_hash<_Traits, key_type>)  {
        return _Traitsobj(_Keyval) & _Mask;
    }

    [[nodiscard]] size_type bucket_size(size_type _Bucket) const noexcept  {
        _Unchecked_iterator _Bucket_lo = _Vec._Mypair._Myval2._Myfirst[_Bucket << 1];
        if (_Bucket_lo == _Unchecked_end()) {
            return 0;
        }

        return static_cast<size_type>(::std:: distance(_Bucket_lo, _Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1])) + 1;
    }

    [[nodiscard]] local_iterator begin(size_type _Bucket) noexcept  {
        return _List._Make_iter(_Vec._Mypair._Myval2._Myfirst[_Bucket << 1]._Ptr);
    }

    [[nodiscard]] const_local_iterator begin(size_type _Bucket) const noexcept  {
        return _List._Make_const_iter(_Vec._Mypair._Myval2._Myfirst[_Bucket << 1]._Ptr);
    }

    [[nodiscard]] local_iterator end(size_type _Bucket) noexcept  {
        _Nodeptr _Bucket_hi = _Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1]._Ptr;
        if (_Bucket_hi != _List._Mypair._Myval2._Myhead) {
            _Bucket_hi = _Bucket_hi->_Next;
        }

        return _List._Make_iter(_Bucket_hi);
    }

    [[nodiscard]] const_local_iterator end(size_type _Bucket) const noexcept  {
        _Nodeptr _Bucket_hi = _Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1]._Ptr;
        if (_Bucket_hi != _List._Mypair._Myval2._Myhead) {
            _Bucket_hi = _Bucket_hi->_Next;
        }

        return _List._Make_const_iter(_Bucket_hi);
    }

    [[nodiscard]] const_local_iterator cbegin(size_type _Bucket) const noexcept  {
        return _List._Make_const_iter(_Vec._Mypair._Myval2._Myfirst[_Bucket << 1]._Ptr);
    }

    [[nodiscard]] const_local_iterator cend(size_type _Bucket) const noexcept  {
        _Nodeptr _Bucket_hi = _Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1]._Ptr;
        if (_Bucket_hi != _List._Mypair._Myval2._Myhead) {
            _Bucket_hi = _Bucket_hi->_Next;
        }

        return _List._Make_const_iter(_Bucket_hi);
    }

    [[nodiscard]] float load_factor() const noexcept {
        return static_cast<float>(size()) / static_cast<float>(bucket_count());
    }

    [[nodiscard]] float max_load_factor() const noexcept {
        return _Max_bucket_size();
    }

    void max_load_factor(float _Newmax) noexcept  {
        ;
        _Max_bucket_size() = _Newmax;
    }

    void rehash(size_type _Buckets) { 
        
        _Buckets = (::std:: max)(_Min_load_factor_buckets(_List.size()), _Buckets);
        if (_Buckets <= _Maxidx) { 
            return;
        }

        _Forced_rehash(_Buckets);
    }

    void reserve(size_type _Maxcount) { 
        rehash(static_cast<size_type>(static_cast<float>(_Maxcount) / max_load_factor() + 0.5F));
    }

    conditional_t<_Multi, iterator, pair<iterator, bool>> insert(const value_type& _Val) {
        return emplace(_Val);
    }

    conditional_t<_Multi, iterator, pair<iterator, bool>> insert(value_type&& _Val) {
        return emplace(::std:: move(_Val));
    }

    iterator insert(const_iterator _Hint, const value_type& _Val) {
        return emplace_hint(_Hint, _Val);
    }

    iterator insert(const_iterator _Hint, value_type&& _Val) {
        return emplace_hint(_Hint, ::std:: move(_Val));
    }

    template <class _Iter>
    void insert(_Iter _First, _Iter _Last) {
        _Adl_verify_range(_First, _Last);
        auto _UFirst      = _Get_unwrapped(_First);
        const auto _ULast = _Get_unwrapped(_Last);
        for (; _UFirst != _ULast; ++_UFirst) {
            emplace(*_UFirst);
        }
    }

    void insert(initializer_list<value_type> _Ilist) {
        insert(_Ilist.begin(), _Ilist.end());
    }

private:
    _Nodeptr _Unchecked_erase(_Nodeptr _Plist) noexcept(_Nothrow_hash<_Traits, key_type>) {
        size_type _Bucket = bucket(_Traits::_Kfn(_Plist->_Myval));
        _Erase_bucket(_Plist, _Bucket);
        return _List._Unchecked_erase(_Plist);
    }

    struct _Range_eraser {
        _Range_eraser(const _Range_eraser&) = delete;
        _Range_eraser& operator=(const _Range_eraser&) = delete;


#line 974 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xhash"
      
        _Range_eraser(_Mylist& _List_, const _Nodeptr _First_) noexcept
            : _List(_List_), _Predecessor(_First_->_Prev), _Next(_First_) {}

        void _Bump_erased() noexcept {
            const auto _Oldnext = _Next;
            _Next               = _Oldnext->_Next;
            _Node::_Freenode(_List._Getal(), _Oldnext);
            --_List._Mypair._Myval2._Mysize;
        }

        ~_Range_eraser() noexcept {
            _Predecessor->_Next = _Next;
            _Next->_Prev        = _Predecessor;
        }

        _Mylist& _List;
        const _Nodeptr _Predecessor;
        _Nodeptr _Next;
#line 994 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xhash"
    };

    _Nodeptr _Unchecked_erase(_Nodeptr _First, const _Nodeptr _Last) noexcept(_Nothrow_hash<_Traits, key_type>) {
        if (_First == _Last) {
            return _Last;
        }

        const auto _End           = _List._Mypair._Myval2._Myhead;
        const auto _Bucket_bounds = _Vec._Mypair._Myval2._Myfirst;
        _Range_eraser _Eraser{_List, _First};
        {
            
            const auto _Predecessor = _First->_Prev;
            const size_type _Bucket = bucket(_Traits::_Kfn(_Eraser._Next->_Myval)); 
            
            _Nodeptr& _Bucket_lo   = _Bucket_bounds[_Bucket << 1]._Ptr;
            _Nodeptr& _Bucket_hi   = _Bucket_bounds[(_Bucket << 1) + 1]._Ptr;
            const bool _Update_lo  = _Bucket_lo == _Eraser._Next;
            const _Nodeptr _Old_hi = _Bucket_hi;
            for (;;) { 
                const bool _At_bucket_back = _Eraser._Next == _Old_hi;
                _Eraser._Bump_erased();
                if (_At_bucket_back) {
                    break;
                }

                if (_Eraser._Next == _Last) {
                    if (_Update_lo) {
                        
                        _Bucket_lo = _Eraser._Next;
                    }

                    return _Last;
                }
            }

            if (_Update_lo) {
                
                _Bucket_lo = _End;
                _Bucket_hi = _End;
            } else {
                _Bucket_hi = _Predecessor;
            }
        }

        
        while (_Eraser._Next != _Last) {
            const size_type _Bucket = bucket(_Traits::_Kfn(_Eraser._Next->_Myval)); 
            
            _Nodeptr& _Bucket_lo   = _Bucket_bounds[_Bucket << 1]._Ptr;
            _Nodeptr& _Bucket_hi   = _Bucket_bounds[(_Bucket << 1) + 1]._Ptr;
            const _Nodeptr _Old_hi = _Bucket_hi;
            for (;;) { 
                const bool _At_bucket_back = _Eraser._Next == _Old_hi;
                _Eraser._Bump_erased();
                if (_At_bucket_back) {
                    break;
                }

                if (_Eraser._Next == _Last) {
                    
                    _Bucket_lo = _Eraser._Next;
                    return _Last;
                }
            }

            
            _Bucket_lo = _End;
            _Bucket_hi = _End;
        }

        return _Last;
    }

    template <class _Kx>
    static constexpr bool _Noexcept_heterogeneous_erasure() {
        return _Nothrow_hash<_Traits, _Kx> 
            && (!_Multi || (_Nothrow_compare<_Traits, key_type, _Kx> && _Nothrow_compare<_Traits, _Kx, key_type>) );
    }

    template <class _Keytype>
    size_type _Erase(const _Keytype& _Keyval) noexcept(_Noexcept_heterogeneous_erasure<_Keytype>())  {
        const size_t _Hashval = _Traitsobj(_Keyval);
        if constexpr (_Multi) {
            const auto _Where = _Equal_range(_Keyval, _Hashval);
            _Unchecked_erase(_Where._First._Ptr, _Where._Last._Ptr);
            return _Where._Distance;
        } else {
            const auto _Target = _Find_last(_Keyval, _Hashval)._Duplicate;
            if (_Target) {
                _Erase_bucket(_Target, _Hashval & _Mask);
                _List._Unchecked_erase(_Target);
                return 1;
            }

            return 0;
        }
    }

public:
    template <class _Iter = iterator, enable_if_t<!is_same_v<_Iter, const_iterator>, int> = 0>
    iterator erase(iterator _Plist) noexcept(_Nothrow_hash<_Traits, key_type>)  {
        return _List._Make_iter(_Unchecked_erase(_Plist._Ptr));
    }

    iterator erase(const_iterator _Plist) noexcept(_Nothrow_hash<_Traits, key_type>)  {
        return _List._Make_iter(_Unchecked_erase(_Plist._Ptr));
    }

    iterator erase(const_iterator _First, const_iterator _Last) noexcept(
        _Nothrow_hash<_Traits, key_type>)  {
        return _List._Make_iter(_Unchecked_erase(_First._Ptr, _Last._Ptr));
    }

    size_type erase(const key_type& _Keyval) noexcept(noexcept(_Erase(_Keyval)))  {
        return _Erase(_Keyval);
    }


    template <class _Kx, class _Mytraits = _Traits, class = typename _Mytraits::_Transparent,
        enable_if_t<!disjunction_v<is_convertible<_Kx, const_iterator>, is_convertible<_Kx, iterator>>, int> = 0>
    size_type erase(_Kx&& _Keyval) noexcept(noexcept(_Erase(_Keyval)))  {
        return _Erase(_Keyval);
    }
#line 1119 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xhash"

    void clear() noexcept {
        
        
        const auto _Oldsize = _List._Mypair._Myval2._Mysize;
        if (_Oldsize == 0) {
            return;
        }

        if constexpr (_Nothrow_hash<_Traits, key_type>) {
            
            
            if (bucket_count() / 8 > _Oldsize) {
                const auto _Head = _List._Mypair._Myval2._Myhead;
                _Unchecked_erase(_Head->_Next, _Head);
                return;
            }
        }

        
        _List.clear();
        ::std:: fill(_Vec._Mypair._Myval2._Myfirst, _Vec._Mypair._Myval2._Mylast, _Unchecked_end());
    }

private:
    template <class _Keyty>
    [[nodiscard]] _Nodeptr _Find_first(const _Keyty& _Keyval, const size_t _Hashval) const {
        
        const size_type _Bucket = _Hashval & _Mask;
        _Nodeptr _Where         = _Vec._Mypair._Myval2._Myfirst[_Bucket << 1]._Ptr;
        const _Nodeptr _End     = _List._Mypair._Myval2._Myhead;
        if (_Where == _End) {
            return _End;
        }

        const _Nodeptr _Bucket_hi = _Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1]._Ptr;
        for (;;) {
            if (!_Traitsobj(_Traits::_Kfn(_Where->_Myval), _Keyval)) {
                if constexpr (!_Traits::_Standard) {
                    if (_Traitsobj(_Keyval, _Traits::_Kfn(_Where->_Myval))) {
                        return _End;
                    }
                }

                return _Where;
            }

            if (_Where == _Bucket_hi) {
                return _End;
            }

            _Where = _Where->_Next;
        }
    }

    template <class _Keyty>
    _Nodeptr _Find(const _Keyty& _Keyval, const size_t _Hashval) const {
        if constexpr (_Traits::_Multi) {
            return _Find_first(_Keyval, _Hashval);
        } else {
            
            auto _Target = _Find_last(_Keyval, _Hashval)._Duplicate;
            if (_Target) {
                return _Target;
            }

            return _List._Mypair._Myval2._Myhead;
        }
    }

public:
    template <class _Keyty = void>
    [[nodiscard]] iterator find(typename _Traits::template _Deduce_key<_Keyty> _Keyval) {
        return _List._Make_iter(_Find(_Keyval, _Traitsobj(_Keyval)));
    }

    template <class _Keyty = void>
    [[nodiscard]] const_iterator find(typename _Traits::template _Deduce_key<_Keyty> _Keyval) const {
        return _List._Make_const_iter(_Find(_Keyval, _Traitsobj(_Keyval)));
    }


    template <class _Keyty = void>
    [[nodiscard]] bool contains(typename _Traits::template _Deduce_key<_Keyty> _Keyval) const {
        return static_cast<bool>(_Find_last(_Keyval, _Traitsobj(_Keyval))._Duplicate);
    }
#line 1212 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xhash"

    template <class _Keyty = void>
    [[nodiscard]] size_type count(typename _Traits::template _Deduce_key<_Keyty> _Keyval) const {
        const size_t _Hashval = _Traitsobj(_Keyval);
        if constexpr (_Multi) {
            return _Equal_range(_Keyval, _Hashval)._Distance;
        } else {
            return static_cast<bool>(_Find_last(_Keyval, _Hashval)._Duplicate);
        }
    }

    [[deprecated( "warning STL4022: " "The hash_meow and unordered_meow containers' non-Standard lower_bound() member was provided for interface " "compatibility with the ordered associative containers, and doesn't match the semantics of the " "hash_meow or unordered_meow containers. Please use the find() member instead. You can define " "_SILENCE_STDEXT_HASH_LOWER_BOUND_DEPRECATION_WARNING to suppress this deprecation.")]] [[nodiscard]] iterator lower_bound(const key_type& _Keyval) {
        return _List._Make_iter(_Find(_Keyval, _Traitsobj(_Keyval)));
    }

    [[deprecated( "warning STL4022: " "The hash_meow and unordered_meow containers' non-Standard lower_bound() member was provided for interface " "compatibility with the ordered associative containers, and doesn't match the semantics of the " "hash_meow or unordered_meow containers. Please use the find() member instead. You can define " "_SILENCE_STDEXT_HASH_LOWER_BOUND_DEPRECATION_WARNING to suppress this deprecation.")]] [[nodiscard]] const_iterator lower_bound(const key_type& _Keyval) const {
        return _List._Make_const_iter(_Find(_Keyval, _Traitsobj(_Keyval)));
    }

    [[deprecated( "warning STL4023: " "The hash_meow and unordered_meow containers' non-Standard upper_bound() member was provided for interface " "compatibility with the ordered associative containers, and doesn't match the semantics of the " "hash_meow or unordered_meow containers. Please use the second iterator returned by the " "equal_range() member instead. You can define " "_SILENCE_STDEXT_HASH_UPPER_BOUND_DEPRECATION_WARNING to suppress this deprecation.")]] [[nodiscard]] iterator upper_bound(const key_type& _Keyval) {
        auto _Target = _Find_last(_Keyval, _Traitsobj(_Keyval))._Duplicate;
        if (_Target) {
            _Target = _Target->_Next;
        } else {
            _Target = _List._Mypair._Myval2._Myhead;
        }

        return _List._Make_iter(_Target);
    }

    [[deprecated( "warning STL4023: " "The hash_meow and unordered_meow containers' non-Standard upper_bound() member was provided for interface " "compatibility with the ordered associative containers, and doesn't match the semantics of the " "hash_meow or unordered_meow containers. Please use the second iterator returned by the " "equal_range() member instead. You can define " "_SILENCE_STDEXT_HASH_UPPER_BOUND_DEPRECATION_WARNING to suppress this deprecation.")]] [[nodiscard]] const_iterator upper_bound(const key_type& _Keyval) const {
        auto _Target = _Find_last(_Keyval, _Traitsobj(_Keyval))._Duplicate;
        if (_Target) {
            _Target = _Target->_Next;
        } else {
            _Target = _List._Mypair._Myval2._Myhead;
        }

        return _List._Make_const_iter(_Target);
    }

private:
    struct _Equal_range_result {
        _Unchecked_const_iterator _First;
        _Unchecked_const_iterator _Last;
        size_type _Distance;
    };

    template <class _Keyty>
    [[nodiscard]] _Equal_range_result _Equal_range(const _Keyty& _Keyval, const size_t _Hashval) const
        noexcept(_Nothrow_compare<_Traits, key_type, _Keyty>&& _Nothrow_compare<_Traits, _Keyty, key_type>) {
        const size_type _Bucket              = _Hashval & _Mask;
        _Unchecked_const_iterator _Where     = _Vec._Mypair._Myval2._Myfirst[_Bucket << 1];
        const _Unchecked_const_iterator _End = _Unchecked_end();
        if (_Where == _End) {
            return {_End, _End, 0};
        }

        const _Unchecked_const_iterator _Bucket_hi = _Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1];
        for (; _Traitsobj(_Traits::_Kfn(*_Where), _Keyval); ++_Where) {
            if (_Where == _Bucket_hi) {
                return {_End, _End, 0};
            }
        }

        if constexpr (!_Traits::_Standard) {
            if (_Traitsobj(_Keyval, _Traits::_Kfn(*_Where))) {
                return {_End, _End, 0};
            }
        }

        const _Unchecked_const_iterator _First = _Where;
        if constexpr (_Multi) {
            size_type _Distance = 0;
            for (;;) {
                ++_Distance;

                const bool _At_bucket_end = _Where == _Bucket_hi;
                ++_Where;
                if (_At_bucket_end) {
                    break;
                }

                if (_Traitsobj(_Keyval, _Traits::_Kfn(*_Where))) {
                    break;
                }
            }

            return {_First, _Where, _Distance};
        } else {
            ++_Where; 
            return {_First, _Where, 1};
        }
    }

public:
    template <class _Keyty = void>
    [[nodiscard]] pair<iterator, iterator> equal_range(typename _Traits::template _Deduce_key<_Keyty> _Keyval) {
        const auto _Result = _Equal_range(_Keyval, _Traitsobj(_Keyval));
        return {_List._Make_iter(_Result._First._Ptr), _List._Make_iter(_Result._Last._Ptr)};
    }

    template <class _Keyty = void>
    [[nodiscard]] pair<const_iterator, const_iterator> equal_range(
        typename _Traits::template _Deduce_key<_Keyty> _Keyval) const {
        const auto _Result = _Equal_range(_Keyval, _Traitsobj(_Keyval));
        return {_List._Make_const_iter(_Result._First._Ptr), _List._Make_const_iter(_Result._Last._Ptr)};
    }

    void swap(_Hash& _Right) noexcept(noexcept(_Traitsobj.swap(_Right._Traitsobj)))  {
        if (this != ::std:: addressof(_Right)) {
            _Traitsobj.swap(_Right._Traitsobj);
            _Pocs(_List._Getal(), _Right._List._Getal());
            _Pocs(_Vec._Mypair._Get_first(), _Right._Vec._Mypair._Get_first());
            _Swap_val(_Right);
        }
    }


    using node_type = typename _Traits::node_type;

    node_type extract(const const_iterator _Where) {


#line 1339 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xhash"

        return node_type::_Make(_Extract(_Where._Unwrapped()), _List._Getal());
    }

    node_type extract(const key_type& _Keyval) {
        const auto _Ptr = _Extract(_Keyval);
        if (!_Ptr) {
            return node_type{};
        }

        return node_type::_Make(_Ptr, _List._Getal());
    }


    template <class _Kx, class _Mytraits = _Traits, class = typename _Mytraits::_Transparent,
        enable_if_t<!disjunction_v<is_convertible<_Kx, const_iterator>, is_convertible<_Kx, iterator>>, int> = 0>
    node_type extract(_Kx&& _Keyval) {
        const auto _Ptr = _Extract(_Keyval);
        if (!_Ptr) {
            return node_type{};
        }

        return node_type::_Make(_Ptr, _List._Getal());
    }
#line 1364 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xhash"

    iterator insert(const_iterator _Hint, node_type&& _Handle) {
        if (_Handle.empty()) {
            return end();
        }


#line 1373 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xhash"

        const auto& _Keyval   = _Traits::_Kfn(_Handle._Getptr()->_Myval);
        const size_t _Hashval = _Traitsobj(_Keyval);
        auto _Target          = _Find_hint(_Hint._Ptr, _Keyval, _Hashval);
        if constexpr (!_Traits::_Multi) {
            if (_Target._Duplicate) {
                return _List._Make_iter(_Target._Duplicate);
            }
        }

        _Check_max_size();
        if (_Check_rehash_required_1()) {
            _Rehash_for_1();
            _Target = _Find_hint(_Hint._Ptr, _Keyval, _Hashval);
        }

        const auto _Released = _Handle._Release();
        _Destroy_in_place(_Released->_Next); 
        _Destroy_in_place(_Released->_Prev);
        return _List._Make_iter(_Insert_new_node_before(_Hashval, _Target._Insert_before, _Released));
    }

    template <class>
    friend class _Hash;

    template <class _Other_traits>
    void merge(_Hash<_Other_traits>& _That) { 
        static_assert(is_same_v<_Nodeptr, typename _Hash<_Other_traits>::_Nodeptr>,
            "merge() requires an argument with a compatible node type.");

        static_assert(is_same_v<allocator_type, typename _Hash<_Other_traits>::allocator_type>,
            "merge() requires an argument with the same allocator type.");

        if constexpr (is_same_v<_Hash, _Hash<_Other_traits>>) {
            if (this == ::std:: addressof(_That)) {
                return;
            }
        }


#line 1417 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xhash"

        auto _First      = _That._Unchecked_begin();
        const auto _Last = _That._Unchecked_end();
        while (_First != _Last) {
            const auto _Candidate = _First._Ptr;
            ++_First;
            const auto& _Keyval   = _Traits::_Kfn(_Candidate->_Myval);
            const size_t _Hashval = _Traitsobj(_Keyval);
            auto _Target          = _Find_last(_Keyval, _Hashval);
            if constexpr (!_Traits::_Multi) {
                if (_Target._Duplicate) {
                    continue;
                }
            }

            _Check_max_size();
            if (_Check_rehash_required_1()) {
                _Rehash_for_1();
                _Target = _Find_last(_Keyval, _Hashval);
            }

            
            const auto _Source_bucket = _Hashval & _That._Mask;
            _That._Erase_bucket(_Candidate, _Source_bucket);
            _Candidate->_Prev->_Next = _Candidate->_Next;
            _Candidate->_Next->_Prev = _Candidate->_Prev;
            --_That._List._Mypair._Myval2._Mysize;
            _Destroy_in_place(_Candidate->_Next); 
            _Destroy_in_place(_Candidate->_Prev);


#line 1449 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xhash"
            (void) _Insert_new_node_before(_Hashval, _Target._Insert_before, _Candidate);
        }
    }

    template <class _Other_traits>
    void merge(_Hash<_Other_traits>&& _That) { 
        static_assert(is_same_v<_Nodeptr, typename _Hash<_Other_traits>::_Nodeptr>,
            "merge() requires an argument with a compatible node type.");

        static_assert(is_same_v<allocator_type, typename _Hash<_Other_traits>::allocator_type>,
            "merge() requires an argument with the same allocator type.");

        merge(_That);
    }

protected:
    _Nodeptr _Extract(const _Unchecked_const_iterator _Where) {
        const size_type _Bucket = bucket(_Traits::_Kfn(*_Where));
        _Erase_bucket(_Where._Ptr, _Bucket);
        return _List._Mypair._Myval2._Unlinknode(_Where._Ptr);
    }

    template <class _Kx>
    _Nodeptr _Extract(const _Kx& _Keyval) {
        const size_t _Hashval = _Traitsobj(_Keyval);
        _Nodeptr _Target;
        if constexpr (_Traits::_Multi) {
            _Target = _Find_first(_Keyval, _Hashval);
            if (_Target == _List._Mypair._Myval2._Myhead) {
                return _Nodeptr{};
            }
        } else {
            _Target = _Find_last(_Keyval, _Hashval)._Duplicate;
            if (_Target == nullptr) {
                return _Nodeptr{};
            }
        }

        _Erase_bucket(_Target, _Hashval & _Mask);
        return _List._Mypair._Myval2._Unlinknode(_Target);
    }

public:
    conditional_t<_Traits::_Multi, iterator, _Insert_return_type<iterator, node_type>> insert(node_type&& _Handle) {
        
        if (_Handle.empty()) {
            if constexpr (_Traits::_Multi) {
                return end();
            } else {
                return {end(), false, ::std:: move(_Handle)};
            }
        }


#line 1505 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xhash"

        const auto& _Keyval   = _Traits::_Kfn(_Handle._Getptr()->_Myval);
        const size_t _Hashval = _Traitsobj(_Keyval);
        auto _Target          = _Find_last(_Keyval, _Hashval);
        if constexpr (!_Traits::_Multi) {
            if (_Target._Duplicate) {
                return {_List._Make_iter(_Target._Duplicate), false, ::std:: move(_Handle)};
            }
        }

        _Check_max_size();
        if (_Check_rehash_required_1()) {
            _Rehash_for_1();
            _Target = _Find_last(_Keyval, _Hashval);
        }

        const auto _Released = _Handle._Release();
        _Destroy_in_place(_Released->_Next); 
        _Destroy_in_place(_Released->_Prev);
        const auto _Newnode = _Insert_new_node_before(_Hashval, _Target._Insert_before, _Released);
        if constexpr (_Traits::_Multi) {
            return _List._Make_iter(_Newnode);
        } else {
            return {_List._Make_iter(_Newnode), true, node_type{}};
        }
    }
#line 1532 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xhash"

protected:
    template <class _Keyty>
    [[nodiscard]] _Hash_find_last_result<_Nodeptr> _Find_last(const _Keyty& _Keyval, const size_t _Hashval) const {
        
        const size_type _Bucket = _Hashval & _Mask;
        _Nodeptr _Where         = _Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1]._Ptr;
        const _Nodeptr _End     = _List._Mypair._Myval2._Myhead;
        if (_Where == _End) {
            return {_End, _Nodeptr{}};
        }

        const _Nodeptr _Bucket_lo = _Vec._Mypair._Myval2._Myfirst[_Bucket << 1]._Ptr;
        for (;;) {
            
            if (!_Traitsobj(_Keyval, _Traits::_Kfn(_Where->_Myval))) {
                if constexpr (!_Traits::_Standard) {
                    if (_Traitsobj(_Traits::_Kfn(_Where->_Myval), _Keyval)) {
                        return {_Where->_Next, _Nodeptr{}};
                    }
                }

                return {_Where->_Next, _Where};
            }

            if (_Where == _Bucket_lo) {
                return {_Where, _Nodeptr{}};
            }

            _Where = _Where->_Prev;
        }
    }

    template <class _Keyty>
    [[nodiscard]] _Hash_find_last_result<_Nodeptr> _Find_hint(
        const _Nodeptr _Hint, const _Keyty& _Keyval, const size_t _Hashval) const {
        
        
        if (_Hint != _List._Mypair._Myval2._Myhead && !_Traitsobj(_Traits::_Kfn(_Hint->_Myval), _Keyval)) {
            if constexpr (!_Traits::_Standard) {
                if (_Traitsobj(_Keyval, _Traits::_Kfn(_Hint->_Myval))) {
                    return _Find_last(_Keyval, _Hashval);
                }
            }

            return {_Hint->_Next, _Hint};
        }

        return _Find_last(_Keyval, _Hashval);
    }

    _Nodeptr _Insert_new_node_before(
        const size_t _Hashval, const _Nodeptr _Insert_before, const _Nodeptr _Newnode) noexcept {
        const _Nodeptr _Insert_after = _Insert_before->_Prev;
        ++_List._Mypair._Myval2._Mysize;
        _Construct_in_place(_Newnode->_Next, _Insert_before);
        _Construct_in_place(_Newnode->_Prev, _Insert_after);
        _Insert_after->_Next  = _Newnode;
        _Insert_before->_Prev = _Newnode;

        const auto _Head                = _List._Mypair._Myval2._Myhead;
        const auto _Bucket_array        = _Vec._Mypair._Myval2._Myfirst;
        const size_type _Bucket         = _Hashval & _Mask;
        _Unchecked_iterator& _Bucket_lo = _Bucket_array[_Bucket << 1];
        _Unchecked_iterator& _Bucket_hi = _Bucket_array[(_Bucket << 1) + 1];
        if (_Bucket_lo._Ptr == _Head) {
            
            _Bucket_lo._Ptr = _Newnode;
            _Bucket_hi._Ptr = _Newnode;
        } else if (_Bucket_lo._Ptr == _Insert_before) {
            
            _Bucket_lo._Ptr = _Newnode;
        } else if (_Bucket_hi._Ptr == _Insert_after) {
            
            _Bucket_hi._Ptr = _Newnode;
        }


        return _Newnode;
    }

    void _Check_max_size() const {
        const size_type _Oldsize = _List._Mypair._Myval2._Mysize;
        if (_Oldsize == _List.max_size()) {
            _Xlength_error("unordered_map/set too long");
        }
    }

    bool _Check_rehash_required_1() const noexcept {
        const size_type _Oldsize = _List._Mypair._Myval2._Mysize;
        const auto _Newsize      = _Oldsize + 1;
        return max_load_factor() < static_cast<float>(_Newsize) / static_cast<float>(bucket_count());
    }

    void _Rehash_for_1() {
        const auto _Oldsize = _List._Mypair._Myval2._Mysize;
        const auto _Newsize = _Oldsize + 1;
        _Forced_rehash(_Desired_grow_bucket_count(_Newsize));
    }

    void _Erase_bucket(_Nodeptr _Plist, size_type _Bucket) noexcept {
        
        _Nodeptr& _Bucket_lo = _Vec._Mypair._Myval2._Myfirst[_Bucket << 1]._Ptr;
        _Nodeptr& _Bucket_hi = _Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1]._Ptr;
        if (_Bucket_hi == _Plist) {
            if (_Bucket_lo == _Plist) { 
                const auto _End = _List._Mypair._Myval2._Myhead;

                _Bucket_lo = _End;
                _Bucket_hi = _End;
            } else {
                _Bucket_hi = _Plist->_Prev; 
            }
        } else if (_Bucket_lo == _Plist) {
            _Bucket_lo = _Plist->_Next; 
        }
    }

    [[nodiscard]] size_type _Min_load_factor_buckets(const size_type _For_size) const noexcept {
        
        return static_cast<size_type>(:: ceilf(static_cast<float>(_For_size) / max_load_factor()));
    }

    [[nodiscard]] size_type _Desired_grow_bucket_count(const size_type _For_size) const noexcept {
        const size_type _Old_buckets = bucket_count();
        const size_type _Req_buckets = (::std:: max)(_Min_buckets, _Min_load_factor_buckets(_For_size));
        if (_Old_buckets >= _Req_buckets) {
            
            return _Old_buckets;
        }

        if (_Old_buckets < 512 && _Old_buckets * 8 >= _Req_buckets) {
            
            return _Old_buckets * 8;
        }

        
        return _Req_buckets;
    }

    void _Reinsert_with_invalid_vec() { 
        _Forced_rehash(_Desired_grow_bucket_count(_List.size()));
    }

    void _Forced_rehash(size_type _Buckets) {
        
        
        const unsigned long _Max_storage_buckets_log2 = _Floor_of_log_2(static_cast<size_t>(_Vec.max_size() >> 1));
        const auto _Max_storage_buckets               = static_cast<size_type>(1) << _Max_storage_buckets_log2;
        if (_Buckets > _Max_storage_buckets) {
            _Xlength_error("invalid hash bucket count");
        }

        
        _Buckets                       = static_cast<size_type>(1) << _Ceiling_of_log_2(static_cast<size_t>(_Buckets));
        const _Unchecked_iterator _End = _Unchecked_end();

        _Vec._Assign_grow(_Buckets << 1, _End);
        _Mask   = _Buckets - 1;
        _Maxidx = _Buckets;

        _Clear_guard _Guard{this};

        _Unchecked_iterator _Inserted = _Unchecked_begin();

        
        for (_Unchecked_iterator _Next_inserted = _Inserted; _Inserted != _End; _Inserted = _Next_inserted) {
            ++_Next_inserted;

            auto& _Inserted_key     = _Traits::_Kfn(*_Inserted);
            const size_type _Bucket = bucket(_Inserted_key);

            
            _Unchecked_iterator& _Bucket_lo = _Vec._Mypair._Myval2._Myfirst[_Bucket << 1];
            _Unchecked_iterator& _Bucket_hi = _Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1];

            if (_Bucket_lo == _End) {
                
                _Bucket_lo = _Inserted;
                _Bucket_hi = _Inserted;
                continue;
            }

            
            _Unchecked_const_iterator _Insert_before = _Bucket_hi;
            if (!_Traitsobj(_Inserted_key, _Traits::_Kfn(*_Insert_before))) {
                
                
                ++_Insert_before;
                if (_Insert_before != _Inserted) { 
                    _Mylist::_Scary_val::_Unchecked_splice(_Insert_before._Ptr, _Inserted._Ptr, _Next_inserted._Ptr);
                }

                _Bucket_hi = _Inserted;
                continue;
            }

            
            for (;;) {
                if (_Bucket_lo == _Insert_before) {
                    
                    
                    _Mylist::_Scary_val::_Unchecked_splice(_Insert_before._Ptr, _Inserted._Ptr, _Next_inserted._Ptr);
                    _Bucket_lo = _Inserted;
                    break;
                }

                if (!_Traitsobj(_Inserted_key, _Traits::_Kfn(*--_Insert_before))) {
                    
                    ++_Insert_before;
                    
                    
                    _Mylist::_Scary_val::_Unchecked_splice(_Insert_before._Ptr, _Inserted._Ptr, _Next_inserted._Ptr);
                    break;
                }
            }
        }

        _Guard._Target = nullptr;


    }

    float& _Max_bucket_size() noexcept {
        return _Traitsobj._Get_max_bucket_size();
    }

    const float& _Max_bucket_size() const noexcept {
        return _Traitsobj._Get_max_bucket_size();
    }

    _Alnode& _Getal() noexcept {
        return _List._Getal();
    }

    const _Alnode& _Getal() const noexcept {
        return _List._Getal();
    }

    struct _Multi_equal_check_result {
        bool _Equal_possible = false;
        _Unchecked_const_iterator _Subsequent_first{}; 
    };

    [[nodiscard]] _Multi_equal_check_result _Multi_equal_check_equal_range(
        const _Hash& _Right, _Unchecked_const_iterator _First1) const {
        
        
        auto& _Keyval = _Traits::_Kfn(*_First1);
        
        const size_t _Hashval   = _Right._Traitsobj(_Keyval);
        const size_type _Bucket = _Hashval & _Right._Mask;
        auto _First2            = _Right._Vec._Mypair._Myval2._Myfirst[_Bucket << 1];
        if (_First2 == _Right._Unchecked_end()) {
            
            return {};
        }

        const auto _Bucket_hi = _Right._Vec._Mypair._Myval2._Myfirst[(_Bucket << 1) + 1];
        for (; _Right._Traitsobj(_Traits::_Kfn(*_First2), _Keyval); ++_First2) {
            
            if (_First2 == _Bucket_hi) {
                return {};
            }
        }

        _Unchecked_const_iterator _Left_stop_at;
        if constexpr (_Traits::_Standard) {
            _Left_stop_at = _Unchecked_end();
        } else {
            
            if (_Right._Traitsobj(_Keyval, _Traits::_Kfn(*_First2))) {
                return {};
            }

            const size_t _LHashval   = _Traitsobj(_Keyval);
            const size_type _LBucket = _LHashval & _Mask;
            const auto _LBucket_hi   = _Vec._Mypair._Myval2._Myfirst[(_LBucket << 1) + 1];
            _Left_stop_at            = _LBucket_hi;
            ++_Left_stop_at;
        }

        
        while (*_First1 == *_First2) {
            
            bool _Right_range_end = _First2 == _Bucket_hi;
            ++_First2;
            if (!_Right_range_end) {
                _Right_range_end = _Right._Traitsobj(_Keyval, _Traits::_Kfn(*_First2));
            }

            
            ++_First1;
            const bool _Left_range_end = _First1 == _Left_stop_at || _Traitsobj(_Keyval, _Traits::_Kfn(*_First1));

            if (_Left_range_end && _Right_range_end) {
                
                return {true, _First1};
            }

            if (_Left_range_end || _Right_range_end) {
                
                return {};
            }
        }

        
        auto _Last1 = _First1;
        auto _Last2 = _First2;
        for (;;) {
            bool _Right_range_end = _Last2 == _Bucket_hi;
            ++_Last2;
            if (!_Right_range_end) {
                _Right_range_end = _Right._Traitsobj(_Keyval, _Traits::_Kfn(*_Last2));
            }

            ++_Last1;
            const bool _Left_range_end = _Last1 == _Left_stop_at || _Traitsobj(_Keyval, _Traits::_Kfn(*_Last1));

            if (_Left_range_end && _Right_range_end) {
                
                return {_Check_match_counts(_First1, _Last1, _First2, _Last2, equal_to<>{}), _Last1};
            }

            if (_Left_range_end || _Right_range_end) {
                
                return {};
            }
        }
    }

    template <bool _Multi2 = _Traits::_Multi, enable_if_t<_Multi2, int> = 0>
    [[nodiscard]] bool _Multi_equal(const _Hash& _Right) const {
        static_assert(_Traits::_Multi, "This function only works with multi containers");
        ;
        const auto _Last1 = _Unchecked_end();
        auto _First1      = _Unchecked_begin();
        while (_First1 != _Last1) {
            const auto _Result = _Multi_equal_check_equal_range(_Right, _First1);
            if (!_Result._Equal_possible) {
                return false;
            }

            _First1 = _Result._Subsequent_first;
        }

        return true;
    }


    _Traits _Traitsobj; 
    _Mylist _List; 
    _Hash_vec<_Aliter> _Vec; 
                             
                             
    size_type _Mask; 
    size_type _Maxidx; 
};


template <class _Hasher>
using _Is_hasher = negation<disjunction<is_integral<_Hasher>, _Is_allocator<_Hasher>>>;
#line 1977 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xhash"

template <class _Traits>
[[nodiscard]] bool _Hash_equal(const _Hash<_Traits>& _Left, const _Hash<_Traits>& _Right) {
    if (_Left.size() != _Right.size()) {
        return false;
    }

    if constexpr (_Traits::_Multi) {
        return _Left._Multi_equal(_Right);
    } else {
        for (const auto& _LVal : _Left) {
            
            const auto& _Keyval = _Traits::_Kfn(_LVal);
            const auto _Next2   = _Right._Find_last(_Keyval, _Right._Traitsobj(_Keyval))._Duplicate;
            if (!(static_cast<bool>(_Next2) && _Traits::_Nonkfn(_LVal) == _Traits::_Nonkfn(_Next2->_Myval))) {
                return false;
            }
        }
    }

    return true;
}
}


#pragma warning(pop)
#pragma pack(pop)
#line 2006 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xhash"
#line 2007 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xhash"
#line 12 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\unordered_map"


#line 16 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\unordered_map"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
template <class _Kty, 
    class _Ty, 
    class _Tr, 
    class _Alloc, 
    bool _Mfl> 
class _Umap_traits : public _Tr { 
public:
    using key_type            = _Kty;
    using value_type          = pair<const _Kty, _Ty>;
    using _Mutable_value_type = pair<_Kty, _Ty>;
    using key_compare         = _Tr;
    using allocator_type      = _Alloc;

    using node_type = _Node_handle<_List_node<value_type, typename allocator_traits<_Alloc>::void_pointer>, _Alloc,
        _Node_handle_map_base, _Kty, _Ty>;
#line 41 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\unordered_map"

    static constexpr bool _Multi    = _Mfl;
    static constexpr bool _Standard = true;

    template <class... _Args>
    using _In_place_key_extractor = _In_place_key_extract_map<_Kty, _Args...>;

    _Umap_traits() = default;

    explicit _Umap_traits(const _Tr& _Traits) noexcept(is_nothrow_copy_constructible_v<_Tr>) : _Tr(_Traits) {}

    using value_compare = void; 

    template <class _Ty1, class _Ty2>
    static const _Kty& _Kfn(const pair<_Ty1, _Ty2>& _Val) noexcept { 
        return _Val.first;
    }

    template <class _Ty1, class _Ty2>
    static const _Ty2& _Nonkfn(const pair<_Ty1, _Ty2>& _Val) noexcept { 
        return _Val.second;
    }
};

template <class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>,
    class _Alloc = allocator<pair<const _Kty, _Ty>>>
class unordered_map : public _Hash<_Umap_traits<_Kty, _Ty, _Uhash_compare<_Kty, _Hasher, _Keyeq>, _Alloc, false>> {
    
public:
    static_assert(!1 || is_same_v<pair<const _Kty, _Ty>, typename _Alloc::value_type>,
        "unordered_map<Key, Value, Hasher, Eq, Allocator>" " requires that Allocator's value_type match " "pair<const Key, Value>" " (See N4659 26.2.1 [container.requirements.general]/16 allocator_type)" " Either fix the allocator value_type or define _ENFORCE_MATCHING_ALLOCATORS=0" " to suppress this diagnostic.");

private:
    using _Mytraits      = _Uhash_compare<_Kty, _Hasher, _Keyeq>;
    using _Mybase        = _Hash<_Umap_traits<_Kty, _Ty, _Mytraits, _Alloc, false>>;
    using _Alnode        = typename _Mybase::_Alnode;
    using _Alnode_traits = typename _Mybase::_Alnode_traits;
    using _Nodeptr       = typename _Mybase::_Nodeptr;
    using _Key_compare   = typename _Mybase::_Key_compare;

public:
    using hasher      = _Hasher;
    using key_type    = _Kty;
    using mapped_type = _Ty;
    using key_equal   = _Keyeq;

    using value_type      = pair<const _Kty, _Ty>;
    using allocator_type  = typename _Mybase::allocator_type;
    using size_type       = typename _Mybase::size_type;
    using difference_type = typename _Mybase::difference_type;
    using pointer         = typename _Mybase::pointer;
    using const_pointer   = typename _Mybase::const_pointer;
    using reference       = value_type&;
    using const_reference = const value_type&;
    using iterator        = typename _Mybase::iterator;
    using const_iterator  = typename _Mybase::const_iterator;

    using local_iterator       = typename _Mybase::iterator;
    using const_local_iterator = typename _Mybase::const_iterator;


    using insert_return_type = _Insert_return_type<iterator, typename _Mybase::node_type>;
#line 104 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\unordered_map"

    unordered_map() : _Mybase(_Key_compare(), allocator_type()) {}

    explicit unordered_map(const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {}

    unordered_map(const unordered_map& _Right)
        : _Mybase(_Right, _Alnode_traits::select_on_container_copy_construction(_Right._Getal())) {}

    unordered_map(const unordered_map& _Right, const allocator_type& _Al) : _Mybase(_Right, _Al) {}

    explicit unordered_map(size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
        _Mybase::rehash(_Buckets);
    }

    unordered_map(size_type _Buckets, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
        _Mybase::rehash(_Buckets);
    }

    unordered_map(size_type _Buckets, const hasher& _Hasharg) : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
        _Mybase::rehash(_Buckets);
    }

    unordered_map(size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
        : _Mybase(_Key_compare(_Hasharg), _Al) {
        _Mybase::rehash(_Buckets);
    }

    unordered_map(size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
        _Mybase::rehash(_Buckets);
    }

    unordered_map(size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg, const allocator_type& _Al)
        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
        _Mybase::rehash(_Buckets);
    }

    template <class _Iter>
    unordered_map(_Iter _First, _Iter _Last) : _Mybase(_Key_compare(), allocator_type()) {
        insert(_First, _Last);
    }

    template <class _Iter>
    unordered_map(_Iter _First, _Iter _Last, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
        insert(_First, _Last);
    }

    template <class _Iter>
    unordered_map(_Iter _First, _Iter _Last, size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
        _Mybase::rehash(_Buckets);
        insert(_First, _Last);
    }

    template <class _Iter>
    unordered_map(_Iter _First, _Iter _Last, size_type _Buckets, const allocator_type& _Al)
        : _Mybase(_Key_compare(), _Al) {
        _Mybase::rehash(_Buckets);
        insert(_First, _Last);
    }

    template <class _Iter>
    unordered_map(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg)
        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
        _Mybase::rehash(_Buckets);
        insert(_First, _Last);
    }

    template <class _Iter>
    unordered_map(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
        : _Mybase(_Key_compare(_Hasharg), _Al) {
        _Mybase::rehash(_Buckets);
        insert(_First, _Last);
    }

    template <class _Iter>
    unordered_map(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
        _Mybase::rehash(_Buckets);
        insert(_First, _Last);
    }

    template <class _Iter>
    unordered_map(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg,
        const allocator_type& _Al)
        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
        _Mybase::rehash(_Buckets);
        insert(_First, _Last);
    }

    unordered_map& operator=(const unordered_map& _Right) {
        _Mybase::operator=(_Right);
        return *this;
    }

    unordered_map(unordered_map&& _Right) : _Mybase(::std:: move(_Right)) {}

    unordered_map(unordered_map&& _Right, const allocator_type& _Al) : _Mybase(::std:: move(_Right), _Al) {}

    unordered_map& operator=(unordered_map&& _Right) noexcept(_Alnode_traits::is_always_equal::value&&
            is_nothrow_move_assignable_v<_Hasher>&& is_nothrow_move_assignable_v<_Keyeq>) {
        _Mybase::operator=(::std:: move(_Right));
        return *this;
    }

    mapped_type& operator[](key_type&& _Keyval) {
        return this->_Try_emplace(::std:: move(_Keyval)).first->_Myval.second;
    }

    void swap(unordered_map& _Right) noexcept(noexcept(_Mybase::swap(_Right))) {
        _Mybase::swap(_Right);
    }

    using _Mybase::insert;

    template <class _Valty, enable_if_t<is_constructible_v<value_type, _Valty>, int> = 0>
    pair<iterator, bool> insert(_Valty&& _Val) {
        return this->emplace(::std:: forward<_Valty>(_Val));
    }

    template <class _Valty, enable_if_t<is_constructible_v<value_type, _Valty>, int> = 0>
    iterator insert(const_iterator _Where, _Valty&& _Val) {
        return this->emplace_hint(_Where, ::std:: forward<_Valty>(_Val));
    }

    template <class... _Mappedty>
    pair<iterator, bool> try_emplace(const key_type& _Keyval, _Mappedty&&... _Mapval) {
        const auto _Result = this->_Try_emplace(_Keyval, ::std:: forward<_Mappedty>(_Mapval)...);
        return {this->_List._Make_iter(_Result.first), _Result.second};
    }

    template <class... _Mappedty>
    pair<iterator, bool> try_emplace(key_type&& _Keyval, _Mappedty&&... _Mapval) {
        const auto _Result = this->_Try_emplace(::std:: move(_Keyval), ::std:: forward<_Mappedty>(_Mapval)...);
        return {this->_List._Make_iter(_Result.first), _Result.second};
    }

    template <class... _Mappedty>
    iterator try_emplace(const const_iterator _Hint, const key_type& _Keyval, _Mappedty&&... _Mapval) {
        return this->_List._Make_iter(
            this->_Try_emplace_hint(_Hint._Ptr, _Keyval, ::std:: forward<_Mappedty>(_Mapval)...));
    }

    template <class... _Mappedty>
    iterator try_emplace(const const_iterator _Hint, key_type&& _Keyval, _Mappedty&&... _Mapval) {
        return this->_List._Make_iter(
            this->_Try_emplace_hint(_Hint._Ptr, ::std:: move(_Keyval), ::std:: forward<_Mappedty>(_Mapval)...));
    }

private:
    template <class _Keyty, class _Mappedty>
    pair<iterator, bool> _Insert_or_assign(_Keyty&& _Keyval_arg, _Mappedty&& _Mapval) {
        const auto& _Keyval   = _Keyval_arg;
        const size_t _Hashval = this->_Traitsobj(_Keyval);
        auto _Target          = this->_Find_last(_Keyval, _Hashval);
        if (_Target._Duplicate) {
            _Target._Duplicate->_Myval.second = ::std:: forward<_Mappedty>(_Mapval);
            return {this->_List._Make_iter(_Target._Duplicate), false};
        }

        this->_Check_max_size();
        
        _List_node_emplace_op2<_Alnode> _Newnode(
            this->_Getal(), ::std:: forward<_Keyty>(_Keyval_arg), ::std:: forward<_Mappedty>(_Mapval));
        if (this->_Check_rehash_required_1()) {
            this->_Rehash_for_1();
            _Target = this->_Find_last(_Newnode._Ptr->_Myval.first, _Hashval);
        }

        return {this->_List._Make_iter(
                    this->_Insert_new_node_before(_Hashval, _Target._Insert_before, _Newnode._Release())),
            true};
    }

    template <class _Keyty, class _Mappedty>
    iterator _Insert_or_assign(const _Nodeptr _Hint, _Keyty&& _Keyval_arg, _Mappedty&& _Mapval) {
        const auto& _Keyval   = _Keyval_arg;
        const size_t _Hashval = this->_Traitsobj(_Keyval);
        auto _Target          = this->_Find_hint(_Hint, _Keyval, _Hashval);
        if (_Target._Duplicate) {
            _Target._Duplicate->_Myval.second = ::std:: forward<_Mappedty>(_Mapval);
            return this->_List._Make_iter(_Target._Duplicate);
        }

        this->_Check_max_size();
        
        _List_node_emplace_op2<_Alnode> _Newnode(
            this->_Getal(), ::std:: forward<_Keyty>(_Keyval_arg), ::std:: forward<_Mappedty>(_Mapval));
        if (this->_Check_rehash_required_1()) {
            this->_Rehash_for_1();
            _Target = this->_Find_hint(_Hint, _Newnode._Ptr->_Myval.first, _Hashval);
        }

        return this->_List._Make_iter(
            this->_Insert_new_node_before(_Hashval, _Target._Insert_before, _Newnode._Release()));
    }

public:
    template <class _Mappedty>
    pair<iterator, bool> insert_or_assign(const key_type& _Keyval, _Mappedty&& _Mapval) {
        return _Insert_or_assign(_Keyval, ::std:: forward<_Mappedty>(_Mapval));
    }

    template <class _Mappedty>
    pair<iterator, bool> insert_or_assign(key_type&& _Keyval, _Mappedty&& _Mapval) {
        return _Insert_or_assign(::std:: move(_Keyval), ::std:: forward<_Mappedty>(_Mapval));
    }

    template <class _Mappedty>
    iterator insert_or_assign(const_iterator _Hint, const key_type& _Keyval, _Mappedty&& _Mapval) {
        return _Insert_or_assign(_Hint._Ptr, _Keyval, ::std:: forward<_Mappedty>(_Mapval));
    }

    template <class _Mappedty>
    iterator insert_or_assign(const_iterator _Hint, key_type&& _Keyval, _Mappedty&& _Mapval) {
        return _Insert_or_assign(_Hint._Ptr, ::std:: move(_Keyval), ::std:: forward<_Mappedty>(_Mapval));
    }

    unordered_map(initializer_list<value_type> _Ilist) : _Mybase(_Key_compare(), allocator_type()) {
        insert(_Ilist);
    }

    unordered_map(initializer_list<value_type> _Ilist, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
        insert(_Ilist);
    }

    unordered_map(initializer_list<value_type> _Ilist, size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
        _Mybase::rehash(_Buckets);
        insert(_Ilist);
    }

    unordered_map(initializer_list<value_type> _Ilist, size_type _Buckets, const allocator_type& _Al)
        : _Mybase(_Key_compare(), _Al) {
        _Mybase::rehash(_Buckets);
        insert(_Ilist);
    }

    unordered_map(initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg)
        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
        _Mybase::rehash(_Buckets);
        insert(_Ilist);
    }

    unordered_map(
        initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
        : _Mybase(_Key_compare(_Hasharg), _Al) {
        _Mybase::rehash(_Buckets);
        insert(_Ilist);
    }

    unordered_map(
        initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
        _Mybase::rehash(_Buckets);
        insert(_Ilist);
    }

    unordered_map(initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg,
        const _Keyeq& _Keyeqarg, const allocator_type& _Al)
        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
        _Mybase::rehash(_Buckets);
        insert(_Ilist);
    }

    unordered_map& operator=(initializer_list<value_type> _Ilist) {
        _Mybase::clear();
        insert(_Ilist);
        return *this;
    }

    [[nodiscard]] hasher hash_function() const {
        return _Mybase::_Traitsobj._Mypair._Get_first();
    }

    [[nodiscard]] key_equal key_eq() const {
        return _Mybase::_Traitsobj._Mypair._Myval2._Get_first();
    }

    mapped_type& operator[](const key_type& _Keyval) {
        return this->_Try_emplace(_Keyval).first->_Myval.second;
    }

    [[nodiscard]] mapped_type& at(const key_type& _Keyval) {
        const auto _Target = this->_Find_last(_Keyval, this->_Traitsobj(_Keyval));
        if (_Target._Duplicate) {
            return _Target._Duplicate->_Myval.second;
        }

        _Xout_of_range("invalid unordered_map<K, T> key");
    }

    [[nodiscard]] const mapped_type& at(const key_type& _Keyval) const {
        const auto _Target = this->_Find_last(_Keyval, this->_Traitsobj(_Keyval));
        if (_Target._Duplicate) {
            return _Target._Duplicate->_Myval.second;
        }

        _Xout_of_range("invalid unordered_map<K, T> key");
    }

    using _Mybase::_Unchecked_begin;
    using _Mybase::_Unchecked_end;
};


template <class _Iter, class _Hasher = hash<_Guide_key_t<_Iter>>, class _Keyeq = equal_to<_Guide_key_t<_Iter>>,
    class _Alloc = allocator<_Guide_pair_t<_Iter>>,
    enable_if_t<
        conjunction_v<_Is_iterator<_Iter>, _Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>,
        int> = 0>
unordered_map(_Iter, _Iter, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(), _Alloc = _Alloc())
    -> unordered_map<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>, _Hasher, _Keyeq, _Alloc>;

template <class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>,
    class _Alloc = allocator<pair<const _Kty, _Ty>>,
    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>, int> = 0>
unordered_map(initializer_list<pair<_Kty, _Ty>>, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
    _Alloc = _Alloc()) -> unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>;

template <class _Iter, class _Alloc, enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
unordered_map(_Iter, _Iter, _Alloc) -> unordered_map<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>,
    hash<_Guide_key_t<_Iter>>, equal_to<_Guide_key_t<_Iter>>, _Alloc>;

template <class _Iter, class _Alloc, enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
unordered_map(_Iter, _Iter, _Guide_size_type_t<_Alloc>, _Alloc) -> unordered_map<_Guide_key_t<_Iter>,
    _Guide_val_t<_Iter>, hash<_Guide_key_t<_Iter>>, equal_to<_Guide_key_t<_Iter>>, _Alloc>;

template <class _Iter, class _Hasher, class _Alloc,
    enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
unordered_map(_Iter, _Iter, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
    -> unordered_map<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>, _Hasher, equal_to<_Guide_key_t<_Iter>>, _Alloc>;

template <class _Kty, class _Ty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
unordered_map(initializer_list<pair<_Kty, _Ty>>, _Alloc)
    -> unordered_map<_Kty, _Ty, hash<_Kty>, equal_to<_Kty>, _Alloc>;

template <class _Kty, class _Ty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
unordered_map(initializer_list<pair<_Kty, _Ty>>, _Guide_size_type_t<_Alloc>, _Alloc)
    -> unordered_map<_Kty, _Ty, hash<_Kty>, equal_to<_Kty>, _Alloc>;

template <class _Kty, class _Ty, class _Hasher, class _Alloc,
    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
unordered_map(initializer_list<pair<_Kty, _Ty>>, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
    -> unordered_map<_Kty, _Ty, _Hasher, equal_to<_Kty>, _Alloc>;
#line 448 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\unordered_map"

template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc>
void swap(unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Left,
    unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
    _Left.swap(_Right);
}


template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc, class _Pr>
typename unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>::size_type erase_if(
    unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Cont, _Pr _Pred) {
    return _Erase_nodes_if(_Cont, _Pass_fn(_Pred));
}
#line 462 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\unordered_map"

template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc>
[[nodiscard]] bool operator==(const unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Left,
    const unordered_map<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Right) {
    return _Hash_equal(_Left, _Right);
}


#line 476 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\unordered_map"

template <class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>,
    class _Alloc = allocator<pair<const _Kty, _Ty>>>
class unordered_multimap : public _Hash<_Umap_traits<_Kty, _Ty, _Uhash_compare<_Kty, _Hasher, _Keyeq>, _Alloc, true>> {
    
public:
    static_assert(!1 || is_same_v<pair<const _Kty, _Ty>, typename _Alloc::value_type>,
        "unordered_multimap<Key, Value, Hasher, Eq, Allocator>" " requires that Allocator's value_type match " "pair<const Key, Value>" " (See N4659 26.2.1 [container.requirements.general]/16 allocator_type)" " Either fix the allocator value_type or define _ENFORCE_MATCHING_ALLOCATORS=0" " to suppress this diagnostic.");
#line 485 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\unordered_map"

private:
    using _Mytraits      = _Uhash_compare<_Kty, _Hasher, _Keyeq>;
    using _Mybase        = _Hash<_Umap_traits<_Kty, _Ty, _Mytraits, _Alloc, true>>;
    using _Alnode        = typename _Mybase::_Alnode;
    using _Alnode_traits = typename _Mybase::_Alnode_traits;
    using _Key_compare   = typename _Mybase::_Key_compare;

public:
    using hasher      = _Hasher;
    using key_type    = _Kty;
    using mapped_type = _Ty;
    using key_equal   = _Keyeq;

    using value_type      = pair<const _Kty, _Ty>;
    using allocator_type  = typename _Mybase::allocator_type;
    using size_type       = typename _Mybase::size_type;
    using difference_type = typename _Mybase::difference_type;
    using pointer         = typename _Mybase::pointer;
    using const_pointer   = typename _Mybase::const_pointer;
    using reference       = value_type&;
    using const_reference = const value_type&;
    using iterator        = typename _Mybase::iterator;
    using const_iterator  = typename _Mybase::const_iterator;

    using local_iterator       = typename _Mybase::iterator;
    using const_local_iterator = typename _Mybase::const_iterator;

    unordered_multimap() : _Mybase(_Key_compare(), allocator_type()) {} 

    explicit unordered_multimap(const allocator_type& _Al)
        : _Mybase(_Key_compare(), _Al) {} 

    unordered_multimap(const unordered_multimap& _Right)
        : _Mybase(_Right, _Alnode_traits::select_on_container_copy_construction(_Right._Getal())) {}

    unordered_multimap(const unordered_multimap& _Right, const allocator_type& _Al) : _Mybase(_Right, _Al) {}

    explicit unordered_multimap(size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
        _Mybase::rehash(_Buckets);
    }

    unordered_multimap(size_type _Buckets, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
        _Mybase::rehash(_Buckets);
    }

    unordered_multimap(size_type _Buckets, const hasher& _Hasharg) : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
        _Mybase::rehash(_Buckets);
    }

    unordered_multimap(size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
        : _Mybase(_Key_compare(_Hasharg), _Al) {
        _Mybase::rehash(_Buckets);
    }

    unordered_multimap(size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
        _Mybase::rehash(_Buckets);
    }

    unordered_multimap(size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg, const allocator_type& _Al)
        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
        _Mybase::rehash(_Buckets);
    }

    template <class _Iter>
    unordered_multimap(_Iter _First, _Iter _Last) : _Mybase(_Key_compare(), allocator_type()) {
        insert(_First, _Last);
    }

    template <class _Iter>
    unordered_multimap(_Iter _First, _Iter _Last, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
        insert(_First, _Last);
    }

    template <class _Iter>
    unordered_multimap(_Iter _First, _Iter _Last, size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
        _Mybase::rehash(_Buckets);
        insert(_First, _Last);
    }

    template <class _Iter>
    unordered_multimap(_Iter _First, _Iter _Last, size_type _Buckets, const allocator_type& _Al)
        : _Mybase(_Key_compare(), _Al) {
        _Mybase::rehash(_Buckets);
        insert(_First, _Last);
    }

    template <class _Iter>
    unordered_multimap(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg)
        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
        _Mybase::rehash(_Buckets);
        insert(_First, _Last);
    }

    template <class _Iter>
    unordered_multimap(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
        : _Mybase(_Key_compare(_Hasharg), _Al) {
        _Mybase::rehash(_Buckets);
        insert(_First, _Last);
    }

    template <class _Iter>
    unordered_multimap(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
        _Mybase::rehash(_Buckets);
        insert(_First, _Last);
    }

    template <class _Iter>
    unordered_multimap(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg,
        const allocator_type& _Al)
        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
        _Mybase::rehash(_Buckets);
        insert(_First, _Last);
    }

    unordered_multimap& operator=(const unordered_multimap& _Right) {
        _Mybase::operator=(_Right);
        return *this;
    }

    unordered_multimap(unordered_multimap&& _Right) : _Mybase(::std:: move(_Right)) {}

    unordered_multimap(unordered_multimap&& _Right, const allocator_type& _Al) : _Mybase(::std:: move(_Right), _Al) {}

    unordered_multimap& operator=(unordered_multimap&& _Right) noexcept(_Alnode_traits::is_always_equal::value&&
            is_nothrow_move_assignable_v<_Hasher>&& is_nothrow_move_assignable_v<_Keyeq>) {
        _Mybase::operator=(::std:: move(_Right));
        return *this;
    }

    void swap(unordered_multimap& _Right) noexcept(noexcept(_Mybase::swap(_Right))) {
        _Mybase::swap(_Right);
    }

    using _Mybase::insert;

    template <class _Valty, enable_if_t<is_constructible_v<value_type, _Valty>, int> = 0>
    iterator insert(_Valty&& _Val) {
        return this->emplace(::std:: forward<_Valty>(_Val));
    }

    template <class _Valty, enable_if_t<is_constructible_v<value_type, _Valty>, int> = 0>
    iterator insert(const_iterator _Where, _Valty&& _Val) {
        return this->emplace_hint(_Where, ::std:: forward<_Valty>(_Val));
    }

    unordered_multimap(initializer_list<value_type> _Ilist) : _Mybase(_Key_compare(), allocator_type()) {
        insert(_Ilist);
    }

    unordered_multimap(initializer_list<value_type> _Ilist, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
        insert(_Ilist);
    }

    unordered_multimap(initializer_list<value_type> _Ilist, size_type _Buckets)
        : _Mybase(_Key_compare(), allocator_type()) {
        _Mybase::rehash(_Buckets);
        insert(_Ilist);
    }

    unordered_multimap(initializer_list<value_type> _Ilist, size_type _Buckets, const allocator_type& _Al)
        : _Mybase(_Key_compare(), _Al) {
        _Mybase::rehash(_Buckets);
        insert(_Ilist);
    }

    unordered_multimap(initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg)
        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
        _Mybase::rehash(_Buckets);
        insert(_Ilist);
    }

    unordered_multimap(
        initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
        : _Mybase(_Key_compare(_Hasharg), _Al) {
        _Mybase::rehash(_Buckets);
        insert(_Ilist);
    }

    unordered_multimap(
        initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
        _Mybase::rehash(_Buckets);
        insert(_Ilist);
    }

    unordered_multimap(initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg,
        const _Keyeq& _Keyeqarg, const allocator_type& _Al)
        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
        _Mybase::rehash(_Buckets);
        insert(_Ilist);
    }

    unordered_multimap& operator=(initializer_list<value_type> _Ilist) {
        _Mybase::clear();
        insert(_Ilist);
        return *this;
    }

    [[nodiscard]] hasher hash_function() const {
        return _Mybase::_Traitsobj._Mypair._Get_first();
    }

    [[nodiscard]] key_equal key_eq() const {
        return _Mybase::_Traitsobj._Mypair._Myval2._Get_first();
    }

    using _Mybase::_Unchecked_begin;
    using _Mybase::_Unchecked_end;
};


template <class _Iter, class _Hasher = hash<_Guide_key_t<_Iter>>, class _Keyeq = equal_to<_Guide_key_t<_Iter>>,
    class _Alloc = allocator<_Guide_pair_t<_Iter>>,
    enable_if_t<
        conjunction_v<_Is_iterator<_Iter>, _Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>,
        int> = 0>
unordered_multimap(_Iter, _Iter, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
    _Alloc = _Alloc()) -> unordered_multimap<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>, _Hasher, _Keyeq, _Alloc>;

template <class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>,
    class _Alloc = allocator<pair<const _Kty, _Ty>>,
    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>, int> = 0>
unordered_multimap(initializer_list<pair<_Kty, _Ty>>, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(),
    _Keyeq = _Keyeq(), _Alloc = _Alloc()) -> unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>;

template <class _Iter, class _Alloc, enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
unordered_multimap(_Iter, _Iter, _Alloc) -> unordered_multimap<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>,
    hash<_Guide_key_t<_Iter>>, equal_to<_Guide_key_t<_Iter>>, _Alloc>;

template <class _Iter, class _Alloc, enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
unordered_multimap(_Iter, _Iter, _Guide_size_type_t<_Alloc>, _Alloc) -> unordered_multimap<_Guide_key_t<_Iter>,
    _Guide_val_t<_Iter>, hash<_Guide_key_t<_Iter>>, equal_to<_Guide_key_t<_Iter>>, _Alloc>;

template <class _Iter, class _Hasher, class _Alloc,
    enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
unordered_multimap(_Iter, _Iter, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
    -> unordered_multimap<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>, _Hasher, equal_to<_Guide_key_t<_Iter>>, _Alloc>;

template <class _Kty, class _Ty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
unordered_multimap(initializer_list<pair<_Kty, _Ty>>, _Alloc)
    -> unordered_multimap<_Kty, _Ty, hash<_Kty>, equal_to<_Kty>, _Alloc>;

template <class _Kty, class _Ty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
unordered_multimap(initializer_list<pair<_Kty, _Ty>>, _Guide_size_type_t<_Alloc>, _Alloc)
    -> unordered_multimap<_Kty, _Ty, hash<_Kty>, equal_to<_Kty>, _Alloc>;

template <class _Kty, class _Ty, class _Hasher, class _Alloc,
    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
unordered_multimap(initializer_list<pair<_Kty, _Ty>>, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
    -> unordered_multimap<_Kty, _Ty, _Hasher, equal_to<_Kty>, _Alloc>;
#line 739 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\unordered_map"

template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc>
void swap(unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Left,
    unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
    _Left.swap(_Right);
}


template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc, class _Pr>
typename unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>::size_type erase_if(
    unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Cont, _Pr _Pred) {
    return _Erase_nodes_if(_Cont, _Pass_fn(_Pred));
}
#line 753 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\unordered_map"

template <class _Kty, class _Ty, class _Hasher, class _Keyeq, class _Alloc>
[[nodiscard]] bool operator==(const unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Left,
    const unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc>& _Right) {
    return _Hash_equal(_Left, _Right);
}


#line 767 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\unordered_map"


#line 774 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\unordered_map"


namespace pmr {
    template <class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>>
    using unordered_map = ::std:: unordered_map<_Kty, _Ty, _Hasher, _Keyeq, polymorphic_allocator<pair<const _Kty, _Ty>>>;

    template <class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>>
    using unordered_multimap =
        ::std:: unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, polymorphic_allocator<pair<const _Kty, _Ty>>>;
} 
#line 785 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\unordered_map"
}


#pragma warning(pop)
#pragma pack(pop)
#line 791 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\unordered_map"
#line 792 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\unordered_map"
#line 19 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"
#line 20 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"


#line 23 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {

template <class _Result_type, class _Callable, class... _Types,
    enable_if_t<is_invocable_r_v<_Result_type, _Callable, _Types...>, int> = 0>
[[nodiscard]] constexpr _Result_type invoke_r(_Callable&& _Obj, _Types&&... _Args) noexcept(
    is_nothrow_invocable_r_v<_Result_type, _Callable, _Types...>) {
    if constexpr (is_void_v<_Result_type>) {
        (void) ::std:: invoke(static_cast<_Callable&&>(_Obj), static_cast<_Types&&>(_Args)...);
    } else {
        return ::std:: invoke(static_cast<_Callable&&>(_Obj), static_cast<_Types&&>(_Args)...);
    }
}
#line 44 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"


template <class _Ty = void>
struct divides {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_first_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_second_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_result;

    [[nodiscard]] constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left / _Right;
    }
};

template <class _Ty = void>
struct modulus {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_first_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_second_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_result;

    [[nodiscard]] constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left % _Right;
    }
};

template <class _Ty = void>
struct negate {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_result;

    [[nodiscard]] constexpr _Ty operator()(const _Ty& _Left) const {
        return -_Left;
    }
};


template <class _Ty = void>
struct logical_and {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_first_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_second_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef bool _Unnameable_result;

    [[nodiscard]] constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left && _Right;
    }
};

template <class _Ty = void>
struct logical_or {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_first_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_second_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef bool _Unnameable_result;

    [[nodiscard]] constexpr bool operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left || _Right;
    }
};

template <class _Ty = void>
struct logical_not {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef bool _Unnameable_result;

    [[nodiscard]] constexpr bool operator()(const _Ty& _Left) const {
        return !_Left;
    }
};

template <class _Ty = void>
struct bit_and {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_first_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_second_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_result;

    [[nodiscard]] constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left & _Right;
    }
};

template <class _Ty = void>
struct bit_or {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_first_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_second_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_result;

    [[nodiscard]] constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left | _Right;
    }
};

template <class _Ty = void>
struct bit_xor {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_first_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_second_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_result;

    [[nodiscard]] constexpr _Ty operator()(const _Ty& _Left, const _Ty& _Right) const {
        return _Left ^ _Right;
    }
};

template <class _Ty = void>
struct bit_not {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ty _Unnameable_result;

    [[nodiscard]] constexpr _Ty operator()(const _Ty& _Left) const {
        return ~_Left;
    }
};


template <>
struct divides<void> {
    template <class _Ty1, class _Ty2>
    [[nodiscard]] constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
        -> decltype(::std:: forward<_Ty1>(_Left) / ::std:: forward<_Ty2>(_Right)) {
        return ::std:: forward<_Ty1>(_Left) / ::std:: forward<_Ty2>(_Right);
    }

    using is_transparent = int;
};

template <>
struct modulus<void> {
    template <class _Ty1, class _Ty2>
    [[nodiscard]] constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
        -> decltype(::std:: forward<_Ty1>(_Left) % ::std:: forward<_Ty2>(_Right)) {
        return ::std:: forward<_Ty1>(_Left) % ::std:: forward<_Ty2>(_Right);
    }

    using is_transparent = int;
};

template <>
struct negate<void> {
    template <class _Ty>
    [[nodiscard]] constexpr auto operator()(_Ty&& _Left) const -> decltype(-::std:: forward<_Ty>(_Left)) {
        return -::std:: forward<_Ty>(_Left);
    }

    using is_transparent = int;
};


template <>
struct logical_and<void> {
    template <class _Ty1, class _Ty2>
    [[nodiscard]] constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
        -> decltype(::std:: forward<_Ty1>(_Left) && ::std:: forward<_Ty2>(_Right)) {
        return ::std:: forward<_Ty1>(_Left) && ::std:: forward<_Ty2>(_Right);
    }

    using is_transparent = int;
};

template <>
struct logical_or<void> {
    template <class _Ty1, class _Ty2>
    [[nodiscard]] constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
        -> decltype(::std:: forward<_Ty1>(_Left) || ::std:: forward<_Ty2>(_Right)) {
        return ::std:: forward<_Ty1>(_Left) || ::std:: forward<_Ty2>(_Right);
    }

    using is_transparent = int;
};

template <>
struct logical_not<void> {
    template <class _Ty>
    [[nodiscard]] constexpr auto operator()(_Ty&& _Left) const -> decltype(!::std:: forward<_Ty>(_Left)) {
        return !::std:: forward<_Ty>(_Left);
    }

    using is_transparent = int;
};

template <>
struct bit_and<void> {
    template <class _Ty1, class _Ty2>
    [[nodiscard]] constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
        -> decltype(::std:: forward<_Ty1>(_Left) & ::std:: forward<_Ty2>(_Right)) {
        return ::std:: forward<_Ty1>(_Left) & ::std:: forward<_Ty2>(_Right);
    }

    using is_transparent = int;
};

template <>
struct bit_or<void> {
    template <class _Ty1, class _Ty2>
    [[nodiscard]] constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
        -> decltype(::std:: forward<_Ty1>(_Left) | ::std:: forward<_Ty2>(_Right)) {
        return ::std:: forward<_Ty1>(_Left) | ::std:: forward<_Ty2>(_Right);
    }

    using is_transparent = int;
};

template <>
struct bit_xor<void> {
    template <class _Ty1, class _Ty2>
    [[nodiscard]] constexpr auto operator()(_Ty1&& _Left, _Ty2&& _Right) const
        -> decltype(::std:: forward<_Ty1>(_Left) ^ ::std:: forward<_Ty2>(_Right)) {
        return ::std:: forward<_Ty1>(_Left) ^ ::std:: forward<_Ty2>(_Right);
    }

    using is_transparent = int;
};

template <>
struct bit_not<void> {
    template <class _Ty>
    [[nodiscard]] constexpr auto operator()(_Ty&& _Left) const -> decltype(~::std:: forward<_Ty>(_Left)) {
        return ~::std:: forward<_Ty>(_Left);
    }

    using is_transparent = int;
};


#line 313 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"


#line 564 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"

template <class _Memptr>
class _Mem_fn : public _Weak_types<_Memptr> {
private:
    _Memptr _Pm;

public:
    constexpr explicit _Mem_fn(_Memptr _Val) noexcept : _Pm(_Val) {}

    template <class... _Types>
    constexpr auto operator()(_Types&&... _Args) const
        noexcept(noexcept(::std:: invoke(_Pm, ::std:: forward<_Types>(_Args)...)))
            -> decltype(::std:: invoke(_Pm, ::std:: forward<_Types>(_Args)...)) {
        return ::std:: invoke(_Pm, ::std:: forward<_Types>(_Args)...);
    }
};

template <class _Rx, class _Ty>
[[nodiscard]] constexpr _Mem_fn<_Rx _Ty::*> mem_fn(_Rx _Ty::*_Pm) noexcept {
    return _Mem_fn<_Rx _Ty::*>(_Pm);
}


struct _Not_fn_tag {
    explicit _Not_fn_tag() = default;
};

template <class _Decayed>
class _Not_fn : private _Ebco_base<_Decayed> {
private:
    using _Mybase = _Ebco_base<_Decayed>;

public:
    template <class _Callable, class _Tag, enable_if_t<is_same_v<_Tag, _Not_fn_tag>, int> = 0>
    constexpr explicit _Not_fn(_Callable&& _Obj, _Tag) noexcept(
        is_nothrow_constructible_v<_Decayed, _Callable>) 
        : _Mybase(::std:: forward<_Callable>(_Obj)) {} 

    constexpr _Not_fn(const _Not_fn&) = default;
    constexpr _Not_fn(_Not_fn&&)      = default;

    template <class... _Types>
    constexpr auto operator()(_Types&&... _Args) & noexcept(
        noexcept(!::std:: invoke(this->_Get_val(), ::std:: forward<_Types>(_Args)...)))
        -> decltype(!::std:: declval<invoke_result_t<_Decayed&, _Types...>>()) {
        return !::std:: invoke(this->_Get_val(), ::std:: forward<_Types>(_Args)...);
    }

    template <class... _Types>
    constexpr auto operator()(_Types&&... _Args) const& noexcept(
        noexcept(!::std:: invoke(this->_Get_val(), ::std:: forward<_Types>(_Args)...)))
        -> decltype(!::std:: declval<invoke_result_t<const _Decayed&, _Types...>>()) {
        return !::std:: invoke(this->_Get_val(), ::std:: forward<_Types>(_Args)...);
    }

    template <class... _Types>
    constexpr auto operator()(_Types&&... _Args) && noexcept(
        noexcept(!::std:: invoke(::std:: move(this->_Get_val()), ::std:: forward<_Types>(_Args)...)))
        -> decltype(!::std:: declval<invoke_result_t<_Decayed, _Types...>>()) {
        return !::std:: invoke(::std:: move(this->_Get_val()), ::std:: forward<_Types>(_Args)...);
    }

    template <class... _Types>
    constexpr auto operator()(_Types&&... _Args) const&& noexcept(
        noexcept(!::std:: invoke(::std:: move(this->_Get_val()), ::std:: forward<_Types>(_Args)...)))
        -> decltype(!::std:: declval<invoke_result_t<const _Decayed, _Types...>>()) {
        return !::std:: invoke(::std:: move(this->_Get_val()), ::std:: forward<_Types>(_Args)...);
    }
};

template <class _Callable>
[[nodiscard]] constexpr _Not_fn<decay_t<_Callable>> not_fn(_Callable&& _Obj) noexcept(
    is_nothrow_constructible_v<decay_t<_Callable>, _Callable>)  {
    
    return _Not_fn<decay_t<_Callable>>(::std:: forward<_Callable>(_Obj), _Not_fn_tag{});
}
#line 641 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"

class bad_function_call : public exception { 
public:
    bad_function_call() noexcept {}

    [[nodiscard]] const char*  what() const noexcept override {
        
        return "bad function call";
    }
};

[[noreturn]]  void __cdecl _Xbad_function_call();

struct _Unforced { 
    explicit _Unforced() = default;
};


template <class _Rx, bool = is_void_v<_Rx>>
struct _Invoker_ret { 
    template <class _Fx, class... _Valtys>
    static constexpr void _Call(_Fx&& _Func, _Valtys&&... _Vals) noexcept(_Select_invoke_traits<_Fx,
        _Valtys...>::_Is_nothrow_invocable::value) { 
        ::std:: invoke(static_cast<_Fx&&>(_Func), static_cast<_Valtys&&>(_Vals)...);
    }
};

template <class _Rx>
struct _Invoker_ret<_Rx, false> { 
    template <class _Fx, class... _Valtys>
    static constexpr _Rx _Call(_Fx&& _Func, _Valtys&&... _Vals) noexcept(_Select_invoke_traits<_Fx,
        _Valtys...>::template _Is_nothrow_invocable_r<_Rx>::value) { 
        return ::std:: invoke(static_cast<_Fx&&>(_Func), static_cast<_Valtys&&>(_Vals)...);
    }
};

template <>
struct _Invoker_ret<_Unforced, false> { 
    template <class _Fx, class... _Valtys>
    static constexpr auto _Call(_Fx&& _Func, _Valtys&&... _Vals) noexcept(
        _Select_invoke_traits<_Fx, _Valtys...>::_Is_nothrow_invocable::value)
        -> decltype(::std:: invoke(static_cast<_Fx&&>(_Func), static_cast<_Valtys&&>(_Vals)...)) { 
        return ::std:: invoke(static_cast<_Fx&&>(_Func), static_cast<_Valtys&&>(_Vals)...);
    }
};

template <class _Fty>
class function;

template <class _Ty>
inline constexpr bool _Testable_callable_v =
    disjunction_v<is_pointer<_Ty>, _Is_specialization<_Ty, function>, is_member_pointer<_Ty>>;

template <class _Ty>
bool _Test_callable(const _Ty& _Arg) noexcept { 
    if constexpr (_Testable_callable_v<_Ty>) {
        return !!_Arg;
    } else {
        return true;
    }
}

template <class _Rx, class... _Types>
class __declspec(novtable) _Func_base { 
public:
    virtual _Func_base* _Copy(void*) const                 = 0;
    virtual _Func_base* _Move(void*) noexcept              = 0;
    virtual _Rx _Do_call(_Types&&...)                      = 0;
    virtual const type_info& _Target_type() const noexcept = 0;
    virtual void _Delete_this(bool) noexcept               = 0;


    const void* _Target(const type_info& _Info) const noexcept {
        return _Target_type() == _Info ? _Get() : nullptr;
    }
#line 717 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"

    _Func_base()                  = default;
    _Func_base(const _Func_base&) = delete;
    _Func_base& operator=(const _Func_base&) = delete;
    

private:
    virtual const void* _Get() const noexcept = 0;
};

constexpr size_t _Space_size = (_Small_object_num_ptrs - 1) * sizeof(void*);

template <class _Impl> 
inline constexpr bool _Is_large = sizeof(_Impl) > _Space_size || alignof(_Impl) > alignof(max_align_t)
                                    || !_Impl::_Nothrow_move::value;


#line 802 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"

template <class _Callable, class _Rx, class... _Types>
class _Func_impl_no_alloc final : public _Func_base<_Rx, _Types...> {
    
public:
    using _Mybase       = _Func_base<_Rx, _Types...>;
    using _Nothrow_move = is_nothrow_move_constructible<_Callable>;

    template <class _Other, enable_if_t<!is_same_v<_Func_impl_no_alloc, decay_t<_Other>>, int> = 0>
    explicit _Func_impl_no_alloc(_Other&& _Val) : _Callee(::std:: forward<_Other>(_Val)) {}

    
private:
    _Mybase* _Copy(void* _Where) const override {
        if constexpr (_Is_large<_Func_impl_no_alloc>) {
            return _Global_new<_Func_impl_no_alloc>(_Callee);
        } else {
            return ::new (_Where) _Func_impl_no_alloc(_Callee);
        }
    }

    _Mybase* _Move(void* _Where) noexcept override {
        if constexpr (_Is_large<_Func_impl_no_alloc>) {
            return nullptr;
        } else {
            return ::new (_Where) _Func_impl_no_alloc(::std:: move(_Callee));
        }
    }

    _Rx _Do_call(_Types&&... _Args) override { 
        return _Invoker_ret<_Rx>::_Call(_Callee, ::std:: forward<_Types>(_Args)...);
    }

    const type_info& _Target_type() const noexcept override {

        return typeid(_Callable);


#line 842 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"
    }

    const void* _Get() const noexcept override {
        return ::std:: addressof(_Callee);
    }

    void _Delete_this(bool _Dealloc) noexcept override { 
        this->~_Func_impl_no_alloc();
        if (_Dealloc) {
            _Deallocate<alignof(_Func_impl_no_alloc)>(this, sizeof(_Func_impl_no_alloc));
        }
    }

    _Callable _Callee;
};


#line 863 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"

template <class _Ret, class... _Types>
class _Func_class : public _Arg_types<_Types...> {
public:
    using result_type = _Ret;

    using _Ptrt = _Func_base<_Ret, _Types...>;

    _Func_class() noexcept {
        _Set(nullptr);
    }

    _Ret operator()(_Types... _Args) const {
        if (_Empty()) {
            _Xbad_function_call();
        }
        const auto _Impl = _Getimpl();
        return _Impl->_Do_call(::std:: forward<_Types>(_Args)...);
    }

    ~_Func_class() noexcept {
        _Tidy();
    }

protected:
    template <class _Fx, class _Function>
    using _Enable_if_callable_t = enable_if_t<conjunction_v<negation<is_same<_Remove_cvref_t<_Fx>, _Function>>,
                                                  _Is_invocable_r<_Ret, decay_t<_Fx>&, _Types...>>,
        int>;

    bool _Empty() const noexcept {
        return !_Getimpl();
    }

    void _Reset_copy(const _Func_class& _Right) { 
        if (!_Right._Empty()) {
            _Set(_Right._Getimpl()->_Copy(&_Mystorage));
        }
    }

    void _Reset_move(_Func_class&& _Right) noexcept { 
        if (!_Right._Empty()) {
            if (_Right._Local()) { 
                _Set(_Right._Getimpl()->_Move(&_Mystorage));
                _Right._Tidy();
            } else { 
                _Set(_Right._Getimpl());
                _Right._Set(nullptr);
            }
        }
    }

    template <class _Fx>
    void _Reset(_Fx&& _Val) { 
        if (!_Test_callable(_Val)) { 
            return; 
        }

        using _Impl = _Func_impl_no_alloc<decay_t<_Fx>, _Ret, _Types...>;
        if constexpr (_Is_large<_Impl>) {
            
            _Set(_Global_new<_Impl>(::std:: forward<_Fx>(_Val)));
        } else {
            
            _Set(::new (static_cast<void*>(&_Mystorage)) _Impl(::std:: forward<_Fx>(_Val)));
        }
    }


#line 955 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"

    void _Tidy() noexcept {
        if (!_Empty()) { 
            _Getimpl()->_Delete_this(!_Local());
            _Set(nullptr);
        }
    }

    void _Swap(_Func_class& _Right) noexcept { 
        if (!_Local() && !_Right._Local()) { 
            _Ptrt* _Temp = _Getimpl();
            _Set(_Right._Getimpl());
            _Right._Set(_Temp);
        } else { 
            _Func_class _Temp;
            _Temp._Reset_move(::std:: move(*this));
            _Reset_move(::std:: move(_Right));
            _Right._Reset_move(::std:: move(_Temp));
        }
    }


    const type_info& _Target_type() const noexcept {
        return _Getimpl() ? _Getimpl()->_Target_type() : typeid(void);
    }

    const void* _Target(const type_info& _Info) const noexcept {
        return _Getimpl() ? _Getimpl()->_Target(_Info) : nullptr;
    }
#line 985 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"

private:
    bool _Local() const noexcept { 
        return _Getimpl() == static_cast<const void*>(&_Mystorage);
    }

    union _Storage { 
        max_align_t _Dummy1; 
        char _Dummy2[_Space_size]; 
        _Ptrt* _Ptrs[_Small_object_num_ptrs]; 
    };

    _Storage _Mystorage;
    enum { _EEN_IMPL = _Small_object_num_ptrs - 1 }; 
    _Ptrt* _Getimpl() const noexcept { 
        return _Mystorage._Ptrs[_Small_object_num_ptrs - 1];
    }

    void _Set(_Ptrt* _Ptr) noexcept { 
        _Mystorage._Ptrs[_Small_object_num_ptrs - 1] = _Ptr;
    }
};

template <class _Tx>
struct _Get_function_impl {
    static_assert(_Always_false<_Tx>, "std::function only accepts function types as template arguments.");
};


template <class _Ret, class... _Types> struct _Get_function_impl<_Ret __cdecl(_Types...)> { using type = _Func_class<_Ret, _Types...>; };  template <class _Ret, class... _Types> struct _Get_function_impl<_Ret __fastcall(_Types...)> { using type = _Func_class<_Ret, _Types...>; }; template <class _Ret, class... _Types> struct _Get_function_impl<_Ret __stdcall(_Types...)> { using type = _Func_class<_Ret, _Types...>; }; template <class _Ret, class... _Types> struct _Get_function_impl<_Ret __vectorcall(_Types...)> { using type = _Func_class<_Ret, _Types...>; };


template <class _Ret, class... _Types> struct _Get_function_impl<_Ret __cdecl(_Types...) noexcept> { static_assert( _Always_false<_Ret>, "std::function does not accept noexcept function types as template arguments."); };  template <class _Ret, class... _Types> struct _Get_function_impl<_Ret __fastcall(_Types...) noexcept> { static_assert( _Always_false<_Ret>, "std::function does not accept noexcept function types as template arguments."); }; template <class _Ret, class... _Types> struct _Get_function_impl<_Ret __stdcall(_Types...) noexcept> { static_assert( _Always_false<_Ret>, "std::function does not accept noexcept function types as template arguments."); }; template <class _Ret, class... _Types> struct _Get_function_impl<_Ret __vectorcall(_Types...) noexcept> { static_assert( _Always_false<_Ret>, "std::function does not accept noexcept function types as template arguments."); };

#line 1032 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"

template <class _Fty>
class function : public _Get_function_impl<_Fty>::type { 
private:
    using _Mybase = typename _Get_function_impl<_Fty>::type;

public:
    function() noexcept {}

    function(nullptr_t) noexcept {}

    function(const function& _Right) {
        this->_Reset_copy(_Right);
    }


    template <class _Fx, typename _Mybase::template _Enable_if_callable_t<_Fx, function> = 0>


#line 1052 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"
    function(_Fx&& _Func) {
        this->_Reset(::std:: forward<_Fx>(_Func));
    }


#line 1077 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"

    function& operator=(const function& _Right) {
        function(_Right).swap(*this);
        return *this;
    }

    function(function&& _Right) noexcept {
        this->_Reset_move(::std:: move(_Right));
    }


#line 1093 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"

    function& operator=(function&& _Right) noexcept  {
        if (this != ::std:: addressof(_Right)) {
            this->_Tidy();
            this->_Reset_move(::std:: move(_Right));
        }
        return *this;
    }


    template <class _Fx, typename _Mybase::template _Enable_if_callable_t<_Fx, function> = 0>


#line 1107 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"
    function& operator=(_Fx&& _Func) {
        function(::std:: forward<_Fx>(_Func)).swap(*this);
        return *this;
    }


#line 1118 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"

    function& operator=(nullptr_t) noexcept {
        this->_Tidy();
        return *this;
    }

    template <class _Fx>
    function& operator=(reference_wrapper<_Fx> _Func) noexcept {
        this->_Tidy();
        this->_Reset(_Func);
        return *this;
    }

    void swap(function& _Right) noexcept {
        this->_Swap(_Right);
    }

    explicit operator bool() const noexcept {
        return !this->_Empty();
    }


    [[nodiscard]] const type_info& target_type() const noexcept {
        return this->_Target_type();
    }

    template <class _Fx>
    [[nodiscard]] _Fx* target() noexcept {
        return reinterpret_cast<_Fx*>(const_cast<void*>(this->_Target(typeid(_Fx))));
    }

    template <class _Fx>
    [[nodiscard]] const _Fx* target() const noexcept {
        return reinterpret_cast<const _Fx*>(this->_Target(typeid(_Fx)));
    }


#line 1162 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"
};


template <class _Ret, class... _Types> function(_Ret(__cdecl*)(_Types...)) -> function<_Ret(_Types...)>;  template <class _Ret, class... _Types> function(_Ret(__fastcall*)(_Types...)) -> function<_Ret(_Types...)>; template <class _Ret, class... _Types> function(_Ret(__stdcall*)(_Types...)) -> function<_Ret(_Types...)>; template <class _Ret, class... _Types> function(_Ret(__vectorcall*)(_Types...)) -> function<_Ret(_Types...)>;


template <class _Fx, class = void>
struct _Deduce_signature {}; 

template <class _Fx>
struct _Deduce_signature<_Fx, void_t<decltype(&_Fx::operator())>>
    : _Is_memfunptr<decltype(&_Fx::operator())>::_Guide_type {}; 

template <class _Fx>
function(_Fx) -> function<typename _Deduce_signature<_Fx>::type>;
#line 1182 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"

template <class _Fty>
void swap(function<_Fty>& _Left, function<_Fty>& _Right) noexcept {
    _Left.swap(_Right);
}

template <class _Fty>
[[nodiscard]] bool operator==(const function<_Fty>& _Other, nullptr_t) noexcept {
    return !_Other;
}


#line 1209 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"


union alignas(max_align_t) _Move_only_function_data {
    void* _Pointers[_Small_object_num_ptrs];
    const void* _Impl;
    char _Data; 

    template <class _Fn>
    static constexpr size_t _Buf_offset = alignof(_Fn) <= sizeof(_Impl)
                                            ? sizeof(_Impl) 
                                            : alignof(_Fn); 

    template <class _Fn>
    static constexpr size_t _Buf_size = sizeof(_Pointers) - _Buf_offset<_Fn>;

    template <class _Fn>
    [[nodiscard]] void* _Buf_ptr() noexcept {
        return &_Data + _Buf_offset<_Fn>;
    }

    template <class _Fn>
    [[nodiscard]] _Fn* _Small_fn_ptr() const noexcept {
        
        
        return static_cast<_Fn*>(const_cast<_Move_only_function_data*>(this)->_Buf_ptr<_Fn>());
    }

    template <class _Fn>
    [[nodiscard]] _Fn* _Large_fn_ptr() const noexcept {
        return static_cast<_Fn*>(_Pointers[1]);
    }

    void _Set_large_fn_ptr(void* const _Value) noexcept {
        _Pointers[1] = _Value;
    }
};


inline constexpr size_t _Minimum_function_size = 2 * sizeof(void*);


template <class _Rx, class... _Types>
[[noreturn]] _Rx __stdcall _Function_not_callable(const _Move_only_function_data&, _Types&&...) noexcept {
    :: abort(); 
                   
}

template <class _Vt, class _VtInvQuals, class _Rx, bool _Noex, class... _Types>
[[nodiscard]] _Rx __stdcall _Function_inv_small(const _Move_only_function_data& _Self, _Types&&... _Args) noexcept(_Noex) {
    return _Invoker_ret<_Rx>::_Call(
        static_cast<_VtInvQuals>(*_Self._Small_fn_ptr<_Vt>()), ::std:: forward<_Types>(_Args)...);
}

template <class _Vt, class _VtInvQuals, class _Rx, bool _Noex, class... _Types>
[[nodiscard]] _Rx __stdcall _Function_inv_large(const _Move_only_function_data& _Self, _Types&&... _Args) noexcept(_Noex) {
    return _Invoker_ret<_Rx>::_Call(
        static_cast<_VtInvQuals>(*_Self._Large_fn_ptr<_Vt>()), ::std:: forward<_Types>(_Args)...);
}

template <class _Vt>
void __stdcall _Function_move_small(_Move_only_function_data& _Self, _Move_only_function_data& _Src) noexcept {
    const auto _Src_fn_ptr = _Src._Small_fn_ptr<_Vt>();
    ::new (_Self._Buf_ptr<_Vt>()) _Vt(::std:: move(*_Src_fn_ptr));
    _Src_fn_ptr->~_Vt();
    _Self._Impl = _Src._Impl;
}

template <size_t _Size>
void __stdcall _Function_move_memcpy(_Move_only_function_data& _Self, _Move_only_function_data& _Src) noexcept {
    :: memcpy(&_Self._Data, &_Src._Data, _Size); 
}

inline void __stdcall _Function_move_large(_Move_only_function_data& _Self, _Move_only_function_data& _Src) noexcept {
    :: memcpy(&_Self._Data, &_Src._Data, _Minimum_function_size); 
}

template <class _Vt>
void __stdcall _Function_destroy_small(_Move_only_function_data& _Self) noexcept {
    _Self._Small_fn_ptr<_Vt>()->~_Vt();
}

inline void __stdcall _Function_deallocate_large_default_aligned(_Move_only_function_data& _Self) noexcept {
    ::operator delete(_Self._Large_fn_ptr<void>());
}

template <size_t _Align>
void __stdcall _Function_deallocate_large_overaligned(_Move_only_function_data& _Self) noexcept {
    ::operator delete (_Self._Large_fn_ptr<void>(), align_val_t{_Align});
}

template <class _Vt>
void __stdcall _Function_destroy_large(_Move_only_function_data& _Self) noexcept {
    const auto _Pfn = _Self._Large_fn_ptr<_Vt>();
    _Pfn->~_Vt();
    if constexpr (alignof(_Vt) <= 8u) {
        ::operator delete(static_cast<void*>(_Pfn));
    } else {
        ::operator delete (static_cast<void*>(_Pfn), align_val_t{alignof(_Vt)});
    }
}

template <class _Vt>
inline constexpr size_t _Function_small_copy_size = 
    _Move_only_function_data::_Buf_offset<_Vt> + 
    (size_t{sizeof(_Vt) + sizeof(void*) - 1} & ~size_t{sizeof(void*) - 1}); 

template <class _Vt, class... _CTypes>
[[nodiscard]] void* _Function_new_large(_CTypes&&... _Args) {
    struct [[nodiscard]] _Guard_type {
        void* _Ptr;

        ~_Guard_type() {
            
            
            if (_Ptr) {
                if constexpr (alignof(_Vt) <= 8u) {
                    ::operator delete(_Ptr);
                } else {
                    ::operator delete (_Ptr, align_val_t{alignof(_Vt)});
                }
            }
        }
    };

    void* _Ptr;
    if constexpr (alignof(_Vt) <= 8u) {
        _Ptr = ::operator new(sizeof(_Vt));
    } else {
        _Ptr = ::operator new (sizeof(_Vt), align_val_t{alignof(_Vt)});
    }
    _Guard_type _Guard{_Ptr};
    ::new (_Ptr) _Vt(::std:: forward<_CTypes>(_Args)...);
    _Guard._Ptr = nullptr;
    return _Ptr;
}

template <class _Rx, bool _Noexcept, class... _Types>
class _Move_only_function_base {
public:
    
    template <bool>
    struct _Invoke_t {
        using _Call = _Rx(__stdcall*)(const _Move_only_function_data&, _Types&&...);
    };

    template <>
    struct _Invoke_t<true> {
        using _Call = _Rx(__stdcall*)(const _Move_only_function_data&, _Types&&...) noexcept;
    };

    struct _Impl_t { 
        
        
        typename _Invoke_t<_Noexcept>::_Call _Invoke;
        
        void(__stdcall* _Move)(_Move_only_function_data&, _Move_only_function_data&) noexcept;
        
        void(__stdcall* _Destroy)(_Move_only_function_data&) noexcept;
    };

    static constexpr _Impl_t _Null_move_only_function = {
        _Function_not_callable<_Rx, _Types...>,
        nullptr,
        nullptr,
    };

    _Move_only_function_data _Data;

    _Move_only_function_base() noexcept = default; 

    _Move_only_function_base(_Move_only_function_base&& _Other) noexcept {
        _Checked_move(_Data, _Other._Data);
        _Other._Reset_to_null();
    }

    void _Construct_with_null() noexcept {
        _Data._Impl = &_Null_move_only_function;
        _Data._Set_large_fn_ptr(nullptr); 
    }

    void _Reset_to_null() noexcept {
        _Data._Impl = &_Null_move_only_function;
    }

    template <class _Vt, class _VtInvQuals, class... _CTypes>
    void _Construct_with_fn(_CTypes&&... _Args) {
        _Data._Impl = _Create_impl_ptr<_Vt, _VtInvQuals>();
        if constexpr (_Large_function_engaged<_Vt>) {
            _Data._Set_large_fn_ptr(_Function_new_large<_Vt>(::std:: forward<_CTypes>(_Args)...));
        } else {
            ::new (_Data._Buf_ptr<_Vt>()) _Vt(::std:: forward<_CTypes>(_Args)...);
        }
    }

    static void _Checked_destroy(_Move_only_function_data& _Data) noexcept {
        const auto _Impl = static_cast<const _Impl_t*>(_Data._Impl);
        if (_Impl->_Destroy) {
            _Impl->_Destroy(_Data);
        }
    }

    static void _Checked_move(_Move_only_function_data& _Data, _Move_only_function_data& _Src) noexcept {
        const auto _Impl = static_cast<const _Impl_t*>(_Src._Impl);
        if (_Impl->_Move) {
            _Impl->_Move(_Data, _Src);
        } else {
            _Function_move_large(_Data, _Src);
        }
    }

    void _Move_assign(_Move_only_function_base&& _Other) noexcept {
        
        
        const auto _Other_impl_move   = static_cast<const _Impl_t*>(_Other._Data._Impl)->_Move;
        const auto _This_impl_destroy = static_cast<const _Impl_t*>(_Data._Impl)->_Destroy;

        if (!_Other_impl_move) {
            
            if (_This_impl_destroy) {
                _This_impl_destroy(_Data);
            }
            _Function_move_large(_Data, _Other._Data);
        } else if (!_This_impl_destroy) {
            
            _Other_impl_move(_Data, _Other._Data);
        } else {
            
            _Move_only_function_data _Tmp;
            _Checked_move(_Tmp, _Data);
            _Other_impl_move(_Data, _Other._Data);
            _This_impl_destroy(_Tmp);
        }
        _Other._Reset_to_null();
    }

    void _Swap(_Move_only_function_base& _Other) noexcept {
        _Move_only_function_data _Tmp;

        _Checked_move(_Tmp, _Data);
        _Checked_move(_Data, _Other._Data);
        _Checked_move(_Other._Data, _Tmp);
    }

    [[nodiscard]] bool _Is_null() const noexcept {
        return _Data._Impl == &_Null_move_only_function;
    }

    template <class _Vt>
    static constexpr bool _Large_function_engaged =
        alignof(_Vt) > alignof(max_align_t)
        || sizeof(_Vt) > _Move_only_function_data::_Buf_size<_Vt> || !is_nothrow_move_constructible_v<_Vt>;

    [[nodiscard]] auto _Get_invoke() const noexcept {
        return static_cast<const _Impl_t*>(_Data._Impl)->_Invoke;
    }

    template <class _Vt, class _VtInvQuals>
    [[nodiscard]] static constexpr _Impl_t _Create_impl() noexcept {
        _Impl_t _Impl{};
        if constexpr (_Large_function_engaged<_Vt>) {
            _Impl._Invoke = _Function_inv_large<_Vt, _VtInvQuals, _Rx, _Noexcept, _Types...>;
            _Impl._Move   = nullptr;

            if constexpr (is_trivially_destructible_v<_Vt>) {
                if constexpr (alignof(_Vt) <= 8u) {
                    _Impl._Destroy = _Function_deallocate_large_default_aligned;
                } else {
                    _Impl._Destroy = _Function_deallocate_large_overaligned<alignof(_Vt)>;
                }
            } else {
                _Impl._Destroy = _Function_destroy_large<_Vt>;
            }
        } else {
            _Impl._Invoke = _Function_inv_small<_Vt, _VtInvQuals, _Rx, _Noexcept, _Types...>;

            if constexpr (is_trivially_copyable_v<_Vt> && is_trivially_destructible_v<_Vt>) {
                if constexpr ((_Function_small_copy_size<_Vt>) > _Minimum_function_size) {
                    _Impl._Move = _Function_move_memcpy<_Function_small_copy_size<_Vt>>;
                } else {
                    _Impl._Move = nullptr;
                }
            } else {
                _Impl._Move = _Function_move_small<_Vt>;
            }

            if constexpr (is_trivially_destructible_v<_Vt>) {
                _Impl._Destroy = nullptr;
            } else {
                _Impl._Destroy = _Function_destroy_small<_Vt>;
            }
        }
        return _Impl;
    }

    template <class _Vt, class _VtInvQuals>
    [[nodiscard]] static const _Impl_t* _Create_impl_ptr() noexcept {
        static constexpr _Impl_t _Impl = _Create_impl<_Vt, _VtInvQuals>();
        return &_Impl;
    }
};

template <class... _Signature>
class _Move_only_function_call {
    static_assert((_Always_false<_Signature> || ...),
        "std::move_only_function only accepts function types as template arguments, "
        "with possibly const/ref/noexcept qualifiers.");

    static_assert(sizeof...(_Signature) > 0,
        "Unlike std::function, std::move_only_function does not define class template argument deduction guides.");
};


template <class _Rx, class... _Types>
class _Move_only_function_call<_Rx(_Types...)> : public _Move_only_function_base<_Rx, false, _Types...> {
public:
    using result_type = _Rx;

    template <class _Vt>
    using _VtInvQuals = _Vt&;

    template <class _Vt>
    static constexpr bool _Is_callable_from =
        is_invocable_r_v<_Rx, _Vt, _Types...>&& is_invocable_r_v<_Rx, _Vt&, _Types...>;

    _Rx operator()(_Types... _Args) {
        return this->_Get_invoke()(this->_Data, ::std:: forward<_Types>(_Args)...);
    }
};

template <class _Rx, class... _Types>
class _Move_only_function_call<_Rx(_Types...)&> : public _Move_only_function_base<_Rx, false, _Types...> {
public:
    using result_type = _Rx;

    template <class _Vt>
    using _VtInvQuals = _Vt&;

    template <class _Vt>
    static constexpr bool _Is_callable_from = is_invocable_r_v<_Rx, _Vt&, _Types...>;

    _Rx operator()(_Types... _Args) & {
        return this->_Get_invoke()(this->_Data, ::std:: forward<_Types>(_Args)...);
    }
};

template <class _Rx, class... _Types>
class _Move_only_function_call<_Rx(_Types...) &&> : public _Move_only_function_base<_Rx, false, _Types...> {
public:
    using result_type = _Rx;

    template <class _Vt>
    using _VtInvQuals = _Vt&&;

    template <class _Vt>
    static constexpr bool _Is_callable_from = is_invocable_r_v<_Rx, _Vt, _Types...>;

    _Rx operator()(_Types... _Args) && {
        return this->_Get_invoke()(this->_Data, ::std:: forward<_Types>(_Args)...);
    }
};

template <class _Rx, class... _Types>
class _Move_only_function_call<_Rx(_Types...) const> : public _Move_only_function_base<_Rx, false, _Types...> {
public:
    using result_type = _Rx;

    template <class _Vt>
    using _VtInvQuals = const _Vt&;

    template <class _Vt>
    static constexpr bool _Is_callable_from =
        is_invocable_r_v<_Rx, const _Vt, _Types...>&& is_invocable_r_v<_Rx, const _Vt&, _Types...>;

    _Rx operator()(_Types... _Args) const {
        return this->_Get_invoke()(this->_Data, ::std:: forward<_Types>(_Args)...);
    }
};

template <class _Rx, class... _Types>
class _Move_only_function_call<_Rx(_Types...) const&> : public _Move_only_function_base<_Rx, false, _Types...> {
public:
    using result_type = _Rx;

    template <class _Vt>
    using _VtInvQuals = const _Vt&;

    template <class _Vt>
    static constexpr bool _Is_callable_from = is_invocable_r_v<_Rx, const _Vt&, _Types...>;

    _Rx operator()(_Types... _Args) const& {
        return this->_Get_invoke()(this->_Data, ::std:: forward<_Types>(_Args)...);
    }
};

template <class _Rx, class... _Types>
class _Move_only_function_call<_Rx(_Types...) const&&> : public _Move_only_function_base<_Rx, false, _Types...> {
public:
    using result_type = _Rx;

    template <class _Vt>
    using _VtInvQuals = const _Vt&&;

    template <class _Vt>
    static constexpr bool _Is_callable_from = is_invocable_r_v<_Rx, const _Vt, _Types...>;

    _Rx operator()(_Types... _Args) const&& {
        return this->_Get_invoke()(this->_Data, ::std:: forward<_Types>(_Args)...);
    }
};


template <class _Rx, class... _Types>
class _Move_only_function_call<_Rx(_Types...) noexcept> : public _Move_only_function_base<_Rx, true, _Types...> {
public:
    using result_type = _Rx;

    template <class _Vt>
    using _VtInvQuals = _Vt&;

    template <class _Vt>
    static constexpr bool _Is_callable_from =
        is_nothrow_invocable_r_v<_Rx, _Vt, _Types...>&& is_nothrow_invocable_r_v<_Rx, _Vt&, _Types...>;

    _Rx operator()(_Types... _Args) noexcept {
        return this->_Get_invoke()(this->_Data, ::std:: forward<_Types>(_Args)...);
    }
};

template <class _Rx, class... _Types>
class _Move_only_function_call<_Rx(_Types...)& noexcept> : public _Move_only_function_base<_Rx, true, _Types...> {
public:
    using result_type = _Rx;

    template <class _Vt>
    using _VtInvQuals = _Vt&;

    template <class _Vt>
    static constexpr bool _Is_callable_from = is_nothrow_invocable_r_v<_Rx, _Vt&, _Types...>;

    _Rx operator()(_Types... _Args) & noexcept {
        return this->_Get_invoke()(this->_Data, ::std:: forward<_Types>(_Args)...);
    }
};

template <class _Rx, class... _Types>
class _Move_only_function_call<_Rx(_Types...)&& noexcept> : public _Move_only_function_base<_Rx, true, _Types...> {
public:
    using result_type = _Rx;

    template <class _Vt>
    using _VtInvQuals = _Vt&&;

    template <class _Vt>
    static constexpr bool _Is_callable_from = is_nothrow_invocable_r_v<_Rx, _Vt, _Types...>;

    _Rx operator()(_Types... _Args) && noexcept {
        return this->_Get_invoke()(this->_Data, ::std:: forward<_Types>(_Args)...);
    }
};

template <class _Rx, class... _Types>
class _Move_only_function_call<_Rx(_Types...) const noexcept> : public _Move_only_function_base<_Rx, true, _Types...> {
public:
    using result_type = _Rx;

    template <class _Vt>
    using _VtInvQuals = const _Vt&;

    template <class _Vt>
    static constexpr bool _Is_callable_from =
        is_nothrow_invocable_r_v<_Rx, const _Vt, _Types...>&& is_nothrow_invocable_r_v<_Rx, const _Vt&, _Types...>;

    _Rx operator()(_Types... _Args) const noexcept {
        return this->_Get_invoke()(this->_Data, ::std:: forward<_Types>(_Args)...);
    }
};

template <class _Rx, class... _Types>
class _Move_only_function_call<_Rx(_Types...) const& noexcept> : public _Move_only_function_base<_Rx, true, _Types...> {
public:
    using result_type = _Rx;

    template <class _Vt>
    using _VtInvQuals = const _Vt&;

    template <class _Vt>
    static constexpr bool _Is_callable_from = is_nothrow_invocable_r_v<_Rx, const _Vt&, _Types...>;

    _Rx operator()(_Types... _Args) const& noexcept {
        return this->_Get_invoke()(this->_Data, ::std:: forward<_Types>(_Args)...);
    }
};

template <class _Rx, class... _Types>
class _Move_only_function_call<_Rx(_Types...) const&& noexcept>
    : public _Move_only_function_base<_Rx, true, _Types...> {
public:
    using result_type = _Rx;

    template <class _Vt>
    using _VtInvQuals = const _Vt&&;

    template <class _Vt>
    static constexpr bool _Is_callable_from = is_nothrow_invocable_r_v<_Rx, const _Vt, _Types...>;

    _Rx operator()(_Types... _Args) const&& noexcept {
        return this->_Get_invoke()(this->_Data, ::std:: forward<_Types>(_Args)...);
    }
};
#line 1736 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"

template <class... _Signature>
class move_only_function : private _Move_only_function_call<_Signature...> {
private:
    using _Call = _Move_only_function_call<_Signature...>;

    
    template <class _Fn>
    static constexpr bool _Enable_one_arg_constructor =
        !is_same_v<remove_cvref_t<_Fn>, move_only_function>
        && !_Is_specialization_v<remove_cvref_t<_Fn>, in_place_type_t>
        && _Call::template _Is_callable_from<decay_t<_Fn>>;

    template <class _Fn, class... _CTypes>
    static constexpr bool _Enable_in_place_constructor =
        is_constructible_v<decay_t<_Fn>, _CTypes...>
        && _Call::template _Is_callable_from<decay_t<_Fn>>;

    template <class _Fn, class _Ux, class... _CTypes>
    static constexpr bool _Enable_in_place_list_constructor =
        is_constructible_v<decay_t<_Fn>, initializer_list<_Ux>&, _CTypes...>
        && _Call::template _Is_callable_from<decay_t<_Fn>>;
    
public:
    using typename _Call::result_type;

    move_only_function() noexcept {
        this->_Construct_with_null();
    }

    move_only_function(nullptr_t) noexcept {
        this->_Construct_with_null();
    }

    move_only_function(move_only_function&&) noexcept = default;

    template <class _Fn, enable_if_t<_Enable_one_arg_constructor<_Fn>, int> = 0>
    move_only_function(_Fn&& _Callable) {
        using _Vt = decay_t<_Fn>;
        static_assert(is_constructible_v<_Vt, _Fn>, "_Vt should be constructible from _Fn. "
                                                    "(N4901 [func.wrap.move.ctor]/6)");

        if constexpr (is_member_pointer_v<_Vt> || is_pointer_v<_Vt> || _Is_specialization_v<_Vt, move_only_function>) {
            if (_Callable == nullptr) {
                this->_Construct_with_null();
                return;
            }
        }

        using _VtInvQuals = typename _Call::template _VtInvQuals<_Vt>;
        this->template _Construct_with_fn<_Vt, _VtInvQuals>(::std:: forward<_Fn>(_Callable));
    }

    template <class _Fn, class... _CTypes, enable_if_t<_Enable_in_place_constructor<_Fn, _CTypes...>, int> = 0>
    explicit move_only_function(in_place_type_t<_Fn>, _CTypes&&... _Args) {
        using _Vt = decay_t<_Fn>;
        static_assert(is_same_v<_Vt, _Fn>, "_Vt should be the same type as _Fn. (N4901 [func.wrap.move.ctor]/12)");

        using _VtInvQuals = typename _Call::template _VtInvQuals<_Vt>;
        this->template _Construct_with_fn<_Vt, _VtInvQuals>(::std:: forward<_CTypes>(_Args)...);
    }

    template <class _Fn, class _Ux, class... _CTypes,
        enable_if_t<_Enable_in_place_list_constructor<_Fn, _Ux, _CTypes...>, int> = 0>
    explicit move_only_function(in_place_type_t<_Fn>, initializer_list<_Ux> _Li, _CTypes&&... _Args) {
        using _Vt = decay_t<_Fn>;
        static_assert(is_same_v<_Vt, _Fn>, "_Vt should be the same type as _Fn. (N4901 [func.wrap.move.ctor]/18)");

        using _VtInvQuals = typename _Call::template _VtInvQuals<_Vt>;
        this->template _Construct_with_fn<_Vt, _VtInvQuals>(_Li, ::std:: forward<_CTypes>(_Args)...);
    }

    ~move_only_function() {
        
        
        this->_Checked_destroy(this->_Data);
    }

    move_only_function& operator=(nullptr_t) noexcept {
        this->_Checked_destroy(this->_Data);
        this->_Reset_to_null();
        return *this;
    }

    move_only_function& operator=(move_only_function&& _Other) {
        if (this != ::std:: addressof(_Other)) {
            this->_Move_assign(::std:: move(_Other));
        }
        return *this;
    }

    template <class _Fn, enable_if_t<is_constructible_v<move_only_function, _Fn>, int> = 0>
    move_only_function& operator=(_Fn&& _Callable) {
        this->_Move_assign(move_only_function{::std:: forward<_Fn>(_Callable)});
        return *this;
    }

    [[nodiscard]] explicit operator bool() const noexcept {
        return !this->_Is_null();
    }

    using _Call::operator();

    void swap(move_only_function& _Other) noexcept {
        this->_Swap(_Other);
    }

    friend void swap(move_only_function& _Fn1, move_only_function& _Fn2) noexcept {
        _Fn1._Swap(_Fn2);
    }

    [[nodiscard]] friend bool operator==(const move_only_function& _This, nullptr_t) noexcept {
        return _This._Is_null();
    }
};
#line 1852 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"

template <int _Nx>
struct _Ph { 
    static_assert(_Nx > 0, "invalid placeholder index");
};

template <class _Tx>
struct is_placeholder : integral_constant<int, 0> {}; 

template <int _Nx>
struct is_placeholder<_Ph<_Nx>> : integral_constant<int, _Nx> {}; 

template <class _Tx>
struct is_placeholder<const _Tx> : is_placeholder<_Tx>::type {}; 

template <class _Tx>
struct is_placeholder<volatile _Tx> : is_placeholder<_Tx>::type {}; 

template <class _Tx>
struct is_placeholder<const volatile _Tx> : is_placeholder<_Tx>::type {}; 

template <class _Ty>
inline constexpr int is_placeholder_v = is_placeholder<_Ty>::value;

template <class _Ret, class _Fx, class... _Types>
class _Binder;

template <class _Tx>
struct is_bind_expression : false_type {}; 

template <class _Ret, class _Fx, class... _Types>
struct is_bind_expression<_Binder<_Ret, _Fx, _Types...>> : true_type {}; 

template <class _Tx>
struct is_bind_expression<const _Tx> : is_bind_expression<_Tx>::type {}; 

template <class _Tx>
struct is_bind_expression<volatile _Tx> : is_bind_expression<_Tx>::type {}; 

template <class _Tx>
struct is_bind_expression<const volatile _Tx> : is_bind_expression<_Tx>::type {}; 

template <class _Ty>
inline constexpr bool is_bind_expression_v = is_bind_expression<_Ty>::value;

template <class _Cv_TiD, bool = _Is_specialization_v<remove_cv_t<_Cv_TiD>, reference_wrapper>,
    bool = is_bind_expression_v<_Cv_TiD>, int = is_placeholder_v<_Cv_TiD>>
struct _Select_fixer;

template <class _Cv_TiD>
struct _Select_fixer<_Cv_TiD, true, false, 0> { 
    template <class _Untuple>
    static constexpr auto _Fix(_Cv_TiD& _Tid, _Untuple&&) noexcept -> typename _Cv_TiD::type& {
        
        return _Tid.get();
    }
};

template <class _Cv_TiD>
struct _Select_fixer<_Cv_TiD, false, true, 0> { 
    template <class _Untuple, size_t... _Jx>
    static constexpr auto _Apply(_Cv_TiD& _Tid, _Untuple&& _Ut, index_sequence<_Jx...>) noexcept(
        noexcept(_Tid(::std:: get<_Jx>(::std:: move(_Ut))...))) -> decltype(_Tid(::std:: get<_Jx>(::std:: move(_Ut))...)) {
        
        return _Tid(::std:: get<_Jx>(::std:: move(_Ut))...);
    }

    template <class _Untuple>
    static constexpr auto _Fix(_Cv_TiD& _Tid, _Untuple&& _Ut) noexcept(
        noexcept(_Apply(_Tid, ::std:: move(_Ut), make_index_sequence<tuple_size_v<_Untuple>>{})))
        -> decltype(_Apply(_Tid, ::std:: move(_Ut), make_index_sequence<tuple_size_v<_Untuple>>{})) {
        
        return _Apply(_Tid, ::std:: move(_Ut), make_index_sequence<tuple_size_v<_Untuple>>{});
    }
};

template <class _Cv_TiD>
struct _Select_fixer<_Cv_TiD, false, false, 0> { 
    template <class _Untuple>
    static constexpr _Cv_TiD& _Fix(_Cv_TiD& _Tid, _Untuple&&) noexcept {
        
        return _Tid;
    }
};

template <class _Cv_TiD, int _Jx>
struct _Select_fixer<_Cv_TiD, false, false, _Jx> { 
    static_assert(_Jx > 0, "invalid is_placeholder value");

    template <class _Untuple>
    static constexpr auto _Fix(_Cv_TiD&, _Untuple&& _Ut) noexcept
        -> decltype(::std:: get<_Jx - 1>(::std:: move(_Ut))) { 
        return ::std:: get<_Jx - 1>(::std:: move(_Ut));
    }
};

template <class _Cv_TiD, class _Untuple>
constexpr auto _Fix_arg(_Cv_TiD& _Tid, _Untuple&& _Ut) noexcept(
    noexcept(_Select_fixer<_Cv_TiD>::_Fix(_Tid, ::std:: move(_Ut))))
    -> decltype(_Select_fixer<_Cv_TiD>::_Fix(_Tid, ::std:: move(_Ut))) { 
    return _Select_fixer<_Cv_TiD>::_Fix(_Tid, ::std:: move(_Ut));
}

template <class _Ret, size_t... _Ix, class _Cv_FD, class _Cv_tuple_TiD, class _Untuple>
constexpr auto _Call_binder(_Invoker_ret<_Ret>, index_sequence<_Ix...>, _Cv_FD& _Obj, _Cv_tuple_TiD& _Tpl,
    _Untuple&& _Ut) noexcept(noexcept(_Invoker_ret<_Ret>::_Call(_Obj,
    _Fix_arg(::std:: get<_Ix>(_Tpl), ::std:: move(_Ut))...)))
    -> decltype(_Invoker_ret<_Ret>::_Call(_Obj, _Fix_arg(::std:: get<_Ix>(_Tpl), ::std:: move(_Ut))...)) {
    
    return _Invoker_ret<_Ret>::_Call(_Obj, _Fix_arg(::std:: get<_Ix>(_Tpl), ::std:: move(_Ut))...);
}

template <class _Ret>
struct _Forced_result_type { 
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef _Ret _Unnameable_result;
};

template <class _Ret, class _Fx>
struct _Binder_result_type { 
    using _Decayed = decay_t<_Fx>;

    using _All_weak_types = _Weak_types<_Decayed>;

    using type =
        conditional_t<is_same_v<_Ret, _Unforced>, _Weak_result_type<_All_weak_types>, _Forced_result_type<_Ret>>;
};

template <class _Ret, class _Fx, class... _Types>
class _Binder : public _Binder_result_type<_Ret, _Fx>::type { 
private:
    using _Seq    = index_sequence_for<_Types...>;
    using _First  = decay_t<_Fx>;
    using _Second = tuple<decay_t<_Types>...>;

    _Compressed_pair<_First, _Second> _Mypair;

public:
    constexpr explicit _Binder(_Fx&& _Func, _Types&&... _Args)
        : _Mypair(_One_then_variadic_args_t{}, ::std:: forward<_Fx>(_Func), ::std:: forward<_Types>(_Args)...) {}


    template <class... _Unbound>
    constexpr auto operator()(_Unbound&&... _Unbargs) noexcept(noexcept(_Call_binder(_Invoker_ret<_Ret>{}, _Seq{}, _Mypair._Get_first(), _Mypair._Myval2, ::std:: forward_as_tuple(::std:: forward<_Unbound>(_Unbargs)...)))) -> decltype(_Call_binder(_Invoker_ret<_Ret>{}, _Seq{}, _Mypair._Get_first(), _Mypair._Myval2, ::std:: forward_as_tuple(::std:: forward<_Unbound>(_Unbargs)...))) {
        return _Call_binder(_Invoker_ret<_Ret>{}, _Seq{}, _Mypair._Get_first(), _Mypair._Myval2, ::std:: forward_as_tuple(::std:: forward<_Unbound>(_Unbargs)...));
    }

    template <class... _Unbound>
    constexpr auto operator()(_Unbound&&... _Unbargs) const noexcept(noexcept(_Call_binder(_Invoker_ret<_Ret>{}, _Seq{}, _Mypair._Get_first(), _Mypair._Myval2, ::std:: forward_as_tuple(::std:: forward<_Unbound>(_Unbargs)...))))
        -> decltype(_Call_binder(_Invoker_ret<_Ret>{}, _Seq{}, _Mypair._Get_first(), _Mypair._Myval2, ::std:: forward_as_tuple(::std:: forward<_Unbound>(_Unbargs)...))) {
        return _Call_binder(_Invoker_ret<_Ret>{}, _Seq{}, _Mypair._Get_first(), _Mypair._Myval2, ::std:: forward_as_tuple(::std:: forward<_Unbound>(_Unbargs)...));
    }


};

template <class _Fx, class... _Types>
[[nodiscard]] constexpr _Binder<_Unforced, _Fx, _Types...> bind(_Fx&& _Func, _Types&&... _Args) {
    return _Binder<_Unforced, _Fx, _Types...>(::std:: forward<_Fx>(_Func), ::std:: forward<_Types>(_Args)...);
}

template <class _Ret, class _Fx, class... _Types>
[[nodiscard]] constexpr _Binder<_Ret, _Fx, _Types...> bind(_Fx&& _Func, _Types&&... _Args) {
    return _Binder<_Ret, _Fx, _Types...>(::std:: forward<_Fx>(_Func), ::std:: forward<_Types>(_Args)...);
}

namespace placeholders {
    inline constexpr _Ph<1> _1{};
    inline constexpr _Ph<2> _2{};
    inline constexpr _Ph<3> _3{};
    inline constexpr _Ph<4> _4{};
    inline constexpr _Ph<5> _5{};
    inline constexpr _Ph<6> _6{};
    inline constexpr _Ph<7> _7{};
    inline constexpr _Ph<8> _8{};
    inline constexpr _Ph<9> _9{};
    inline constexpr _Ph<10> _10{};
    inline constexpr _Ph<11> _11{};
    inline constexpr _Ph<12> _12{};
    inline constexpr _Ph<13> _13{};
    inline constexpr _Ph<14> _14{};
    inline constexpr _Ph<15> _15{};
    inline constexpr _Ph<16> _16{};
    inline constexpr _Ph<17> _17{};
    inline constexpr _Ph<18> _18{};
    inline constexpr _Ph<19> _19{};
    inline constexpr _Ph<20> _20{};
} 


template <size_t... _Ix, class _Cv_FD, class _Cv_tuple_TiD, class... _Unbound>
constexpr auto _Call_front_binder(index_sequence<_Ix...>, _Cv_FD&& _Obj, _Cv_tuple_TiD&& _Tpl,
    _Unbound&&... _Unbargs) noexcept(noexcept(::std:: invoke(::std:: forward<_Cv_FD>(_Obj),
    ::std:: get<_Ix>(::std:: forward<_Cv_tuple_TiD>(_Tpl))..., ::std:: forward<_Unbound>(_Unbargs)...)))
    -> decltype(::std:: invoke(::std:: forward<_Cv_FD>(_Obj), ::std:: get<_Ix>(::std:: forward<_Cv_tuple_TiD>(_Tpl))...,
        ::std:: forward<_Unbound>(_Unbargs)...)) {
    return ::std:: invoke(::std:: forward<_Cv_FD>(_Obj), ::std:: get<_Ix>(::std:: forward<_Cv_tuple_TiD>(_Tpl))...,
        ::std:: forward<_Unbound>(_Unbargs)...);
}

template <class _Fx, class... _Types>
class _Front_binder { 
private:
    using _Seq = index_sequence_for<_Types...>;

    _Compressed_pair<_Fx, tuple<_Types...>> _Mypair;

    ;
    ;

public:
    template <class _FxInit, class... _TypesInit,
        enable_if_t<sizeof...(_TypesInit) != 0 || !is_same_v<remove_cvref_t<_FxInit>, _Front_binder>, int> = 0>
    constexpr explicit _Front_binder(_FxInit&& _Func, _TypesInit&&... _Args)
        : _Mypair(_One_then_variadic_args_t{}, ::std:: forward<_FxInit>(_Func), ::std:: forward<_TypesInit>(_Args)...) {}

    template <class... _Unbound>
    constexpr auto operator()(_Unbound&&... _Unbargs) & noexcept(noexcept(
        _Call_front_binder(_Seq{}, _Mypair._Get_first(), _Mypair._Myval2, ::std:: forward<_Unbound>(_Unbargs)...)))
        -> decltype(_Call_front_binder(
            _Seq{}, _Mypair._Get_first(), _Mypair._Myval2, ::std:: forward<_Unbound>(_Unbargs)...)) {
        return _Call_front_binder(_Seq{}, _Mypair._Get_first(), _Mypair._Myval2, ::std:: forward<_Unbound>(_Unbargs)...);
    }

    template <class... _Unbound>
    constexpr auto operator()(_Unbound&&... _Unbargs) const& noexcept(noexcept(
        _Call_front_binder(_Seq{}, _Mypair._Get_first(), _Mypair._Myval2, ::std:: forward<_Unbound>(_Unbargs)...)))
        -> decltype(_Call_front_binder(
            _Seq{}, _Mypair._Get_first(), _Mypair._Myval2, ::std:: forward<_Unbound>(_Unbargs)...)) {
        return _Call_front_binder(_Seq{}, _Mypair._Get_first(), _Mypair._Myval2, ::std:: forward<_Unbound>(_Unbargs)...);
    }

    template <class... _Unbound>
    constexpr auto operator()(_Unbound&&... _Unbargs) && noexcept(noexcept(_Call_front_binder(
        _Seq{}, ::std:: move(_Mypair._Get_first()), ::std:: move(_Mypair._Myval2), ::std:: forward<_Unbound>(_Unbargs)...)))
        -> decltype(_Call_front_binder(
            _Seq{}, ::std:: move(_Mypair._Get_first()), ::std:: move(_Mypair._Myval2), ::std:: forward<_Unbound>(_Unbargs)...)) {
        return _Call_front_binder(
            _Seq{}, ::std:: move(_Mypair._Get_first()), ::std:: move(_Mypair._Myval2), ::std:: forward<_Unbound>(_Unbargs)...);
    }

    template <class... _Unbound>
    constexpr auto operator()(_Unbound&&... _Unbargs) const&& noexcept(noexcept(_Call_front_binder(
        _Seq{}, ::std:: move(_Mypair._Get_first()), ::std:: move(_Mypair._Myval2), ::std:: forward<_Unbound>(_Unbargs)...)))
        -> decltype(_Call_front_binder(
            _Seq{}, ::std:: move(_Mypair._Get_first()), ::std:: move(_Mypair._Myval2), ::std:: forward<_Unbound>(_Unbargs)...)) {
        return _Call_front_binder(
            _Seq{}, ::std:: move(_Mypair._Get_first()), ::std:: move(_Mypair._Myval2), ::std:: forward<_Unbound>(_Unbargs)...);
    }
};

template <class _Fx, class... _Types>
[[nodiscard]] constexpr auto bind_front(_Fx&& _Func, _Types&&... _Args) {
    static_assert(is_constructible_v<decay_t<_Fx>, _Fx>,
        "std::bind_front requires the decayed callable to be constructible from an undecayed callable");
    static_assert(is_move_constructible_v<decay_t<_Fx>>,
        "std::bind_front requires the decayed callable to be move constructible");
    static_assert(conjunction_v<is_constructible<decay_t<_Types>, _Types>...>,
        "std::bind_front requires the decayed bound arguments to be constructible from undecayed bound arguments");
    static_assert(conjunction_v<is_move_constructible<decay_t<_Types>>...>,
        "std::bind_front requires the decayed bound arguments to be move constructible");

    return _Front_binder<decay_t<_Fx>, decay_t<_Types>...>(::std:: forward<_Fx>(_Func), ::std:: forward<_Types>(_Args)...);
}
#line 2119 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"


#line 2124 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"


inline void _Add_alloc_size(size_t& _Size, const size_t _Size_added, const size_t _Alignment) {
    
    
    const size_t _Align_masked = _Size & (_Alignment - 1u);
    _Size += _Size_added;
    if (_Align_masked != 0) {
        _Size += _Alignment - _Align_masked;
    }
}

template <class _Ty>
void _Add_alloc_size(size_t& _Size) { 
    _Add_alloc_size(_Size, sizeof(_Ty), alignof(_Ty));
}

template <class _Ty>
void _Add_alloc_size(size_t& _Size, const size_t _Count) {
    
    _Add_alloc_size(_Size, _Get_size_of_n<sizeof(_Ty)>(_Count), alignof(_Ty));
}

inline void* _Decode_aligned_block(void*& _Base, size_t _Size, const size_t _Alignment) {
    
    
    auto _Space  = static_cast<size_t>(-1);
    auto _Result = ::std:: align(_Alignment, _Size, _Base, _Space);
    _Base        = static_cast<char*>(_Base) + _Size;
    return _Result;
}

template <class _Ty>
_Ty* _Decode_aligned_block(void*& _Base) { 
    return static_cast<_Ty*>(_Decode_aligned_block(_Base, sizeof(_Ty), alignof(_Ty)));
}

template <class _Ty>
_Ty* _Decode_aligned_block(void*& _Base, const size_t _Count) {
    
    return static_cast<_Ty*>(_Decode_aligned_block(_Base, sizeof(_Ty) * _Count, alignof(_Ty)));
}

struct _Global_delete {
    void operator()(void* const _Ptr) const {
        ::operator delete(_Ptr);
    }
};

template <class _FwdItHaystack, class _FwdItPat, class _Pred_eq>
constexpr pair<_FwdItHaystack, _FwdItHaystack> _Search_pair_unchecked(_FwdItHaystack _First1, _FwdItHaystack _Last1,
    _FwdItPat _First2, _FwdItPat _Last2, _Pred_eq& _Eq, forward_iterator_tag, forward_iterator_tag) {
    
    for (;; ++_First1) { 
        _FwdItHaystack _Mid1 = _First1;
        for (_FwdItPat _Mid2 = _First2;; ++_Mid1, (void) ++_Mid2) {
            if (_Mid2 == _Last2) {
                return {_First1, _Mid1};
            }

            if (_Mid1 == _Last1) {
                return {_Last1, _Last1};
            }

            if (!_Eq(*_Mid1, *_Mid2)) {
                break;
            }
        }
    }
}

template <class _FwdItHaystack, class _FwdItPat, class _Pred_eq>
constexpr pair<_FwdItHaystack, _FwdItHaystack> _Search_pair_unchecked(_FwdItHaystack _First1, _FwdItHaystack _Last1,
    _FwdItPat _First2, _FwdItPat _Last2, _Pred_eq& _Eq, random_access_iterator_tag, random_access_iterator_tag) {
    
    _Iter_diff_t<_FwdItHaystack> _Count1 = _Last1 - _First1;
    _Iter_diff_t<_FwdItPat> _Count2      = _Last2 - _First2;

    for (; _Count2 <= _Count1; ++_First1, (void) --_Count1) { 
        _FwdItHaystack _Mid1 = _First1;
        for (_FwdItPat _Mid2 = _First2;; ++_Mid1, (void) ++_Mid2) {
            if (_Mid2 == _Last2) {
                return {_First1, _Mid1};
            }

            if (!_Eq(*_Mid1, *_Mid2)) {
                break;
            }
        }
    }

    return {_Last1, _Last1};
}

template <class _FwdItPat, class _Pred_eq = equal_to<>>
class default_searcher { 
public:
    constexpr default_searcher(_FwdItPat _First, _FwdItPat _Last, _Pred_eq _Eq = _Pred_eq())
        : _Data{_One_then_variadic_args_t{}, ::std:: move(_Eq), pair<_FwdItPat, _FwdItPat>{_First, _Last}} {
        const auto& _Pat = _Data._Myval2;
        _Adl_verify_range(_Pat.first, _Pat.second);
    }

    template <class _FwdItHaystack>
    [[nodiscard]] constexpr pair<_FwdItHaystack, _FwdItHaystack> operator()(
        _FwdItHaystack _First, _FwdItHaystack _Last) const {
        
        _Adl_verify_range(_First, _Last);
        const auto& _Eq  = _Data._Get_first();
        const auto& _Pat = _Data._Myval2;
        _Adl_verify_range(_Pat.first, _Pat.second); 
        const auto _Result =
            _Search_pair_unchecked(_Get_unwrapped(_First), _Get_unwrapped(_Last), _Get_unwrapped(_Pat.first),
                _Get_unwrapped(_Pat.second), _Eq, _Iter_cat_t<_FwdItHaystack>{}, _Iter_cat_t<_FwdItPat>{});
        _Seek_wrapped(_Last, _Result.second);
        _Seek_wrapped(_First, _Result.first);
        return {_First, _Last};
    }

private:
    _Compressed_pair<_Pred_eq, pair<_FwdItPat, _FwdItPat>> _Data;
};


template <class _RanItPat, class _Hash_ty, class _Pred_eq>
struct _Boyer_moore_hash_delta_1_table { 
    using _Value_t = _Iter_value_t<_RanItPat>;
    using _Diff    = _Iter_diff_t<_RanItPat>;

    _Boyer_moore_hash_delta_1_table(_RanItPat _Pat_first_arg, _Unwrapped_t<const _RanItPat&> _UPat_first,
        const _Diff _Pat_size_arg, _Hash_ty&& _Hash_fn, _Pred_eq&& _Eq)
        : _Pat_first(_Pat_first_arg), _Pat_size(_Pat_size_arg),
          _Map(0, ::std:: move(_Hash_fn), ::std:: move(_Eq)) { 
        for (_Diff _Idx = 1; _Idx <= _Pat_size; ++_Idx, (void) ++_UPat_first) {
            _Map.insert_or_assign(*_UPat_first, _Pat_size - _Idx);
        }
    }

    _Diff _Lookup(const _Value_t& _Value) const {
        
        const auto _Iter = _Map.find(_Value);
        if (_Iter == _Map.end()) {
            return _Pat_size;
        }

        return _Iter->second;
    }

    _Pred_eq _Get_eq() const {
        return _Map.key_eq();
    }

    const _RanItPat _Pat_first;
    const _Diff _Pat_size;

private:
    unordered_map<_Value_t, _Diff, _Hash_ty, _Pred_eq> _Map;
};


template <class _RanItPat, _Iter_diff_t<_RanItPat> _Limit>
struct _Boyer_moore_flat_delta_1_table { 
    using _Value_t = _Iter_value_t<_RanItPat>;
    using _Diff    = _Iter_diff_t<_RanItPat>;

    _Boyer_moore_flat_delta_1_table(_RanItPat _Pat_first_arg, _Unwrapped_t<const _RanItPat&> _UPat_first,
        const _Diff _Pat_size_arg, _Unused_parameter, _Unused_parameter)
        : _Pat_first(_Pat_first_arg), _Pat_size(_Pat_size_arg) { 
        ::std:: fill(::std:: begin(_Table), ::std:: end(_Table), _Pat_size);
        for (_Diff _Idx = 1; _Idx <= _Pat_size; ++_Idx, (void) ++_UPat_first) {
            _Table[_Unsigned_value(*_UPat_first)] = _Pat_size - _Idx;
        }
    }

    _Diff _Lookup(const _Value_t _Value) const { 
        const auto _UValue = _Unsigned_value(_Value);
        if (_UValue < ::std:: size(_Table)) {
            return _Table[_UValue];
        }

        return _Pat_size;
    }

    equal_to<> _Get_eq() const {
        return {};
    }

    const _RanItPat _Pat_first;
    const _Diff _Pat_size;

private:
    _Diff _Table[_Limit];
};


template <class _RanItPat, class _Pred_eq>
void _Build_boyer_moore_delta_2_table(_Iter_diff_t<_RanItPat>* const _Shifts, const _RanItPat _Pat_first,
    const _Iter_diff_t<_RanItPat> _Pat_size, _Pred_eq& _Eq) {
    
    
    using _Diff = _Iter_diff_t<_RanItPat>;

    if (_Pat_size == 0) {
        return;
    }

    if ((numeric_limits<_Diff>::max)() - _Pat_size < _Pat_size) {
        _Xlength_error("Boyer-Moore pattern is too long");
    }

    const auto _Mx = static_cast<size_t>(_Pat_size);

    const unique_ptr<size_t[]> _Fx{new size_t[_Mx]};

    for (size_t _Kx = 1; _Kx <= _Mx; ++_Kx) {
        _Shifts[_Kx - 1] = static_cast<_Diff>(2 * _Mx - _Kx);
    }

    size_t _Tx = _Mx + 1;
    for (size_t _Jx = _Mx; _Jx > 0; --_Jx, --_Tx) {
        _Fx[_Jx - 1] = _Tx;
        while (_Tx <= _Mx && !_Eq(_Pat_first[_Jx - 1], _Pat_first[_Tx - 1])) {
            _Shifts[_Tx - 1] = (::std:: min)(_Shifts[_Tx - 1], static_cast<_Diff>(_Mx - _Jx));
            _Tx              = _Fx[_Tx - 1];
        }
    }

    
    size_t _Qx = _Tx;
    _Tx        = _Mx + 1 - _Qx;
    for (size_t _Jx = 1, _Tx1 = 0; _Jx <= _Tx; ++_Tx1, ++_Jx) {
        _Fx[_Jx - 1] = _Tx1;
        while (_Tx1 >= 1 && !_Eq(_Pat_first[_Jx - 1], _Pat_first[_Tx1 - 1])) {
            _Tx1 = _Fx[_Tx1 - 1];
        }
    }

    size_t _Qx1 = 1;
    while (_Qx < _Mx) {
        for (size_t _Kx = _Qx1; _Kx <= _Qx; ++_Kx) {
            _Shifts[_Kx - 1] = (::std:: min)(_Shifts[_Kx - 1], static_cast<_Diff>(_Mx + _Qx - _Kx));
        }
        _Qx1 = _Qx + 1;

        const size_t _Temp = _Fx[_Tx - 1];

        _Qx = _Qx + _Tx - _Temp;
        _Tx = _Temp;
    }
}


template <class _Delta1_t, class _RanItHaystack>
pair<_RanItHaystack, _RanItHaystack> _Boyer_moore_search(
    const _Delta1_t& _Delta1, typename _Delta1_t::_Diff* _Delta2, _RanItHaystack _First, _RanItHaystack _Last) {
    static_assert(is_same_v<typename _Delta1_t::_Value_t, _Iter_value_t<_RanItHaystack>>,
        "boyer_moore_searcher requires matching iterator value types");
    using _Diff = typename _Delta1_t::_Diff;
    _Adl_verify_range(_First, _Last);
    auto _UFirst         = _Get_unwrapped(_First);
    const auto _ULast    = _Get_unwrapped(_Last);
    const auto _Pat_size = _Delta1._Pat_size;
    if (_Pat_size == 0) {
        return {_First, _First};
    }

    const auto _UPat_first = _Get_unwrapped_n(_Delta1._Pat_first, _Pat_size);
    const auto _Eq         = _Delta1._Get_eq();
    _Diff _Shift           = _Pat_size - 1;
    while (_Shift < _ULast - _UFirst) {
        _UFirst += _Shift;
        _Shift = _Delta1._Lookup(*_UFirst);
        if (_Shift == 0) { 
            _Diff _Idx = _Pat_size - 1;
            do {
                if (_Idx == 0) {
                    _Seek_wrapped(_Last, _UFirst + _Pat_size);
                    _Seek_wrapped(_First, _UFirst);
                    return {_First, _Last};
                }

                --_Idx;
                --_UFirst;
            } while (_Eq(*_UFirst, _UPat_first[_Idx]));
            _Shift = (::std:: max)(_Delta1._Lookup(*_UFirst), _Delta2[_Idx]);
        }
    }

    _Seek_wrapped(_Last, _ULast);
    _Seek_wrapped(_First, _ULast);
    return {_First, _Last};
}


template <class _Delta1_t, class _RanItHaystack>
pair<_RanItHaystack, _RanItHaystack> _Boyer_moore_horspool_search(
    const _Delta1_t& _Delta1, _RanItHaystack _First, _RanItHaystack _Last) {
    static_assert(is_same_v<typename _Delta1_t::_Value_t, _Iter_value_t<_RanItHaystack>>,
        "boyer_moore_horspool_searcher requires matching iterator value types");
    using _Diff = typename _Delta1_t::_Diff;
    _Adl_verify_range(_First, _Last);
    const auto _Pat_size = _Delta1._Pat_size;
    if (_Pat_size == 0) {
        return {_First, _First};
    }

    auto _UFirst           = _Get_unwrapped(_First);
    const auto _ULast      = _Get_unwrapped(_Last);
    const auto _UPat_first = _Get_unwrapped_n(_Delta1._Pat_first, _Pat_size);
    const auto _Eq         = _Delta1._Get_eq();
    _Diff _Shift           = _Pat_size - 1;
    while (_Shift < _ULast - _UFirst) {
        _UFirst += _Shift;
        _Shift = _Delta1._Lookup(*_UFirst);
        if (_Shift == 0) { 
            const auto _Candidate = _UFirst - (_Pat_size - 1);
            if (::std:: equal(_UPat_first, _UPat_first + (_Pat_size - 1), _Candidate, _Pass_fn(_Eq))) {
                _Seek_wrapped(_Last, _Candidate + _Pat_size);
                _Seek_wrapped(_First, _Candidate);
                return {_First, _Last};
            }

            _Shift = 1;
        }
    }

    _Seek_wrapped(_Last, _ULast);
    _Seek_wrapped(_First, _ULast);
    return {_First, _Last};
}


template <class _RanItPat, class _Hash_ty, class _Pred_eq, class _Delta1_t>
struct _Single_delta1_type_boyer_moore_traits {
    using _Diff = _Iter_diff_t<_RanItPat>;

    
    template <bool _Build_delta2>
    static void* _Build_boyer_moore(_RanItPat _First, _RanItPat _Last, _Hash_ty _Hash_fn, _Pred_eq _Eq) {
        
        _Adl_verify_range(_First, _Last);
        const auto _UFirst       = _Get_unwrapped(_First);
        const auto _Pat_size_raw = _Get_unwrapped(_Last) - _UFirst;
        using _CT                = common_type_t<_Iter_diff_t<_RanItPat>, size_t>;
        if (static_cast<_CT>(_Pat_size_raw) > static_cast<_CT>(0xffffffffui32)) {
            _Xbad_alloc();
        }

        const auto _Pat_size = static_cast<size_t>(_Pat_size_raw);
        size_t _Buf_size     = 0;
        _Add_alloc_size<_Atomic_counter_t>(_Buf_size);
        _Add_alloc_size<_Delta1_t>(_Buf_size);
        if (_Build_delta2) {
            _Add_alloc_size<_Diff>(_Buf_size, _Pat_size);
        }

        unique_ptr<void, _Global_delete> _Buf_bytes(::operator new(_Buf_size));
        void* _Buf                                      = _Buf_bytes.get();
        *_Decode_aligned_block<_Atomic_counter_t>(_Buf) = 1;
        void* const _Delta1                             = _Decode_aligned_block<_Delta1_t>(_Buf);
        if (_Build_delta2) {
            _Build_boyer_moore_delta_2_table(
                _Decode_aligned_block<_Diff>(_Buf, _Pat_size), _UFirst, _Pat_size_raw, _Eq);
        }

        ::new (_Delta1) _Delta1_t(_First, _UFirst, _Pat_size_raw, ::std:: move(_Hash_fn), ::std:: move(_Eq));
        return _Buf_bytes.release();
    }

    template <class _RanItHaystack>
    static pair<_RanItHaystack, _RanItHaystack> _Use_boyer_moore(
        void* _Data, _RanItHaystack _First, _RanItHaystack _Last) {
        
        (void) _Decode_aligned_block<_Atomic_counter_t>(_Data);
        const auto _Delta1 = _Decode_aligned_block<_Delta1_t>(_Data);
        const auto _Delta2 = _Decode_aligned_block<_Diff>(_Data, static_cast<size_t>(_Delta1->_Pat_size));
        return _Boyer_moore_search(*_Delta1, _Delta2, _First, _Last);
    }

    template <class _RanItHaystack>
    static pair<_RanItHaystack, _RanItHaystack> _Use_boyer_moore_horspool(
        void* _Data, _RanItHaystack _First, _RanItHaystack _Last) {
        
        (void) _Decode_aligned_block<_Atomic_counter_t>(_Data);
        const auto _Delta1 = _Decode_aligned_block<_Delta1_t>(_Data);
        return _Boyer_moore_horspool_search(*_Delta1, _First, _Last);
    }

    static void _Destroy(void* const _Base) noexcept {
        
        void* _Data = _Base;
        (void) _Decode_aligned_block<_Atomic_counter_t>(_Data);
        _Decode_aligned_block<_Delta1_t>(_Data)->~_Delta1_t();
        ::operator delete(_Base);
    }
};

template <class _RanItPat, class _Hash_ty, class _Pred_eq>
using _Boyer_moore_traits_char_mode = _Single_delta1_type_boyer_moore_traits<_RanItPat, _Hash_ty, _Pred_eq,
    _Boyer_moore_flat_delta_1_table<_RanItPat, 256>>;

template <class _RanItPat>
struct _Boyer_moore_traits_wchar_t_mode {
    using _Value_t       = _Iter_value_t<_RanItPat>;
    using _Diff          = _Iter_diff_t<_RanItPat>;
    using _Big_table_t   = _Boyer_moore_flat_delta_1_table<_RanItPat, 65536>;
    using _Small_table_t = _Boyer_moore_flat_delta_1_table<_RanItPat, 256>;

    
    template <bool _Build_delta2>
    static void* _Build_boyer_moore(_RanItPat _First, _RanItPat _Last, _Unused_parameter, _Unused_parameter) {
        
        _Adl_verify_range(_First, _Last);
        const auto _UFirst       = _Get_unwrapped(_First);
        const auto _ULast        = _Get_unwrapped(_Last);
        const auto _Pat_size_raw = _ULast - _UFirst;
        using _CT                = common_type_t<_Iter_diff_t<_RanItPat>, size_t>;
        if (static_cast<_CT>(_Pat_size_raw) > static_cast<_CT>(0xffffffffui32)) {
            _Xbad_alloc();
        }

        const auto _Pat_size = static_cast<size_t>(_Pat_size_raw);
        size_t _Buf_size     = 0;
        _Add_alloc_size<_Atomic_counter_t>(_Buf_size);
        bool _Use_large_table = false;

        for (auto _Temp = _UFirst; _Temp != _ULast; ++_Temp) {
            if (_Unsigned_value(*_Temp) > 255) {
                _Use_large_table = true;
                break;
            }
        }

        _Add_alloc_size<bool>(_Buf_size);
        if (_Use_large_table) {
            _Add_alloc_size<_Big_table_t>(_Buf_size);
        } else {
            _Add_alloc_size<_Small_table_t>(_Buf_size);
        }

        if (_Build_delta2) {
            _Add_alloc_size<_Diff>(_Buf_size, _Pat_size);
        }

        unique_ptr<void, _Global_delete> _Buf_bytes(::operator new(_Buf_size));
        void* _Buf                                      = _Buf_bytes.get();
        *_Decode_aligned_block<_Atomic_counter_t>(_Buf) = 1;
        *_Decode_aligned_block<bool>(_Buf)              = _Use_large_table;
        if (_Use_large_table) {
            using _Delta1_t = _Big_table_t;
            ::new (static_cast<void*>(_Decode_aligned_block<_Delta1_t>(_Buf)))
                _Delta1_t(_First, _UFirst, _Pat_size_raw, {}, {});
        } else {
            using _Delta1_t = _Small_table_t;
            ::new (static_cast<void*>(_Decode_aligned_block<_Delta1_t>(_Buf)))
                _Delta1_t(_First, _UFirst, _Pat_size_raw, {}, {});
        }

        if (_Build_delta2) {
            equal_to<> _Eq;
            _Build_boyer_moore_delta_2_table(
                _Decode_aligned_block<_Diff>(_Buf, _Pat_size), _UFirst, _Pat_size_raw, _Eq);
        }

        return _Buf_bytes.release();
    }

    template <class _RanItHaystack>
    static pair<_RanItHaystack, _RanItHaystack> _Use_boyer_moore(
        void* _Data, _RanItHaystack _First, _RanItHaystack _Last) {
        
        (void) _Decode_aligned_block<_Atomic_counter_t>(_Data);
        if (*_Decode_aligned_block<bool>(_Data)) {
            const auto _Delta1 = _Decode_aligned_block<_Big_table_t>(_Data);
            const auto _Delta2 = _Decode_aligned_block<_Diff>(_Data, static_cast<size_t>(_Delta1->_Pat_size));
            return _Boyer_moore_search(*_Delta1, _Delta2, _First, _Last);
        } else {
            const auto _Delta1 = _Decode_aligned_block<_Small_table_t>(_Data);
            const auto _Delta2 = _Decode_aligned_block<_Diff>(_Data, static_cast<size_t>(_Delta1->_Pat_size));
            return _Boyer_moore_search(*_Delta1, _Delta2, _First, _Last);
        }
    }

    template <class _RanItHaystack>
    static pair<_RanItHaystack, _RanItHaystack> _Use_boyer_moore_horspool(
        void* _Data, _RanItHaystack _First, _RanItHaystack _Last) {
        
        (void) _Decode_aligned_block<_Atomic_counter_t>(_Data);
        if (*_Decode_aligned_block<bool>(_Data)) {
            const auto _Delta1 = _Decode_aligned_block<_Big_table_t>(_Data);
            return _Boyer_moore_horspool_search(*_Delta1, _First, _Last);
        } else {
            const auto _Delta1 = _Decode_aligned_block<_Small_table_t>(_Data);
            return _Boyer_moore_horspool_search(*_Delta1, _First, _Last);
        }
    }

    static void _Destroy(void* const _Base) noexcept {
        
        void* _Data = _Base;
        (void) _Decode_aligned_block<_Atomic_counter_t>(_Data);
        if (*_Decode_aligned_block<bool>(_Data)) {
            const auto _Delta1 = _Decode_aligned_block<_Big_table_t>(_Data);
            _Delta1->~_Big_table_t();
        } else {
            const auto _Delta1 = _Decode_aligned_block<_Small_table_t>(_Data);
            _Delta1->~_Small_table_t();
        }
        static_assert(is_trivially_destructible_v<_Diff>, "allows Boyer-Moore and Boyer-Moore-Horspool to "
                                                          "share cleanup functions");
        ::operator delete(_Base);
    }
};

template <class _RanItPat, class _Hash_ty, class _Pred_eq>
using _Boyer_moore_traits_general_mode = _Single_delta1_type_boyer_moore_traits<_RanItPat, _Hash_ty, _Pred_eq,
    _Boyer_moore_hash_delta_1_table<_RanItPat, _Hash_ty, _Pred_eq>>;

template <class _RanItPat, class _Hash_ty, class _Pred_eq, class _Value_t = _Iter_value_t<_RanItPat>>
using _Boyer_moore_traits =
    conditional_t<is_integral_v<_Value_t> && sizeof(_Value_t) <= 2
                      && (is_same_v<equal_to<>, _Pred_eq> || is_same_v<equal_to<_Value_t>, _Pred_eq>),
        conditional_t<sizeof(_Value_t) == 1, _Boyer_moore_traits_char_mode<_RanItPat, _Hash_ty, _Pred_eq>,
            _Boyer_moore_traits_wchar_t_mode<_RanItPat>>,
        _Boyer_moore_traits_general_mode<_RanItPat, _Hash_ty, _Pred_eq>>;


template <class _RanItPat, class _Hash_ty = hash<_Iter_value_t<_RanItPat>>, class _Pred_eq = equal_to<>>
class boyer_moore_searcher {
public:
    boyer_moore_searcher(
        const _RanItPat _First, const _RanItPat _Last, _Hash_ty _Hash_fn = _Hash_ty(), _Pred_eq _Eq = _Pred_eq())
        : _Data(_Traits::template _Build_boyer_moore<true>(_First, _Last, ::std:: move(_Hash_fn), ::std:: move(_Eq))) {
        
    }

    boyer_moore_searcher(const boyer_moore_searcher& _Other) noexcept 
        : _Data(_Other._Data) {
        _InterlockedIncrement(reinterpret_cast<volatile long*>(&*static_cast<_Atomic_counter_t*>(_Data)));
    }

    ~boyer_moore_searcher() noexcept {
        if (_InterlockedDecrement(reinterpret_cast<volatile long*>(&*static_cast<_Atomic_counter_t*>(_Data))) == 0) {
            _Traits::_Destroy(_Data);
        }
    }

    boyer_moore_searcher& operator=(const boyer_moore_searcher& _Other) noexcept  {
        boyer_moore_searcher _Cpy(_Other);
        swap(_Data, _Cpy._Data);
        return *this;
    }

    template <class _RanItHaystack>
    [[nodiscard]] pair<_RanItHaystack, _RanItHaystack> operator()(
        const _RanItHaystack _First, const _RanItHaystack _Last) const {
        
        return _Traits::_Use_boyer_moore(_Data, _First, _Last);
    }

private:
    using _Traits = _Boyer_moore_traits<_RanItPat, _Hash_ty, _Pred_eq>;
    void* _Data;
};


template <class _RanItPat, class _Hash_ty = hash<_Iter_value_t<_RanItPat>>, class _Pred_eq = equal_to<>>
class boyer_moore_horspool_searcher { 
public:
    boyer_moore_horspool_searcher(
        const _RanItPat _First, const _RanItPat _Last, _Hash_ty _Hash_fn = _Hash_ty(), _Pred_eq _Eq = _Pred_eq())
        : _Data(_Traits::template _Build_boyer_moore<false>(_First, _Last, ::std:: move(_Hash_fn), ::std:: move(_Eq))) {
        
    }

    boyer_moore_horspool_searcher(const boyer_moore_horspool_searcher& _Other) noexcept 
        : _Data(_Other._Data) {
        _InterlockedIncrement(reinterpret_cast<volatile long*>(&*static_cast<_Atomic_counter_t*>(_Data)));
    }

    ~boyer_moore_horspool_searcher() noexcept {
        if (_InterlockedDecrement(reinterpret_cast<volatile long*>(&*static_cast<_Atomic_counter_t*>(_Data))) == 0) {
            _Traits::_Destroy(_Data);
        }
    }

    boyer_moore_horspool_searcher& operator=(const boyer_moore_horspool_searcher& _Other) noexcept  {
        boyer_moore_horspool_searcher _Cpy(_Other);
        swap(_Data, _Cpy._Data);
        return *this;
    }

    template <class _RanItHaystack>
    [[nodiscard]] pair<_RanItHaystack, _RanItHaystack> operator()(
        const _RanItHaystack _First, const _RanItHaystack _Last) const {
        
        return _Traits::_Use_boyer_moore_horspool(_Data, _First, _Last);
    }

private:
    using _Traits = _Boyer_moore_traits<_RanItPat, _Hash_ty, _Pred_eq>;
    void* _Data;
};
#line 2743 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"


namespace ranges {
    struct not_equal_to {
        
        template <class _Ty1, class _Ty2>
            requires equality_comparable_with<_Ty1, _Ty2>
        [[nodiscard]] constexpr bool operator()(_Ty1&& _Left, _Ty2&& _Right) const noexcept(noexcept(
            static_cast<bool>(static_cast<_Ty1&&>(_Left) == static_cast<_Ty2&&>(_Right))))  {
            return !static_cast<bool>(static_cast<_Ty1&&>(_Left) == static_cast<_Ty2&&>(_Right));
        }
        

        using is_transparent = int;
    };

    struct greater_equal {
        
        template <class _Ty1, class _Ty2>
            requires totally_ordered_with<_Ty1, _Ty2>
        [[nodiscard]] constexpr bool operator()(_Ty1&& _Left, _Ty2&& _Right) const noexcept(noexcept(
            static_cast<bool>(static_cast<_Ty1&&>(_Left) < static_cast<_Ty2&&>(_Right))))  {
            return !static_cast<bool>(static_cast<_Ty1&&>(_Left) < static_cast<_Ty2&&>(_Right));
        }
        

        using is_transparent = int;
    };

    struct less_equal {
        
        template <class _Ty1, class _Ty2>
            requires totally_ordered_with<_Ty1, _Ty2>
        [[nodiscard]] constexpr bool operator()(_Ty1&& _Left, _Ty2&& _Right) const noexcept(noexcept(
            static_cast<bool>(static_cast<_Ty2&&>(_Right) < static_cast<_Ty1&&>(_Left))))  {
            return !static_cast<bool>(static_cast<_Ty2&&>(_Right) < static_cast<_Ty1&&>(_Left));
        }
        

        using is_transparent = int;
    };
} 
#line 2786 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"


#line 2801 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"

}


#pragma warning(pop)
#pragma pack(pop)
#line 2809 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"
#line 2810 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\functional"
#line 23 "all-std.cxx"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\source_location"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
struct source_location {
    [[nodiscard]] static consteval source_location current(const uint_least32_t _Line_ = __builtin_LINE(),
        const uint_least32_t _Column_ = __builtin_COLUMN(), const char* const _File_ = __builtin_FILE(),
        const char* const _Function_ = __builtin_FUNCTION()) noexcept {
        source_location _Result;
        _Result._Line     = _Line_;
        _Result._Column   = _Column_;
        _Result._File     = _File_;
        _Result._Function = _Function_;
        return _Result;
    }

    [[nodiscard]] constexpr source_location() noexcept = default;

    [[nodiscard]] constexpr uint_least32_t line() const noexcept {
        return _Line;
    }
    [[nodiscard]] constexpr uint_least32_t column() const noexcept {
        return _Column;
    }
    [[nodiscard]] constexpr const char* file_name() const noexcept {
        return _File;
    }
    [[nodiscard]] constexpr const char* function_name() const noexcept {
        return _Function;
    }

private:
    uint_least32_t _Line{};
    uint_least32_t _Column{};
    const char* _File     = "";
    const char* _Function = "";
};
}


#pragma warning(pop)
#pragma pack(pop)
#line 65 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\source_location"
#line 66 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\source_location"
#line 67 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\source_location"
#line 26 "all-std.cxx"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\typeindex"


#pragma once


#line 16 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\typeindex"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
class type_index { 
public:
    type_index(const type_info& _Tinfo) noexcept : _Tptr(&_Tinfo) {}

    [[nodiscard]] size_t hash_code() const noexcept {
        return _Tptr->hash_code();
    }

    [[nodiscard]] const char* name() const noexcept {
        return _Tptr->name();
    }

    [[nodiscard]] bool operator==(const type_index& _Right) const noexcept {
        return *_Tptr == *_Right._Tptr;
    }


    [[nodiscard]] strong_ordering operator<=>(const type_index& _Right) const noexcept {
        return *_Tptr == *_Right._Tptr      ? strong_ordering::equal
             : _Tptr->before(*_Right._Tptr) ? strong_ordering::less
                                            : strong_ordering::greater;
    }


#line 52 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\typeindex"

    [[nodiscard]] bool operator<(const type_index& _Right) const noexcept {
        return _Tptr->before(*_Right._Tptr);
    }

    [[nodiscard]] bool operator>=(const type_index& _Right) const noexcept {
        return !(*this < _Right);
    }

    [[nodiscard]] bool operator>(const type_index& _Right) const noexcept {
        return _Right < *this;
    }

    [[nodiscard]] bool operator<=(const type_index& _Right) const noexcept {
        return !(_Right < *this);
    }

private:
    const type_info* _Tptr;
};

template <>
struct hash<type_index> {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef type_index _Unnameable_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef size_t _Unnameable_result;

    [[nodiscard]] size_t operator()(const type_index& _Keyval) const noexcept {
        return _Keyval.hash_code();
    }
};
}


#pragma warning(pop)
#pragma pack(pop)
#line 89 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\typeindex"
#line 90 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\typeindex"
#line 29 "all-std.cxx"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\variant"


#pragma once


#line 15 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\variant"


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {

template <class...>
struct _All_same : true_type {};
template <class _First, class... _Rest>
struct _All_same<_First, _Rest...> : bool_constant<conjunction_v<is_same<_First, _Rest>...>> {}; 

template <class _To, class... _From>
struct _Convertible_from_all : bool_constant<conjunction_v<is_convertible<_From, _To>...>> {
    
};

template <class...>
struct _Meta_list {}; 
struct _Meta_nil {};

template <class _List>
struct _Meta_front_;
template <class _List>
using _Meta_front =
    
    typename _Meta_front_<_List>::type;

template <template <class...> class _List, class _First, class... _Rest>
struct _Meta_front_<_List<_First, _Rest...>> {
    using type = _First;
};

template <class _List>
struct _Meta_pop_front_;
template <class _List>
using _Meta_pop_front =
    
    typename _Meta_pop_front_<_List>::type;

template <template <class...> class _List, class _First, class... _Rest>
struct _Meta_pop_front_<_List<_First, _Rest...>> {
    using type = _List<_Rest...>;
};

template <class _List, class _Ty>
struct _Meta_push_front_;
template <class _List, class _Ty>
using _Meta_push_front =
    
    typename _Meta_push_front_<_List, _Ty>::type;

template <template <class...> class _List, class... _Types, class _Ty>
struct _Meta_push_front_<_List<_Types...>, _Ty> {
    using type = _List<_Ty, _Types...>;
};

template <class _Void, template <class...> class _Fn, class... _Args>
struct _Meta_quote_helper_;
template <template <class...> class _Fn, class... _Args>
struct _Meta_quote_helper_<void_t<_Fn<_Args...>>, _Fn, _Args...> {
    using type = _Fn<_Args...>;
};
template <template <class...> class _Fn>
struct _Meta_quote { 
    template <class... _Types>
    using _Invoke = typename _Meta_quote_helper_<void, _Fn, _Types...>::type;
};

template <class _Fn, class... _Args>
using _Meta_invoke = 
    typename _Fn::template _Invoke<_Args...>;

template <class _Fn, class... _Args>
struct _Meta_bind_back { 
    template <class... _Types>
    using _Invoke = _Meta_invoke<_Fn, _Types..., _Args...>;
};

template <class _Fn, class _List>
struct _Meta_apply_;
template <class _Fn, class _List>
using _Meta_apply =
    
    typename _Meta_apply_<_Fn, _List>::type;

template <class _Fn, template <class...> class _List, class... _Types>
struct _Meta_apply_<_Fn,
    _List<_Types...>> { 
    using type = _Meta_invoke<_Fn, _Types...>;
};

template <class _Fn, class _Ty, _Ty... _Idxs>
struct _Meta_apply_<_Fn,
    integer_sequence<_Ty, _Idxs...>> { 
    using type = _Meta_invoke<_Fn, integral_constant<_Ty, _Idxs>...>;
};

template <class _Fn, class _List>
struct _Meta_transform_;
template <class _Fn, class _List>
using _Meta_transform =
    
    typename _Meta_transform_<_Fn, _List>::type;

template <template <class...> class _List, class _Fn, class... _Types>
struct _Meta_transform_<_Fn, _List<_Types...>> {
    using type = _List<_Meta_invoke<_Fn, _Types>...>;
};

template <class, class, template <class...> class>
struct _Meta_repeat_n_c_;
template <size_t _Count, class _Ty, template <class...> class _Continue>
using _Meta_repeat_n_c =
    
    typename _Meta_repeat_n_c_<_Ty, make_index_sequence<_Count>, _Continue>::type;

template <class _Ty, size_t>
using _Meta_repeat_first_helper = _Ty;

template <class _Ty, size_t... _Idxs, template <class...> class _Continue>
struct _Meta_repeat_n_c_<_Ty, index_sequence<_Idxs...>, _Continue> {
    using type = _Continue<_Meta_repeat_first_helper<_Ty, _Idxs>...>;
};

template <class _List, size_t _Idx, class = void>
struct _Meta_at_;
template <class _List, size_t _Idx>
using _Meta_at_c =
    
    typename _Meta_at_<_List, _Idx>::type;


template <class... _VoidPtrs>
struct _Meta_at_impl {
    template <class _Ty, class... _Types>
    static _Ty _Eval(_VoidPtrs..., _Ty*, _Types*...); 
};

template <class _Ty>
constexpr _Identity<_Ty>* _Type_as_pointer() {
    return nullptr;
}

template <template <class...> class _List, class... _Types, size_t _Idx>
struct _Meta_at_<_List<_Types...>, _Idx, enable_if_t<(_Idx < sizeof...(_Types))>> {
    using type =
        typename decltype(_Meta_repeat_n_c<_Idx, void*, _Meta_at_impl>::_Eval(_Type_as_pointer<_Types>()...))::type;
};
#line 180 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\variant"

inline constexpr auto _Meta_npos = ~size_t{0};

template <class _List, class _Ty>
struct _Meta_find_index_ {
    using type = integral_constant<size_t, _Meta_npos>;
};
template <class _List, class _Ty>
using _Meta_find_index =
    
    typename _Meta_find_index_<_List, _Ty>::type;

constexpr size_t _Meta_find_index_i_(const bool* const _Ptr, const size_t _Count,
    size_t _Idx = 0) { 
    for (; _Idx < _Count; ++_Idx) {
        if (_Ptr[_Idx]) {
            return _Idx;
        }
    }

    return _Meta_npos;
}

template <template <class...> class _List, class _First, class... _Rest, class _Ty>
struct _Meta_find_index_<_List<_First, _Rest...>, _Ty> {
    static constexpr bool _Bools[] = {is_same_v<_First, _Ty>, is_same_v<_Rest, _Ty>...};
    using type                     = integral_constant<size_t, _Meta_find_index_i_(_Bools, 1 + sizeof...(_Rest))>;
};

template <class _List, class _Ty>
struct _Meta_find_unique_index_ {
    using type = integral_constant<size_t, _Meta_npos>;
};
template <class _List, class _Ty>
using _Meta_find_unique_index =
    
    typename _Meta_find_unique_index_<_List, _Ty>::type;

constexpr size_t _Meta_find_unique_index_i_2(const bool* const _Ptr, const size_t _Count,
    const size_t
        _First) { 
    return _First != _Meta_npos && _Meta_find_index_i_(_Ptr, _Count, _First + 1) == _Meta_npos ? _First : _Meta_npos;
}

constexpr size_t _Meta_find_unique_index_i_(const bool* const _Ptr,
    const size_t _Count) { 
    return _Meta_find_unique_index_i_2(_Ptr, _Count, _Meta_find_index_i_(_Ptr, _Count));
}

template <template <class...> class _List, class _First, class... _Rest, class _Ty>
struct _Meta_find_unique_index_<_List<_First, _Rest...>, _Ty> {
    using type = integral_constant<size_t,
        _Meta_find_unique_index_i_(_Meta_find_index_<_List<_First, _Rest...>, _Ty>::_Bools, 1 + sizeof...(_Rest))>;
};

template <class>
struct _Meta_as_list_;
template <class _Ty>
using _Meta_as_list =
    
    typename _Meta_as_list_<_Ty>::type;

template <template <class...> class _List, class... _Types>
struct _Meta_as_list_<_List<_Types...>> { 
                                          
    using type = _Meta_list<_Types...>;
};

template <class _Ty, _Ty... _Idxs>
struct _Meta_as_list_<integer_sequence<_Ty, _Idxs...>> { 
                                                         
    using type = _Meta_list<integral_constant<_Ty, _Idxs>...>;
};

template <class _List>
struct _Meta_as_integer_sequence_;
template <class _List>
using _Meta_as_integer_sequence =
    
    typename _Meta_as_integer_sequence_<_List>::type;

template <template <class...> class _List, class _Ty, _Ty... _Idxs>
struct _Meta_as_integer_sequence_<_List<integral_constant<_Ty, _Idxs>...>> {
    using type = integer_sequence<_Ty, _Idxs...>;
};

template <class...>
struct _Meta_concat_;
template <class... _Types>
using _Meta_concat =
    
    typename _Meta_concat_<_Types...>::type;

template <template <class...> class _List>
struct _Meta_concat_<_List<>> {
    using type = _List<>;
};

template <template <class...> class _List, class... _Items1>
struct _Meta_concat_<_List<_Items1...>> {
    using type = _List<_Items1...>;
};

template <template <class...> class _List, class... _Items1, class... _Items2>
struct _Meta_concat_<_List<_Items1...>, _List<_Items2...>> {
    using type = _List<_Items1..., _Items2...>;
};

template <template <class...> class _List, class... _Items1, class... _Items2, class... _Items3>
struct _Meta_concat_<_List<_Items1...>, _List<_Items2...>, _List<_Items3...>> {
    using type = _List<_Items1..., _Items2..., _Items3...>;
};

template <template <class...> class _List, class... _Items1, class... _Items2, class... _Items3, class... _Rest>
struct _Meta_concat_<_List<_Items1...>, _List<_Items2...>, _List<_Items3...>, _Rest...> {
    using type = _Meta_concat<_List<_Items1..., _Items2..., _Items3...>, _Rest...>;
};

template <class _ListOfLists>
using _Meta_join =
    
    _Meta_apply<_Meta_quote<_Meta_concat>, _ListOfLists>;

template <class>
struct _Meta_cartesian_product_;
template <class _ListOfLists>
using _Meta_cartesian_product =
    
    typename _Meta_cartesian_product_<_ListOfLists>::type;

template <template <class...> class _List>
struct _Meta_cartesian_product_<_List<>> {
    using type = _List<>;
};

template <template <class...> class _List1, template <class...> class _List2, class... _Items>
struct _Meta_cartesian_product_<_List1<_List2<_Items...>>> {
    using type = _List1<_List2<_Items>...>;
};

template <template <class...> class _List1, class... _Items, template <class...> class _List2, class... _Lists>
struct _Meta_cartesian_product_<_List1<_List2<_Items...>, _Lists...>> {
    using type = _Meta_join<_List1<_Meta_transform<_Meta_bind_back<_Meta_quote<_Meta_push_front>, _Items>,
        _Meta_cartesian_product<_List1<_Lists...>>>...>>;
};


template <class... _Types>
class variant;

template <class _Ty>
struct variant_size; 
template <class _Ty>
struct variant_size<const _Ty> : variant_size<_Ty>::type {};
template <class _Ty>
struct [[deprecated("warning STL4030: " "Some operations on volatile-qualified types in the STL are deprecated in C++20. " "You can define _SILENCE_CXX20_VOLATILE_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] variant_size<volatile _Ty> : variant_size<_Ty>::type {};
template <class _Ty>
struct [[deprecated("warning STL4030: " "Some operations on volatile-qualified types in the STL are deprecated in C++20. " "You can define _SILENCE_CXX20_VOLATILE_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] variant_size<const volatile _Ty> : variant_size<_Ty>::type {};
template <class _Ty>
inline constexpr size_t variant_size_v = variant_size<_Ty>::value;

template <class... _Types>
struct variant_size<variant<_Types...>> : integral_constant<size_t, sizeof...(_Types)> {};

template <size_t _Idx, class _Ty>
struct variant_alternative; 
template <size_t _Idx, class _Ty>
using variant_alternative_t = typename variant_alternative<_Idx, _Ty>::type;
template <size_t _Idx, class _Ty>
struct variant_alternative<_Idx, const _Ty> {
    using type = add_const_t<variant_alternative_t<_Idx, _Ty>>;
};
template <size_t _Idx, class _Ty>
struct [[deprecated("warning STL4030: " "Some operations on volatile-qualified types in the STL are deprecated in C++20. " "You can define _SILENCE_CXX20_VOLATILE_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] variant_alternative<_Idx, volatile _Ty> {
    using type = add_volatile_t<variant_alternative_t<_Idx, _Ty>>;
};
template <size_t _Idx, class _Ty>
struct [[deprecated("warning STL4030: " "Some operations on volatile-qualified types in the STL are deprecated in C++20. " "You can define _SILENCE_CXX20_VOLATILE_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] variant_alternative<_Idx, const volatile _Ty> {
    using type = add_cv_t<variant_alternative_t<_Idx, _Ty>>;
};
template <size_t _Idx, class... _Types>
struct variant_alternative<_Idx, variant<_Types...>> {
    static_assert(_Idx < sizeof...(_Types), "variant index out of bounds");


    using type = _Meta_at_c<variant<_Types...>, _Idx>;
#line 391 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\variant"
};

inline constexpr size_t variant_npos = _Meta_npos;

class bad_variant_access
    : public exception { 
public:
    bad_variant_access() noexcept = default;

    [[nodiscard]] const char*  what() const noexcept override {
        return "bad variant access";
    }


#line 410 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\variant"
};

[[noreturn]] inline void _Throw_bad_variant_access() {
    throw bad_variant_access{};
}

template <bool _TrivialDestruction, class... _Types>
class _Variant_storage_ {}; 

template <class... _Types>
using _Variant_storage = _Variant_storage_<conjunction_v<is_trivially_destructible<_Types>...>, _Types...>;

template <class _First, class... _Rest>
class _Variant_storage_<true, _First, _Rest...> { 
public:
    static constexpr size_t _Size = 1 + sizeof...(_Rest);
    union {
        remove_const_t<_First> _Head;
        _Variant_storage<_Rest...> _Tail;
    };

    constexpr _Variant_storage_() noexcept {} 

    template <class... _Types>
    constexpr explicit _Variant_storage_(integral_constant<size_t, 0>, _Types&&... _Args) noexcept(
        is_nothrow_constructible_v<_First, _Types...>)
        : _Head(static_cast<_Types&&>(_Args)...) {} 

    template <size_t _Idx, class... _Types, enable_if_t<(_Idx > 0), int> = 0>
    constexpr explicit _Variant_storage_(integral_constant<size_t, _Idx>, _Types&&... _Args) noexcept(
        is_nothrow_constructible_v<_Variant_storage<_Rest...>, integral_constant<size_t, _Idx - 1>, _Types...>)
        : _Tail(integral_constant<size_t, _Idx - 1>{}, static_cast<_Types&&>(_Args)...) {} 

    [[nodiscard]] constexpr _First& _Get() & noexcept {
        return _Head;
    }
    [[nodiscard]] constexpr const _First& _Get() const& noexcept {
        return _Head;
    }
    [[nodiscard]] constexpr _First&& _Get() && noexcept {
        return ::std:: move(_Head);
    }
    [[nodiscard]] constexpr const _First&& _Get() const&& noexcept {
        return ::std:: move(_Head);
    }
};

template <class _First, class... _Rest>
class _Variant_storage_<false, _First, _Rest...> { 
public:
    static constexpr size_t _Size = 1 + sizeof...(_Rest);
    union {
        remove_const_t<_First> _Head;
        _Variant_storage<_Rest...> _Tail;
    };

    constexpr ~_Variant_storage_() noexcept {
        
        
    }

    constexpr _Variant_storage_() noexcept {} 

    template <class... _Types>
    constexpr explicit _Variant_storage_(integral_constant<size_t, 0>, _Types&&... _Args) noexcept(
        is_nothrow_constructible_v<_First, _Types...>)
        : _Head(static_cast<_Types&&>(_Args)...) {} 

    template <size_t _Idx, class... _Types, enable_if_t<(_Idx > 0), int> = 0>
    constexpr explicit _Variant_storage_(integral_constant<size_t, _Idx>, _Types&&... _Args) noexcept(
        is_nothrow_constructible_v<_Variant_storage<_Rest...>, integral_constant<size_t, _Idx - 1>, _Types...>)
        : _Tail(integral_constant<size_t, _Idx - 1>{}, static_cast<_Types&&>(_Args)...) {} 

    _Variant_storage_(_Variant_storage_&&)      = default;
    _Variant_storage_(const _Variant_storage_&) = default;
    _Variant_storage_& operator=(_Variant_storage_&&) = default;
    _Variant_storage_& operator=(const _Variant_storage_&) = default;

    [[nodiscard]] constexpr _First& _Get() & noexcept {
        return _Head;
    }
    [[nodiscard]] constexpr const _First& _Get() const& noexcept {
        return _Head;
    }
    [[nodiscard]] constexpr _First&& _Get() && noexcept {
        return ::std:: move(_Head);
    }
    [[nodiscard]] constexpr const _First&& _Get() const&& noexcept {
        return ::std:: move(_Head);
    }
};


template <size_t _Idx, class _Storage>
[[nodiscard]] constexpr decltype(auto) _Variant_raw_get(
    _Storage&& _Obj) noexcept { 
    if constexpr (_Idx == 0) {
        return static_cast<_Storage&&>(_Obj)._Get();
    } else if constexpr (_Idx == 1) {
        return static_cast<_Storage&&>(_Obj)._Tail._Get();
    } else if constexpr (_Idx == 2) {
        return static_cast<_Storage&&>(_Obj)._Tail._Tail._Get();
    } else if constexpr (_Idx == 3) {
        return static_cast<_Storage&&>(_Obj)._Tail._Tail._Tail._Get();
    } else if constexpr (_Idx == 4) {
        return static_cast<_Storage&&>(_Obj)._Tail._Tail._Tail._Tail._Get();
    } else if constexpr (_Idx == 5) {
        return static_cast<_Storage&&>(_Obj)._Tail._Tail._Tail._Tail._Tail._Get();
    } else if constexpr (_Idx == 6) {
        return static_cast<_Storage&&>(_Obj)._Tail._Tail._Tail._Tail._Tail._Tail._Get();
    } else if constexpr (_Idx == 7) {
        return static_cast<_Storage&&>(_Obj)._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Get();
    } else if constexpr (_Idx < 16) {
        return _Variant_raw_get<_Idx - 8>(
            static_cast<_Storage&&>(_Obj)._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail);
    } else if constexpr (_Idx < 32) {
        return _Variant_raw_get<_Idx - 16>(
            static_cast<_Storage&&>(_Obj)
                ._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail);
    } else if constexpr (_Idx < 64) {
        return _Variant_raw_get<_Idx - 32>(
            static_cast<_Storage&&>(_Obj)
                ._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail
                ._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail);
    } else { 
        return _Variant_raw_get<_Idx - 64>(
            static_cast<_Storage&&>(_Obj)
                ._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail
                ._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail
                ._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail
                ._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail);
    }
}

template <class _Ty, size_t _Tag>
struct _Tagged { 
    static constexpr size_t _Idx = _Tag;
    _Ty _Val;
};

template <class _Storage, size_t _Idx>
using _Variant_tagged_ref_t = _Tagged<decltype(_Variant_raw_get<_Idx>(::std:: declval<_Storage>()))&&, _Idx>;

template <class _Fn, class _Storage>
using _Variant_raw_visit_t = decltype(::std:: declval<_Fn>()(::std:: declval<_Variant_tagged_ref_t<_Storage, 0>>()));

template <size_t _Idx, class _Fn, class _Storage>
[[nodiscard]] constexpr _Variant_raw_visit_t<_Fn, _Storage> _Variant_raw_visit_dispatch(
    _Fn&& _Func, _Storage&& _Var) noexcept(is_nothrow_invocable_v<_Fn, _Variant_tagged_ref_t<_Storage, _Idx>>) {
    
    return static_cast<_Fn&&>(_Func)(
        _Variant_tagged_ref_t<_Storage, _Idx>{_Variant_raw_get<_Idx>(static_cast<_Storage&&>(_Var))});
}

template <class _Fn, class _Storage>
[[nodiscard]] constexpr _Variant_raw_visit_t<_Fn, _Storage> _Variant_raw_visit_valueless(
    _Fn&& _Func, _Storage&& _Obj) noexcept(is_nothrow_invocable_v<_Fn, _Tagged<_Storage&&, variant_npos>>) {
    
    return static_cast<_Fn&&>(_Func)(_Tagged<_Storage&&, variant_npos>{static_cast<_Storage&&>(_Obj)});
}

template <class _Fn, class _Storage, class _Indices = make_index_sequence<remove_reference_t<_Storage>::_Size>>
inline constexpr bool _Variant_raw_visit_noexcept = false;

template <class _Fn, class _Storage, size_t... _Idxs>
inline constexpr bool _Variant_raw_visit_noexcept<_Fn, _Storage, index_sequence<_Idxs...>> =
    conjunction_v<is_nothrow_invocable<_Fn, _Tagged<_Storage&&, variant_npos>>,
        is_nothrow_invocable<_Fn, _Variant_tagged_ref_t<_Storage, _Idxs>>...>;

template <class _Fn, class _Storage,
    class _Indices = make_index_sequence<remove_reference_t<_Storage>::_Size>>
struct _Variant_raw_dispatch_table1; 

template <class _Fn, class _Storage, size_t... _Idxs>
struct _Variant_raw_dispatch_table1<_Fn, _Storage,
    index_sequence<_Idxs...>> { 
    using _Dispatch_t = _Variant_raw_visit_t<_Fn, _Storage> (*)(_Fn&&, _Storage&&) noexcept(
        _Variant_raw_visit_noexcept<_Fn, _Storage>);
    static constexpr _Dispatch_t _Array[] = {
        &_Variant_raw_visit_valueless<_Fn, _Storage>, &_Variant_raw_visit_dispatch<_Idxs, _Fn, _Storage>...};
};

template <int _Strategy>
struct _Variant_raw_visit1;

template <>
struct _Variant_raw_visit1<-1> { 
    template <class _Fn, class _Storage>
    [[nodiscard]] static constexpr _Variant_raw_visit_t<_Fn, _Storage> _Visit(
        size_t _Idx, _Fn&& _Func, _Storage&& _Obj) noexcept(_Variant_raw_visit_noexcept<_Fn, _Storage>) {
        
        constexpr size_t _Size = remove_reference_t<_Storage>::_Size;
        static_assert(_Size > 256);
        constexpr auto& _Array = _Variant_raw_dispatch_table1<_Fn, _Storage>::_Array;
        return _Array[_Idx](static_cast<_Fn&&>(_Func), static_cast<_Storage&&>(_Obj));
    }
};


template <>
struct _Variant_raw_visit1<1> {
    template <class _Fn, class _Storage>
    [[nodiscard]] static constexpr _Variant_raw_visit_t<_Fn, _Storage> _Visit(
        size_t _Idx, _Fn&& _Func, _Storage&& _Obj) noexcept(_Variant_raw_visit_noexcept<_Fn, _Storage>) {
        
        constexpr size_t _Size = remove_reference_t<_Storage>::_Size; static_assert(((4) == 4 || _Size > (4) / 4) && _Size <= (4)); switch (_Idx) { case 0: return static_cast<_Fn&&>(_Func)(_Tagged<_Storage&&, variant_npos>{static_cast<_Storage&&>(_Obj)}); case (0) + 1: if constexpr ((0) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0)>{_Variant_raw_get<(0)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 1) + 1: if constexpr ((0 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 1)>{_Variant_raw_get<(0 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 2) + 1: if constexpr ((0 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 2)>{_Variant_raw_get<(0 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 3) + 1: if constexpr ((0 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 3)>{_Variant_raw_get<(0 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); default: __assume(false); };
    }
};

template <>
struct _Variant_raw_visit1<2> {
    template <class _Fn, class _Storage>
    [[nodiscard]] static constexpr _Variant_raw_visit_t<_Fn, _Storage> _Visit(
        size_t _Idx, _Fn&& _Func, _Storage&& _Obj) noexcept(_Variant_raw_visit_noexcept<_Fn, _Storage>) {
        
        constexpr size_t _Size = remove_reference_t<_Storage>::_Size; static_assert(((16) == 4 || _Size > (16) / 4) && _Size <= (16)); switch (_Idx) { case 0: return static_cast<_Fn&&>(_Func)(_Tagged<_Storage&&, variant_npos>{static_cast<_Storage&&>(_Obj)}); case (0) + 1: if constexpr ((0) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0)>{_Variant_raw_get<(0)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 1) + 1: if constexpr ((0 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 1)>{_Variant_raw_get<(0 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 2) + 1: if constexpr ((0 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 2)>{_Variant_raw_get<(0 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 3) + 1: if constexpr ((0 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 3)>{_Variant_raw_get<(0 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 4) + 1: if constexpr ((0 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 4)>{_Variant_raw_get<(0 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 4 + 1) + 1: if constexpr ((0 + 4 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 4 + 1)>{_Variant_raw_get<(0 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 4 + 2) + 1: if constexpr ((0 + 4 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 4 + 2)>{_Variant_raw_get<(0 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 4 + 3) + 1: if constexpr ((0 + 4 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 4 + 3)>{_Variant_raw_get<(0 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 8) + 1: if constexpr ((0 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 8)>{_Variant_raw_get<(0 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 8 + 1) + 1: if constexpr ((0 + 8 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 8 + 1)>{_Variant_raw_get<(0 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 8 + 2) + 1: if constexpr ((0 + 8 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 8 + 2)>{_Variant_raw_get<(0 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 8 + 3) + 1: if constexpr ((0 + 8 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 8 + 3)>{_Variant_raw_get<(0 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 12) + 1: if constexpr ((0 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 12)>{_Variant_raw_get<(0 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 12 + 1) + 1: if constexpr ((0 + 12 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 12 + 1)>{_Variant_raw_get<(0 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 12 + 2) + 1: if constexpr ((0 + 12 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 12 + 2)>{_Variant_raw_get<(0 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 12 + 3) + 1: if constexpr ((0 + 12 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 12 + 3)>{_Variant_raw_get<(0 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); default: __assume(false); };
    }
};

template <>
struct _Variant_raw_visit1<3> {
    template <class _Fn, class _Storage>
    [[nodiscard]] static constexpr _Variant_raw_visit_t<_Fn, _Storage> _Visit(
        size_t _Idx, _Fn&& _Func, _Storage&& _Obj) noexcept(_Variant_raw_visit_noexcept<_Fn, _Storage>) {
        
        constexpr size_t _Size = remove_reference_t<_Storage>::_Size; static_assert(((64) == 4 || _Size > (64) / 4) && _Size <= (64)); switch (_Idx) { case 0: return static_cast<_Fn&&>(_Func)(_Tagged<_Storage&&, variant_npos>{static_cast<_Storage&&>(_Obj)}); case (0) + 1: if constexpr ((0) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0)>{_Variant_raw_get<(0)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 1) + 1: if constexpr ((0 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 1)>{_Variant_raw_get<(0 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 2) + 1: if constexpr ((0 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 2)>{_Variant_raw_get<(0 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 3) + 1: if constexpr ((0 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 3)>{_Variant_raw_get<(0 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 4) + 1: if constexpr ((0 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 4)>{_Variant_raw_get<(0 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 4 + 1) + 1: if constexpr ((0 + 4 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 4 + 1)>{_Variant_raw_get<(0 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 4 + 2) + 1: if constexpr ((0 + 4 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 4 + 2)>{_Variant_raw_get<(0 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 4 + 3) + 1: if constexpr ((0 + 4 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 4 + 3)>{_Variant_raw_get<(0 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 8) + 1: if constexpr ((0 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 8)>{_Variant_raw_get<(0 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 8 + 1) + 1: if constexpr ((0 + 8 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 8 + 1)>{_Variant_raw_get<(0 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 8 + 2) + 1: if constexpr ((0 + 8 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 8 + 2)>{_Variant_raw_get<(0 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 8 + 3) + 1: if constexpr ((0 + 8 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 8 + 3)>{_Variant_raw_get<(0 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 12) + 1: if constexpr ((0 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 12)>{_Variant_raw_get<(0 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 12 + 1) + 1: if constexpr ((0 + 12 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 12 + 1)>{_Variant_raw_get<(0 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 12 + 2) + 1: if constexpr ((0 + 12 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 12 + 2)>{_Variant_raw_get<(0 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 12 + 3) + 1: if constexpr ((0 + 12 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 12 + 3)>{_Variant_raw_get<(0 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16) + 1: if constexpr ((0 + 16) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16)>{_Variant_raw_get<(0 + 16)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16 + 1) + 1: if constexpr ((0 + 16 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 1)>{_Variant_raw_get<(0 + 16 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16 + 2) + 1: if constexpr ((0 + 16 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 2)>{_Variant_raw_get<(0 + 16 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16 + 3) + 1: if constexpr ((0 + 16 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 3)>{_Variant_raw_get<(0 + 16 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16 + 4) + 1: if constexpr ((0 + 16 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 4)>{_Variant_raw_get<(0 + 16 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16 + 4 + 1) + 1: if constexpr ((0 + 16 + 4 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 4 + 1)>{_Variant_raw_get<(0 + 16 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16 + 4 + 2) + 1: if constexpr ((0 + 16 + 4 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 4 + 2)>{_Variant_raw_get<(0 + 16 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16 + 4 + 3) + 1: if constexpr ((0 + 16 + 4 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 4 + 3)>{_Variant_raw_get<(0 + 16 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16 + 8) + 1: if constexpr ((0 + 16 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 8)>{_Variant_raw_get<(0 + 16 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16 + 8 + 1) + 1: if constexpr ((0 + 16 + 8 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 8 + 1)>{_Variant_raw_get<(0 + 16 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16 + 8 + 2) + 1: if constexpr ((0 + 16 + 8 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 8 + 2)>{_Variant_raw_get<(0 + 16 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16 + 8 + 3) + 1: if constexpr ((0 + 16 + 8 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 8 + 3)>{_Variant_raw_get<(0 + 16 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16 + 12) + 1: if constexpr ((0 + 16 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 12)>{_Variant_raw_get<(0 + 16 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16 + 12 + 1) + 1: if constexpr ((0 + 16 + 12 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 12 + 1)>{_Variant_raw_get<(0 + 16 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16 + 12 + 2) + 1: if constexpr ((0 + 16 + 12 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 12 + 2)>{_Variant_raw_get<(0 + 16 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16 + 12 + 3) + 1: if constexpr ((0 + 16 + 12 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 12 + 3)>{_Variant_raw_get<(0 + 16 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32) + 1: if constexpr ((0 + 32) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32)>{_Variant_raw_get<(0 + 32)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32 + 1) + 1: if constexpr ((0 + 32 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 1)>{_Variant_raw_get<(0 + 32 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32 + 2) + 1: if constexpr ((0 + 32 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 2)>{_Variant_raw_get<(0 + 32 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32 + 3) + 1: if constexpr ((0 + 32 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 3)>{_Variant_raw_get<(0 + 32 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32 + 4) + 1: if constexpr ((0 + 32 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 4)>{_Variant_raw_get<(0 + 32 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32 + 4 + 1) + 1: if constexpr ((0 + 32 + 4 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 4 + 1)>{_Variant_raw_get<(0 + 32 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32 + 4 + 2) + 1: if constexpr ((0 + 32 + 4 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 4 + 2)>{_Variant_raw_get<(0 + 32 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32 + 4 + 3) + 1: if constexpr ((0 + 32 + 4 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 4 + 3)>{_Variant_raw_get<(0 + 32 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32 + 8) + 1: if constexpr ((0 + 32 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 8)>{_Variant_raw_get<(0 + 32 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32 + 8 + 1) + 1: if constexpr ((0 + 32 + 8 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 8 + 1)>{_Variant_raw_get<(0 + 32 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32 + 8 + 2) + 1: if constexpr ((0 + 32 + 8 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 8 + 2)>{_Variant_raw_get<(0 + 32 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32 + 8 + 3) + 1: if constexpr ((0 + 32 + 8 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 8 + 3)>{_Variant_raw_get<(0 + 32 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32 + 12) + 1: if constexpr ((0 + 32 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 12)>{_Variant_raw_get<(0 + 32 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32 + 12 + 1) + 1: if constexpr ((0 + 32 + 12 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 12 + 1)>{_Variant_raw_get<(0 + 32 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32 + 12 + 2) + 1: if constexpr ((0 + 32 + 12 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 12 + 2)>{_Variant_raw_get<(0 + 32 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32 + 12 + 3) + 1: if constexpr ((0 + 32 + 12 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 12 + 3)>{_Variant_raw_get<(0 + 32 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48) + 1: if constexpr ((0 + 48) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48)>{_Variant_raw_get<(0 + 48)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48 + 1) + 1: if constexpr ((0 + 48 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 1)>{_Variant_raw_get<(0 + 48 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48 + 2) + 1: if constexpr ((0 + 48 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 2)>{_Variant_raw_get<(0 + 48 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48 + 3) + 1: if constexpr ((0 + 48 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 3)>{_Variant_raw_get<(0 + 48 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48 + 4) + 1: if constexpr ((0 + 48 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 4)>{_Variant_raw_get<(0 + 48 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48 + 4 + 1) + 1: if constexpr ((0 + 48 + 4 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 4 + 1)>{_Variant_raw_get<(0 + 48 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48 + 4 + 2) + 1: if constexpr ((0 + 48 + 4 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 4 + 2)>{_Variant_raw_get<(0 + 48 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48 + 4 + 3) + 1: if constexpr ((0 + 48 + 4 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 4 + 3)>{_Variant_raw_get<(0 + 48 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48 + 8) + 1: if constexpr ((0 + 48 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 8)>{_Variant_raw_get<(0 + 48 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48 + 8 + 1) + 1: if constexpr ((0 + 48 + 8 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 8 + 1)>{_Variant_raw_get<(0 + 48 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48 + 8 + 2) + 1: if constexpr ((0 + 48 + 8 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 8 + 2)>{_Variant_raw_get<(0 + 48 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48 + 8 + 3) + 1: if constexpr ((0 + 48 + 8 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 8 + 3)>{_Variant_raw_get<(0 + 48 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48 + 12) + 1: if constexpr ((0 + 48 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 12)>{_Variant_raw_get<(0 + 48 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48 + 12 + 1) + 1: if constexpr ((0 + 48 + 12 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 12 + 1)>{_Variant_raw_get<(0 + 48 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48 + 12 + 2) + 1: if constexpr ((0 + 48 + 12 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 12 + 2)>{_Variant_raw_get<(0 + 48 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48 + 12 + 3) + 1: if constexpr ((0 + 48 + 12 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 12 + 3)>{_Variant_raw_get<(0 + 48 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); default: __assume(false); };
    }
};

template <>
struct _Variant_raw_visit1<4> {
    template <class _Fn, class _Storage>
    [[nodiscard]] static constexpr _Variant_raw_visit_t<_Fn, _Storage> _Visit(
        size_t _Idx, _Fn&& _Func, _Storage&& _Obj) noexcept(_Variant_raw_visit_noexcept<_Fn, _Storage>) {
        
        constexpr size_t _Size = remove_reference_t<_Storage>::_Size; static_assert(((256) == 4 || _Size > (256) / 4) && _Size <= (256)); switch (_Idx) { case 0: return static_cast<_Fn&&>(_Func)(_Tagged<_Storage&&, variant_npos>{static_cast<_Storage&&>(_Obj)}); case (0) + 1: if constexpr ((0) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0)>{_Variant_raw_get<(0)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 1) + 1: if constexpr ((0 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 1)>{_Variant_raw_get<(0 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 2) + 1: if constexpr ((0 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 2)>{_Variant_raw_get<(0 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 3) + 1: if constexpr ((0 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 3)>{_Variant_raw_get<(0 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 4) + 1: if constexpr ((0 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 4)>{_Variant_raw_get<(0 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 4 + 1) + 1: if constexpr ((0 + 4 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 4 + 1)>{_Variant_raw_get<(0 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 4 + 2) + 1: if constexpr ((0 + 4 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 4 + 2)>{_Variant_raw_get<(0 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 4 + 3) + 1: if constexpr ((0 + 4 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 4 + 3)>{_Variant_raw_get<(0 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 8) + 1: if constexpr ((0 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 8)>{_Variant_raw_get<(0 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 8 + 1) + 1: if constexpr ((0 + 8 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 8 + 1)>{_Variant_raw_get<(0 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 8 + 2) + 1: if constexpr ((0 + 8 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 8 + 2)>{_Variant_raw_get<(0 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 8 + 3) + 1: if constexpr ((0 + 8 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 8 + 3)>{_Variant_raw_get<(0 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 12) + 1: if constexpr ((0 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 12)>{_Variant_raw_get<(0 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 12 + 1) + 1: if constexpr ((0 + 12 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 12 + 1)>{_Variant_raw_get<(0 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 12 + 2) + 1: if constexpr ((0 + 12 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 12 + 2)>{_Variant_raw_get<(0 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 12 + 3) + 1: if constexpr ((0 + 12 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 12 + 3)>{_Variant_raw_get<(0 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16) + 1: if constexpr ((0 + 16) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16)>{_Variant_raw_get<(0 + 16)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16 + 1) + 1: if constexpr ((0 + 16 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 1)>{_Variant_raw_get<(0 + 16 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16 + 2) + 1: if constexpr ((0 + 16 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 2)>{_Variant_raw_get<(0 + 16 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16 + 3) + 1: if constexpr ((0 + 16 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 3)>{_Variant_raw_get<(0 + 16 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16 + 4) + 1: if constexpr ((0 + 16 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 4)>{_Variant_raw_get<(0 + 16 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16 + 4 + 1) + 1: if constexpr ((0 + 16 + 4 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 4 + 1)>{_Variant_raw_get<(0 + 16 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16 + 4 + 2) + 1: if constexpr ((0 + 16 + 4 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 4 + 2)>{_Variant_raw_get<(0 + 16 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16 + 4 + 3) + 1: if constexpr ((0 + 16 + 4 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 4 + 3)>{_Variant_raw_get<(0 + 16 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16 + 8) + 1: if constexpr ((0 + 16 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 8)>{_Variant_raw_get<(0 + 16 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16 + 8 + 1) + 1: if constexpr ((0 + 16 + 8 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 8 + 1)>{_Variant_raw_get<(0 + 16 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16 + 8 + 2) + 1: if constexpr ((0 + 16 + 8 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 8 + 2)>{_Variant_raw_get<(0 + 16 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16 + 8 + 3) + 1: if constexpr ((0 + 16 + 8 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 8 + 3)>{_Variant_raw_get<(0 + 16 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16 + 12) + 1: if constexpr ((0 + 16 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 12)>{_Variant_raw_get<(0 + 16 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16 + 12 + 1) + 1: if constexpr ((0 + 16 + 12 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 12 + 1)>{_Variant_raw_get<(0 + 16 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16 + 12 + 2) + 1: if constexpr ((0 + 16 + 12 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 12 + 2)>{_Variant_raw_get<(0 + 16 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 16 + 12 + 3) + 1: if constexpr ((0 + 16 + 12 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 16 + 12 + 3)>{_Variant_raw_get<(0 + 16 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32) + 1: if constexpr ((0 + 32) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32)>{_Variant_raw_get<(0 + 32)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32 + 1) + 1: if constexpr ((0 + 32 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 1)>{_Variant_raw_get<(0 + 32 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32 + 2) + 1: if constexpr ((0 + 32 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 2)>{_Variant_raw_get<(0 + 32 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32 + 3) + 1: if constexpr ((0 + 32 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 3)>{_Variant_raw_get<(0 + 32 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32 + 4) + 1: if constexpr ((0 + 32 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 4)>{_Variant_raw_get<(0 + 32 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32 + 4 + 1) + 1: if constexpr ((0 + 32 + 4 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 4 + 1)>{_Variant_raw_get<(0 + 32 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32 + 4 + 2) + 1: if constexpr ((0 + 32 + 4 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 4 + 2)>{_Variant_raw_get<(0 + 32 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32 + 4 + 3) + 1: if constexpr ((0 + 32 + 4 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 4 + 3)>{_Variant_raw_get<(0 + 32 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32 + 8) + 1: if constexpr ((0 + 32 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 8)>{_Variant_raw_get<(0 + 32 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32 + 8 + 1) + 1: if constexpr ((0 + 32 + 8 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 8 + 1)>{_Variant_raw_get<(0 + 32 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32 + 8 + 2) + 1: if constexpr ((0 + 32 + 8 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 8 + 2)>{_Variant_raw_get<(0 + 32 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32 + 8 + 3) + 1: if constexpr ((0 + 32 + 8 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 8 + 3)>{_Variant_raw_get<(0 + 32 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32 + 12) + 1: if constexpr ((0 + 32 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 12)>{_Variant_raw_get<(0 + 32 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32 + 12 + 1) + 1: if constexpr ((0 + 32 + 12 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 12 + 1)>{_Variant_raw_get<(0 + 32 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32 + 12 + 2) + 1: if constexpr ((0 + 32 + 12 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 12 + 2)>{_Variant_raw_get<(0 + 32 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 32 + 12 + 3) + 1: if constexpr ((0 + 32 + 12 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 32 + 12 + 3)>{_Variant_raw_get<(0 + 32 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48) + 1: if constexpr ((0 + 48) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48)>{_Variant_raw_get<(0 + 48)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48 + 1) + 1: if constexpr ((0 + 48 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 1)>{_Variant_raw_get<(0 + 48 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48 + 2) + 1: if constexpr ((0 + 48 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 2)>{_Variant_raw_get<(0 + 48 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48 + 3) + 1: if constexpr ((0 + 48 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 3)>{_Variant_raw_get<(0 + 48 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48 + 4) + 1: if constexpr ((0 + 48 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 4)>{_Variant_raw_get<(0 + 48 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48 + 4 + 1) + 1: if constexpr ((0 + 48 + 4 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 4 + 1)>{_Variant_raw_get<(0 + 48 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48 + 4 + 2) + 1: if constexpr ((0 + 48 + 4 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 4 + 2)>{_Variant_raw_get<(0 + 48 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48 + 4 + 3) + 1: if constexpr ((0 + 48 + 4 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 4 + 3)>{_Variant_raw_get<(0 + 48 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48 + 8) + 1: if constexpr ((0 + 48 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 8)>{_Variant_raw_get<(0 + 48 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48 + 8 + 1) + 1: if constexpr ((0 + 48 + 8 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 8 + 1)>{_Variant_raw_get<(0 + 48 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48 + 8 + 2) + 1: if constexpr ((0 + 48 + 8 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 8 + 2)>{_Variant_raw_get<(0 + 48 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48 + 8 + 3) + 1: if constexpr ((0 + 48 + 8 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 8 + 3)>{_Variant_raw_get<(0 + 48 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48 + 12) + 1: if constexpr ((0 + 48 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 12)>{_Variant_raw_get<(0 + 48 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48 + 12 + 1) + 1: if constexpr ((0 + 48 + 12 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 12 + 1)>{_Variant_raw_get<(0 + 48 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48 + 12 + 2) + 1: if constexpr ((0 + 48 + 12 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 12 + 2)>{_Variant_raw_get<(0 + 48 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 48 + 12 + 3) + 1: if constexpr ((0 + 48 + 12 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 48 + 12 + 3)>{_Variant_raw_get<(0 + 48 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64) + 1: if constexpr ((0 + 64) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64)>{_Variant_raw_get<(0 + 64)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 1) + 1: if constexpr ((0 + 64 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 1)>{_Variant_raw_get<(0 + 64 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 2) + 1: if constexpr ((0 + 64 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 2)>{_Variant_raw_get<(0 + 64 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 3) + 1: if constexpr ((0 + 64 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 3)>{_Variant_raw_get<(0 + 64 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 4) + 1: if constexpr ((0 + 64 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 4)>{_Variant_raw_get<(0 + 64 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 4 + 1) + 1: if constexpr ((0 + 64 + 4 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 4 + 1)>{_Variant_raw_get<(0 + 64 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 4 + 2) + 1: if constexpr ((0 + 64 + 4 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 4 + 2)>{_Variant_raw_get<(0 + 64 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 4 + 3) + 1: if constexpr ((0 + 64 + 4 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 4 + 3)>{_Variant_raw_get<(0 + 64 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 8) + 1: if constexpr ((0 + 64 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 8)>{_Variant_raw_get<(0 + 64 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 8 + 1) + 1: if constexpr ((0 + 64 + 8 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 8 + 1)>{_Variant_raw_get<(0 + 64 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 8 + 2) + 1: if constexpr ((0 + 64 + 8 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 8 + 2)>{_Variant_raw_get<(0 + 64 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 8 + 3) + 1: if constexpr ((0 + 64 + 8 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 8 + 3)>{_Variant_raw_get<(0 + 64 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 12) + 1: if constexpr ((0 + 64 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 12)>{_Variant_raw_get<(0 + 64 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 12 + 1) + 1: if constexpr ((0 + 64 + 12 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 12 + 1)>{_Variant_raw_get<(0 + 64 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 12 + 2) + 1: if constexpr ((0 + 64 + 12 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 12 + 2)>{_Variant_raw_get<(0 + 64 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 12 + 3) + 1: if constexpr ((0 + 64 + 12 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 12 + 3)>{_Variant_raw_get<(0 + 64 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 16) + 1: if constexpr ((0 + 64 + 16) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 16)>{_Variant_raw_get<(0 + 64 + 16)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 16 + 1) + 1: if constexpr ((0 + 64 + 16 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 16 + 1)>{_Variant_raw_get<(0 + 64 + 16 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 16 + 2) + 1: if constexpr ((0 + 64 + 16 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 16 + 2)>{_Variant_raw_get<(0 + 64 + 16 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 16 + 3) + 1: if constexpr ((0 + 64 + 16 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 16 + 3)>{_Variant_raw_get<(0 + 64 + 16 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 16 + 4) + 1: if constexpr ((0 + 64 + 16 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 16 + 4)>{_Variant_raw_get<(0 + 64 + 16 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 16 + 4 + 1) + 1: if constexpr ((0 + 64 + 16 + 4 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 16 + 4 + 1)>{_Variant_raw_get<(0 + 64 + 16 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 16 + 4 + 2) + 1: if constexpr ((0 + 64 + 16 + 4 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 16 + 4 + 2)>{_Variant_raw_get<(0 + 64 + 16 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 16 + 4 + 3) + 1: if constexpr ((0 + 64 + 16 + 4 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 16 + 4 + 3)>{_Variant_raw_get<(0 + 64 + 16 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 16 + 8) + 1: if constexpr ((0 + 64 + 16 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 16 + 8)>{_Variant_raw_get<(0 + 64 + 16 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 16 + 8 + 1) + 1: if constexpr ((0 + 64 + 16 + 8 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 16 + 8 + 1)>{_Variant_raw_get<(0 + 64 + 16 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 16 + 8 + 2) + 1: if constexpr ((0 + 64 + 16 + 8 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 16 + 8 + 2)>{_Variant_raw_get<(0 + 64 + 16 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 16 + 8 + 3) + 1: if constexpr ((0 + 64 + 16 + 8 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 16 + 8 + 3)>{_Variant_raw_get<(0 + 64 + 16 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 16 + 12) + 1: if constexpr ((0 + 64 + 16 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 16 + 12)>{_Variant_raw_get<(0 + 64 + 16 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 16 + 12 + 1) + 1: if constexpr ((0 + 64 + 16 + 12 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 16 + 12 + 1)>{_Variant_raw_get<(0 + 64 + 16 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 16 + 12 + 2) + 1: if constexpr ((0 + 64 + 16 + 12 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 16 + 12 + 2)>{_Variant_raw_get<(0 + 64 + 16 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 16 + 12 + 3) + 1: if constexpr ((0 + 64 + 16 + 12 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 16 + 12 + 3)>{_Variant_raw_get<(0 + 64 + 16 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 32) + 1: if constexpr ((0 + 64 + 32) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 32)>{_Variant_raw_get<(0 + 64 + 32)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 32 + 1) + 1: if constexpr ((0 + 64 + 32 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 32 + 1)>{_Variant_raw_get<(0 + 64 + 32 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 32 + 2) + 1: if constexpr ((0 + 64 + 32 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 32 + 2)>{_Variant_raw_get<(0 + 64 + 32 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 32 + 3) + 1: if constexpr ((0 + 64 + 32 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 32 + 3)>{_Variant_raw_get<(0 + 64 + 32 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 32 + 4) + 1: if constexpr ((0 + 64 + 32 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 32 + 4)>{_Variant_raw_get<(0 + 64 + 32 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 32 + 4 + 1) + 1: if constexpr ((0 + 64 + 32 + 4 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 32 + 4 + 1)>{_Variant_raw_get<(0 + 64 + 32 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 32 + 4 + 2) + 1: if constexpr ((0 + 64 + 32 + 4 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 32 + 4 + 2)>{_Variant_raw_get<(0 + 64 + 32 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 32 + 4 + 3) + 1: if constexpr ((0 + 64 + 32 + 4 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 32 + 4 + 3)>{_Variant_raw_get<(0 + 64 + 32 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 32 + 8) + 1: if constexpr ((0 + 64 + 32 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 32 + 8)>{_Variant_raw_get<(0 + 64 + 32 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 32 + 8 + 1) + 1: if constexpr ((0 + 64 + 32 + 8 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 32 + 8 + 1)>{_Variant_raw_get<(0 + 64 + 32 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 32 + 8 + 2) + 1: if constexpr ((0 + 64 + 32 + 8 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 32 + 8 + 2)>{_Variant_raw_get<(0 + 64 + 32 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 32 + 8 + 3) + 1: if constexpr ((0 + 64 + 32 + 8 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 32 + 8 + 3)>{_Variant_raw_get<(0 + 64 + 32 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 32 + 12) + 1: if constexpr ((0 + 64 + 32 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 32 + 12)>{_Variant_raw_get<(0 + 64 + 32 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 32 + 12 + 1) + 1: if constexpr ((0 + 64 + 32 + 12 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 32 + 12 + 1)>{_Variant_raw_get<(0 + 64 + 32 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 32 + 12 + 2) + 1: if constexpr ((0 + 64 + 32 + 12 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 32 + 12 + 2)>{_Variant_raw_get<(0 + 64 + 32 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 32 + 12 + 3) + 1: if constexpr ((0 + 64 + 32 + 12 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 32 + 12 + 3)>{_Variant_raw_get<(0 + 64 + 32 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 48) + 1: if constexpr ((0 + 64 + 48) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 48)>{_Variant_raw_get<(0 + 64 + 48)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 48 + 1) + 1: if constexpr ((0 + 64 + 48 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 48 + 1)>{_Variant_raw_get<(0 + 64 + 48 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 48 + 2) + 1: if constexpr ((0 + 64 + 48 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 48 + 2)>{_Variant_raw_get<(0 + 64 + 48 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 48 + 3) + 1: if constexpr ((0 + 64 + 48 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 48 + 3)>{_Variant_raw_get<(0 + 64 + 48 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 48 + 4) + 1: if constexpr ((0 + 64 + 48 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 48 + 4)>{_Variant_raw_get<(0 + 64 + 48 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 48 + 4 + 1) + 1: if constexpr ((0 + 64 + 48 + 4 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 48 + 4 + 1)>{_Variant_raw_get<(0 + 64 + 48 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 48 + 4 + 2) + 1: if constexpr ((0 + 64 + 48 + 4 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 48 + 4 + 2)>{_Variant_raw_get<(0 + 64 + 48 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 48 + 4 + 3) + 1: if constexpr ((0 + 64 + 48 + 4 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 48 + 4 + 3)>{_Variant_raw_get<(0 + 64 + 48 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 48 + 8) + 1: if constexpr ((0 + 64 + 48 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 48 + 8)>{_Variant_raw_get<(0 + 64 + 48 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 48 + 8 + 1) + 1: if constexpr ((0 + 64 + 48 + 8 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 48 + 8 + 1)>{_Variant_raw_get<(0 + 64 + 48 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 48 + 8 + 2) + 1: if constexpr ((0 + 64 + 48 + 8 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 48 + 8 + 2)>{_Variant_raw_get<(0 + 64 + 48 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 48 + 8 + 3) + 1: if constexpr ((0 + 64 + 48 + 8 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 48 + 8 + 3)>{_Variant_raw_get<(0 + 64 + 48 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 48 + 12) + 1: if constexpr ((0 + 64 + 48 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 48 + 12)>{_Variant_raw_get<(0 + 64 + 48 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 48 + 12 + 1) + 1: if constexpr ((0 + 64 + 48 + 12 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 48 + 12 + 1)>{_Variant_raw_get<(0 + 64 + 48 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 48 + 12 + 2) + 1: if constexpr ((0 + 64 + 48 + 12 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 48 + 12 + 2)>{_Variant_raw_get<(0 + 64 + 48 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 64 + 48 + 12 + 3) + 1: if constexpr ((0 + 64 + 48 + 12 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 64 + 48 + 12 + 3)>{_Variant_raw_get<(0 + 64 + 48 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128) + 1: if constexpr ((0 + 128) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128)>{_Variant_raw_get<(0 + 128)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 1) + 1: if constexpr ((0 + 128 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 1)>{_Variant_raw_get<(0 + 128 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 2) + 1: if constexpr ((0 + 128 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 2)>{_Variant_raw_get<(0 + 128 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 3) + 1: if constexpr ((0 + 128 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 3)>{_Variant_raw_get<(0 + 128 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 4) + 1: if constexpr ((0 + 128 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 4)>{_Variant_raw_get<(0 + 128 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 4 + 1) + 1: if constexpr ((0 + 128 + 4 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 4 + 1)>{_Variant_raw_get<(0 + 128 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 4 + 2) + 1: if constexpr ((0 + 128 + 4 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 4 + 2)>{_Variant_raw_get<(0 + 128 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 4 + 3) + 1: if constexpr ((0 + 128 + 4 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 4 + 3)>{_Variant_raw_get<(0 + 128 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 8) + 1: if constexpr ((0 + 128 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 8)>{_Variant_raw_get<(0 + 128 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 8 + 1) + 1: if constexpr ((0 + 128 + 8 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 8 + 1)>{_Variant_raw_get<(0 + 128 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 8 + 2) + 1: if constexpr ((0 + 128 + 8 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 8 + 2)>{_Variant_raw_get<(0 + 128 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 8 + 3) + 1: if constexpr ((0 + 128 + 8 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 8 + 3)>{_Variant_raw_get<(0 + 128 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 12) + 1: if constexpr ((0 + 128 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 12)>{_Variant_raw_get<(0 + 128 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 12 + 1) + 1: if constexpr ((0 + 128 + 12 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 12 + 1)>{_Variant_raw_get<(0 + 128 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 12 + 2) + 1: if constexpr ((0 + 128 + 12 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 12 + 2)>{_Variant_raw_get<(0 + 128 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 12 + 3) + 1: if constexpr ((0 + 128 + 12 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 12 + 3)>{_Variant_raw_get<(0 + 128 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 16) + 1: if constexpr ((0 + 128 + 16) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 16)>{_Variant_raw_get<(0 + 128 + 16)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 16 + 1) + 1: if constexpr ((0 + 128 + 16 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 16 + 1)>{_Variant_raw_get<(0 + 128 + 16 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 16 + 2) + 1: if constexpr ((0 + 128 + 16 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 16 + 2)>{_Variant_raw_get<(0 + 128 + 16 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 16 + 3) + 1: if constexpr ((0 + 128 + 16 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 16 + 3)>{_Variant_raw_get<(0 + 128 + 16 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 16 + 4) + 1: if constexpr ((0 + 128 + 16 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 16 + 4)>{_Variant_raw_get<(0 + 128 + 16 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 16 + 4 + 1) + 1: if constexpr ((0 + 128 + 16 + 4 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 16 + 4 + 1)>{_Variant_raw_get<(0 + 128 + 16 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 16 + 4 + 2) + 1: if constexpr ((0 + 128 + 16 + 4 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 16 + 4 + 2)>{_Variant_raw_get<(0 + 128 + 16 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 16 + 4 + 3) + 1: if constexpr ((0 + 128 + 16 + 4 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 16 + 4 + 3)>{_Variant_raw_get<(0 + 128 + 16 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 16 + 8) + 1: if constexpr ((0 + 128 + 16 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 16 + 8)>{_Variant_raw_get<(0 + 128 + 16 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 16 + 8 + 1) + 1: if constexpr ((0 + 128 + 16 + 8 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 16 + 8 + 1)>{_Variant_raw_get<(0 + 128 + 16 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 16 + 8 + 2) + 1: if constexpr ((0 + 128 + 16 + 8 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 16 + 8 + 2)>{_Variant_raw_get<(0 + 128 + 16 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 16 + 8 + 3) + 1: if constexpr ((0 + 128 + 16 + 8 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 16 + 8 + 3)>{_Variant_raw_get<(0 + 128 + 16 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 16 + 12) + 1: if constexpr ((0 + 128 + 16 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 16 + 12)>{_Variant_raw_get<(0 + 128 + 16 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 16 + 12 + 1) + 1: if constexpr ((0 + 128 + 16 + 12 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 16 + 12 + 1)>{_Variant_raw_get<(0 + 128 + 16 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 16 + 12 + 2) + 1: if constexpr ((0 + 128 + 16 + 12 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 16 + 12 + 2)>{_Variant_raw_get<(0 + 128 + 16 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 16 + 12 + 3) + 1: if constexpr ((0 + 128 + 16 + 12 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 16 + 12 + 3)>{_Variant_raw_get<(0 + 128 + 16 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 32) + 1: if constexpr ((0 + 128 + 32) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 32)>{_Variant_raw_get<(0 + 128 + 32)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 32 + 1) + 1: if constexpr ((0 + 128 + 32 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 32 + 1)>{_Variant_raw_get<(0 + 128 + 32 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 32 + 2) + 1: if constexpr ((0 + 128 + 32 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 32 + 2)>{_Variant_raw_get<(0 + 128 + 32 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 32 + 3) + 1: if constexpr ((0 + 128 + 32 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 32 + 3)>{_Variant_raw_get<(0 + 128 + 32 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 32 + 4) + 1: if constexpr ((0 + 128 + 32 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 32 + 4)>{_Variant_raw_get<(0 + 128 + 32 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 32 + 4 + 1) + 1: if constexpr ((0 + 128 + 32 + 4 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 32 + 4 + 1)>{_Variant_raw_get<(0 + 128 + 32 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 32 + 4 + 2) + 1: if constexpr ((0 + 128 + 32 + 4 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 32 + 4 + 2)>{_Variant_raw_get<(0 + 128 + 32 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 32 + 4 + 3) + 1: if constexpr ((0 + 128 + 32 + 4 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 32 + 4 + 3)>{_Variant_raw_get<(0 + 128 + 32 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 32 + 8) + 1: if constexpr ((0 + 128 + 32 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 32 + 8)>{_Variant_raw_get<(0 + 128 + 32 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 32 + 8 + 1) + 1: if constexpr ((0 + 128 + 32 + 8 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 32 + 8 + 1)>{_Variant_raw_get<(0 + 128 + 32 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 32 + 8 + 2) + 1: if constexpr ((0 + 128 + 32 + 8 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 32 + 8 + 2)>{_Variant_raw_get<(0 + 128 + 32 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 32 + 8 + 3) + 1: if constexpr ((0 + 128 + 32 + 8 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 32 + 8 + 3)>{_Variant_raw_get<(0 + 128 + 32 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 32 + 12) + 1: if constexpr ((0 + 128 + 32 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 32 + 12)>{_Variant_raw_get<(0 + 128 + 32 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 32 + 12 + 1) + 1: if constexpr ((0 + 128 + 32 + 12 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 32 + 12 + 1)>{_Variant_raw_get<(0 + 128 + 32 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 32 + 12 + 2) + 1: if constexpr ((0 + 128 + 32 + 12 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 32 + 12 + 2)>{_Variant_raw_get<(0 + 128 + 32 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 32 + 12 + 3) + 1: if constexpr ((0 + 128 + 32 + 12 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 32 + 12 + 3)>{_Variant_raw_get<(0 + 128 + 32 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 48) + 1: if constexpr ((0 + 128 + 48) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 48)>{_Variant_raw_get<(0 + 128 + 48)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 48 + 1) + 1: if constexpr ((0 + 128 + 48 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 48 + 1)>{_Variant_raw_get<(0 + 128 + 48 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 48 + 2) + 1: if constexpr ((0 + 128 + 48 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 48 + 2)>{_Variant_raw_get<(0 + 128 + 48 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 48 + 3) + 1: if constexpr ((0 + 128 + 48 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 48 + 3)>{_Variant_raw_get<(0 + 128 + 48 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 48 + 4) + 1: if constexpr ((0 + 128 + 48 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 48 + 4)>{_Variant_raw_get<(0 + 128 + 48 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 48 + 4 + 1) + 1: if constexpr ((0 + 128 + 48 + 4 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 48 + 4 + 1)>{_Variant_raw_get<(0 + 128 + 48 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 48 + 4 + 2) + 1: if constexpr ((0 + 128 + 48 + 4 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 48 + 4 + 2)>{_Variant_raw_get<(0 + 128 + 48 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 48 + 4 + 3) + 1: if constexpr ((0 + 128 + 48 + 4 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 48 + 4 + 3)>{_Variant_raw_get<(0 + 128 + 48 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 48 + 8) + 1: if constexpr ((0 + 128 + 48 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 48 + 8)>{_Variant_raw_get<(0 + 128 + 48 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 48 + 8 + 1) + 1: if constexpr ((0 + 128 + 48 + 8 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 48 + 8 + 1)>{_Variant_raw_get<(0 + 128 + 48 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 48 + 8 + 2) + 1: if constexpr ((0 + 128 + 48 + 8 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 48 + 8 + 2)>{_Variant_raw_get<(0 + 128 + 48 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 48 + 8 + 3) + 1: if constexpr ((0 + 128 + 48 + 8 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 48 + 8 + 3)>{_Variant_raw_get<(0 + 128 + 48 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 48 + 12) + 1: if constexpr ((0 + 128 + 48 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 48 + 12)>{_Variant_raw_get<(0 + 128 + 48 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 48 + 12 + 1) + 1: if constexpr ((0 + 128 + 48 + 12 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 48 + 12 + 1)>{_Variant_raw_get<(0 + 128 + 48 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 48 + 12 + 2) + 1: if constexpr ((0 + 128 + 48 + 12 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 48 + 12 + 2)>{_Variant_raw_get<(0 + 128 + 48 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 128 + 48 + 12 + 3) + 1: if constexpr ((0 + 128 + 48 + 12 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 128 + 48 + 12 + 3)>{_Variant_raw_get<(0 + 128 + 48 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192) + 1: if constexpr ((0 + 192) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192)>{_Variant_raw_get<(0 + 192)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 1) + 1: if constexpr ((0 + 192 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 1)>{_Variant_raw_get<(0 + 192 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 2) + 1: if constexpr ((0 + 192 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 2)>{_Variant_raw_get<(0 + 192 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 3) + 1: if constexpr ((0 + 192 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 3)>{_Variant_raw_get<(0 + 192 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 4) + 1: if constexpr ((0 + 192 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 4)>{_Variant_raw_get<(0 + 192 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 4 + 1) + 1: if constexpr ((0 + 192 + 4 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 4 + 1)>{_Variant_raw_get<(0 + 192 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 4 + 2) + 1: if constexpr ((0 + 192 + 4 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 4 + 2)>{_Variant_raw_get<(0 + 192 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 4 + 3) + 1: if constexpr ((0 + 192 + 4 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 4 + 3)>{_Variant_raw_get<(0 + 192 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 8) + 1: if constexpr ((0 + 192 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 8)>{_Variant_raw_get<(0 + 192 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 8 + 1) + 1: if constexpr ((0 + 192 + 8 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 8 + 1)>{_Variant_raw_get<(0 + 192 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 8 + 2) + 1: if constexpr ((0 + 192 + 8 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 8 + 2)>{_Variant_raw_get<(0 + 192 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 8 + 3) + 1: if constexpr ((0 + 192 + 8 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 8 + 3)>{_Variant_raw_get<(0 + 192 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 12) + 1: if constexpr ((0 + 192 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 12)>{_Variant_raw_get<(0 + 192 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 12 + 1) + 1: if constexpr ((0 + 192 + 12 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 12 + 1)>{_Variant_raw_get<(0 + 192 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 12 + 2) + 1: if constexpr ((0 + 192 + 12 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 12 + 2)>{_Variant_raw_get<(0 + 192 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 12 + 3) + 1: if constexpr ((0 + 192 + 12 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 12 + 3)>{_Variant_raw_get<(0 + 192 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 16) + 1: if constexpr ((0 + 192 + 16) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 16)>{_Variant_raw_get<(0 + 192 + 16)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 16 + 1) + 1: if constexpr ((0 + 192 + 16 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 16 + 1)>{_Variant_raw_get<(0 + 192 + 16 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 16 + 2) + 1: if constexpr ((0 + 192 + 16 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 16 + 2)>{_Variant_raw_get<(0 + 192 + 16 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 16 + 3) + 1: if constexpr ((0 + 192 + 16 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 16 + 3)>{_Variant_raw_get<(0 + 192 + 16 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 16 + 4) + 1: if constexpr ((0 + 192 + 16 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 16 + 4)>{_Variant_raw_get<(0 + 192 + 16 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 16 + 4 + 1) + 1: if constexpr ((0 + 192 + 16 + 4 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 16 + 4 + 1)>{_Variant_raw_get<(0 + 192 + 16 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 16 + 4 + 2) + 1: if constexpr ((0 + 192 + 16 + 4 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 16 + 4 + 2)>{_Variant_raw_get<(0 + 192 + 16 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 16 + 4 + 3) + 1: if constexpr ((0 + 192 + 16 + 4 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 16 + 4 + 3)>{_Variant_raw_get<(0 + 192 + 16 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 16 + 8) + 1: if constexpr ((0 + 192 + 16 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 16 + 8)>{_Variant_raw_get<(0 + 192 + 16 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 16 + 8 + 1) + 1: if constexpr ((0 + 192 + 16 + 8 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 16 + 8 + 1)>{_Variant_raw_get<(0 + 192 + 16 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 16 + 8 + 2) + 1: if constexpr ((0 + 192 + 16 + 8 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 16 + 8 + 2)>{_Variant_raw_get<(0 + 192 + 16 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 16 + 8 + 3) + 1: if constexpr ((0 + 192 + 16 + 8 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 16 + 8 + 3)>{_Variant_raw_get<(0 + 192 + 16 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 16 + 12) + 1: if constexpr ((0 + 192 + 16 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 16 + 12)>{_Variant_raw_get<(0 + 192 + 16 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 16 + 12 + 1) + 1: if constexpr ((0 + 192 + 16 + 12 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 16 + 12 + 1)>{_Variant_raw_get<(0 + 192 + 16 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 16 + 12 + 2) + 1: if constexpr ((0 + 192 + 16 + 12 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 16 + 12 + 2)>{_Variant_raw_get<(0 + 192 + 16 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 16 + 12 + 3) + 1: if constexpr ((0 + 192 + 16 + 12 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 16 + 12 + 3)>{_Variant_raw_get<(0 + 192 + 16 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 32) + 1: if constexpr ((0 + 192 + 32) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 32)>{_Variant_raw_get<(0 + 192 + 32)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 32 + 1) + 1: if constexpr ((0 + 192 + 32 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 32 + 1)>{_Variant_raw_get<(0 + 192 + 32 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 32 + 2) + 1: if constexpr ((0 + 192 + 32 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 32 + 2)>{_Variant_raw_get<(0 + 192 + 32 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 32 + 3) + 1: if constexpr ((0 + 192 + 32 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 32 + 3)>{_Variant_raw_get<(0 + 192 + 32 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 32 + 4) + 1: if constexpr ((0 + 192 + 32 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 32 + 4)>{_Variant_raw_get<(0 + 192 + 32 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 32 + 4 + 1) + 1: if constexpr ((0 + 192 + 32 + 4 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 32 + 4 + 1)>{_Variant_raw_get<(0 + 192 + 32 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 32 + 4 + 2) + 1: if constexpr ((0 + 192 + 32 + 4 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 32 + 4 + 2)>{_Variant_raw_get<(0 + 192 + 32 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 32 + 4 + 3) + 1: if constexpr ((0 + 192 + 32 + 4 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 32 + 4 + 3)>{_Variant_raw_get<(0 + 192 + 32 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 32 + 8) + 1: if constexpr ((0 + 192 + 32 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 32 + 8)>{_Variant_raw_get<(0 + 192 + 32 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 32 + 8 + 1) + 1: if constexpr ((0 + 192 + 32 + 8 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 32 + 8 + 1)>{_Variant_raw_get<(0 + 192 + 32 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 32 + 8 + 2) + 1: if constexpr ((0 + 192 + 32 + 8 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 32 + 8 + 2)>{_Variant_raw_get<(0 + 192 + 32 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 32 + 8 + 3) + 1: if constexpr ((0 + 192 + 32 + 8 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 32 + 8 + 3)>{_Variant_raw_get<(0 + 192 + 32 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 32 + 12) + 1: if constexpr ((0 + 192 + 32 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 32 + 12)>{_Variant_raw_get<(0 + 192 + 32 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 32 + 12 + 1) + 1: if constexpr ((0 + 192 + 32 + 12 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 32 + 12 + 1)>{_Variant_raw_get<(0 + 192 + 32 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 32 + 12 + 2) + 1: if constexpr ((0 + 192 + 32 + 12 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 32 + 12 + 2)>{_Variant_raw_get<(0 + 192 + 32 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 32 + 12 + 3) + 1: if constexpr ((0 + 192 + 32 + 12 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 32 + 12 + 3)>{_Variant_raw_get<(0 + 192 + 32 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 48) + 1: if constexpr ((0 + 192 + 48) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 48)>{_Variant_raw_get<(0 + 192 + 48)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 48 + 1) + 1: if constexpr ((0 + 192 + 48 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 48 + 1)>{_Variant_raw_get<(0 + 192 + 48 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 48 + 2) + 1: if constexpr ((0 + 192 + 48 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 48 + 2)>{_Variant_raw_get<(0 + 192 + 48 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 48 + 3) + 1: if constexpr ((0 + 192 + 48 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 48 + 3)>{_Variant_raw_get<(0 + 192 + 48 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 48 + 4) + 1: if constexpr ((0 + 192 + 48 + 4) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 48 + 4)>{_Variant_raw_get<(0 + 192 + 48 + 4)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 48 + 4 + 1) + 1: if constexpr ((0 + 192 + 48 + 4 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 48 + 4 + 1)>{_Variant_raw_get<(0 + 192 + 48 + 4 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 48 + 4 + 2) + 1: if constexpr ((0 + 192 + 48 + 4 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 48 + 4 + 2)>{_Variant_raw_get<(0 + 192 + 48 + 4 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 48 + 4 + 3) + 1: if constexpr ((0 + 192 + 48 + 4 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 48 + 4 + 3)>{_Variant_raw_get<(0 + 192 + 48 + 4 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 48 + 8) + 1: if constexpr ((0 + 192 + 48 + 8) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 48 + 8)>{_Variant_raw_get<(0 + 192 + 48 + 8)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 48 + 8 + 1) + 1: if constexpr ((0 + 192 + 48 + 8 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 48 + 8 + 1)>{_Variant_raw_get<(0 + 192 + 48 + 8 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 48 + 8 + 2) + 1: if constexpr ((0 + 192 + 48 + 8 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 48 + 8 + 2)>{_Variant_raw_get<(0 + 192 + 48 + 8 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 48 + 8 + 3) + 1: if constexpr ((0 + 192 + 48 + 8 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 48 + 8 + 3)>{_Variant_raw_get<(0 + 192 + 48 + 8 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 48 + 12) + 1: if constexpr ((0 + 192 + 48 + 12) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 48 + 12)>{_Variant_raw_get<(0 + 192 + 48 + 12)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 48 + 12 + 1) + 1: if constexpr ((0 + 192 + 48 + 12 + 1) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 48 + 12 + 1)>{_Variant_raw_get<(0 + 192 + 48 + 12 + 1)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 48 + 12 + 2) + 1: if constexpr ((0 + 192 + 48 + 12 + 2) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 48 + 12 + 2)>{_Variant_raw_get<(0 + 192 + 48 + 12 + 2)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); case (0 + 192 + 48 + 12 + 3) + 1: if constexpr ((0 + 192 + 48 + 12 + 3) < _Size) { return static_cast<_Fn&&>(_Func)( _Variant_tagged_ref_t<_Storage, (0 + 192 + 48 + 12 + 3)>{_Variant_raw_get<(0 + 192 + 48 + 12 + 3)>(static_cast<_Storage&&>(_Obj))}); } __assume(false); default: __assume(false); };
    }
};


template <class _Storage, class _Fn>
[[nodiscard]] constexpr _Variant_raw_visit_t<_Fn, _Storage> _Variant_raw_visit(
    size_t _Idx, _Storage&& _Obj, _Fn&& _Func) noexcept(_Variant_raw_visit_noexcept<_Fn, _Storage>) {
    
    
    constexpr size_t _Size  = remove_reference_t<_Storage>::_Size;
    constexpr int _Strategy = _Size <= 4 ? 1 : _Size <= 16 ? 2 : _Size <= 64 ? 3 : _Size <= 256 ? 4 : -1;
    ++_Idx; 
    return _Variant_raw_visit1<_Strategy>::_Visit(_Idx, static_cast<_Fn&&>(_Func), static_cast<_Storage&&>(_Obj));
}

template <class...>
class _Variant_base;

template <size_t _Count>
using _Variant_index_t = 
    conditional_t<(_Count < static_cast<size_t>((numeric_limits<signed char>::max)())), signed char,
        conditional_t<(_Count < static_cast<size_t>((numeric_limits<short>::max)())), short, int>>;

template <class... _Types>
struct _Variant_construct_visitor { 
                                    
    _Variant_base<_Types...>& _Self;

    template <class _Ty, size_t _Idx>
    constexpr void operator()(_Tagged<_Ty, _Idx> _Source) const noexcept(
        disjunction_v<bool_constant<_Idx == variant_npos>, is_nothrow_constructible<remove_reference_t<_Ty>, _Ty>>) {
        
        ;
        if constexpr (_Idx != variant_npos) {
            _Construct_in_place(_Self._Storage(), integral_constant<size_t, _Idx>{}, static_cast<_Ty&&>(_Source._Val));
            _Self._Set_index(_Idx);
        }
    }
};

template <class _Target, class... _Types>
inline constexpr bool _Variant_should_directly_construct_v =
    disjunction_v<is_nothrow_constructible<_Target, _Types...>, negation<is_nothrow_move_constructible<_Target>>>;

template <class... _Types>
struct _Variant_assign_visitor { 
    _Variant_base<_Types...>& _Self;

    template <class _Ty, size_t _Idx>
    constexpr void operator()(_Tagged<_Ty, _Idx> _Source) const
        noexcept(disjunction_v<bool_constant<_Idx == variant_npos>,
            conjunction<is_nothrow_assignable<_Remove_cvref_t<_Ty>&, _Ty>,
                is_nothrow_constructible<_Remove_cvref_t<_Ty>, _Ty>>>) {
        
        if constexpr (_Idx == variant_npos) { 
            _Self._Reset();
        } else {
            if (_Self._Which == _Idx) { 
                auto& _Target = _Variant_raw_get<_Idx>(_Self._Storage());
                _Target       = static_cast<_Ty&&>(_Source._Val);
            } else { 
                if constexpr (is_lvalue_reference_v<_Ty>) { 
                    if constexpr (_Variant_should_directly_construct_v<_Remove_cvref_t<_Ty>, _Ty>) {
                        
                        _Self._Reset();
                        _Construct_in_place(_Self._Storage(), integral_constant<size_t, _Idx>{}, _Source._Val);
                    } else { 
                        auto _Temp = _Source._Val;
                        _Self._Reset();
                        _Construct_in_place(_Self._Storage(), integral_constant<size_t, _Idx>{}, ::std:: move(_Temp));
                    }
                } else { 
                    _Self._Reset();
                    _Construct_in_place(
                        _Self._Storage(), integral_constant<size_t, _Idx>{}, static_cast<_Ty&&>(_Source._Val));
                }

                _Self._Set_index(_Idx);
            }
        }
    }
};

template <class... _Types> 
class _Variant_base : private _Variant_storage<_Types...> {
public:
    using _Index_t                       = _Variant_index_t<sizeof...(_Types)>;
    static constexpr auto _Invalid_index = static_cast<_Index_t>(-1);
    _Index_t _Which;

    using _Storage_t = _Variant_storage<_Types...>;
    [[nodiscard]] constexpr _Storage_t& _Storage() & noexcept { 
        return *this;
    }
    [[nodiscard]] constexpr const _Storage_t& _Storage() const& noexcept { 
        return *this;
    }
    [[nodiscard]] constexpr _Storage_t&& _Storage() && noexcept { 
        return ::std:: move(*this);
    }
    [[nodiscard]] constexpr const _Storage_t&& _Storage() const&& noexcept { 
        return ::std:: move(*this);
    }

    
    constexpr _Variant_base() noexcept : _Storage_t{}, _Which{_Invalid_index} {}

    template <size_t _Idx, class... _UTypes,
        enable_if_t<is_constructible_v<_Meta_at_c<variant<_Types...>, _Idx>, _UTypes...>, int> = 0>
    constexpr explicit _Variant_base(in_place_index_t<_Idx>, _UTypes&&... _Args) noexcept(
        is_nothrow_constructible_v<_Meta_at_c<variant<_Types...>, _Idx>, _UTypes...>)
        : _Storage_t(integral_constant<size_t, _Idx>{}, static_cast<_UTypes&&>(_Args)...),
          _Which{static_cast<_Index_t>(_Idx)} { 
    }

    [[nodiscard]] constexpr bool valueless_by_exception() const noexcept { 
        return _Which < 0;
    }
    [[nodiscard]] constexpr size_t index() const noexcept {
        
        return static_cast<size_t>(_Which);
    }
    constexpr void _Set_index(const size_t _Idx) noexcept {
        
        
        _Which = static_cast<_Index_t>(_Idx);
    }

    template <size_t _Idx>
    constexpr void _Destroy() noexcept {
        
        
        if constexpr (_Idx != variant_npos && !is_trivially_destructible_v<_Meta_at_c<variant<_Types...>, _Idx>>) {
            _Destroy_in_place(_Variant_raw_get<_Idx>(_Storage()));
        }
    }

    constexpr void _Destroy() noexcept { 
        if constexpr (!conjunction_v<is_trivially_destructible<_Types>...>) {
            _Variant_raw_visit(index(), _Storage(), [](auto _Ref) noexcept {
                if constexpr (decltype(_Ref)::_Idx != variant_npos) {
                    _Destroy_in_place(_Ref._Val);
                }
            });
        }
    }

    constexpr void _Reset() noexcept { 
        _Destroy();
        _Set_index(variant_npos);
    }

    template <size_t _Idx>
    constexpr void _Reset() noexcept {
        
        
        if constexpr (_Idx != variant_npos) {
            _Destroy<_Idx>();
            _Set_index(variant_npos);
        }
    }

    constexpr void _Construct_from(const _Variant_base& _That) noexcept(
        conjunction_v<is_nothrow_copy_constructible<_Types>...>) {
        
        
        _Variant_raw_visit(_That.index(), _That._Storage(), _Variant_construct_visitor<_Types...>{*this});
    }

    constexpr void _Construct_from(_Variant_base&& _That) noexcept(
        conjunction_v<is_nothrow_move_constructible<_Types>...>) {
        
        
        _Variant_raw_visit(_That.index(), ::std:: move(_That)._Storage(), _Variant_construct_visitor<_Types...>{*this});
    }

    constexpr void _Assign_from(const _Variant_base& _That) noexcept(
        conjunction_v<is_nothrow_copy_constructible<_Types>..., is_nothrow_copy_assignable<_Types>...>) {
        
        _Variant_raw_visit(_That.index(), _That._Storage(), _Variant_assign_visitor<_Types...>{*this});
    }

    constexpr void _Assign_from(_Variant_base&& _That) noexcept(
        conjunction_v<is_nothrow_move_constructible<_Types>..., is_nothrow_move_assignable<_Types>...>) {
        
        _Variant_raw_visit(_That.index(), ::std:: move(_That)._Storage(), _Variant_assign_visitor<_Types...>{*this});
    }
};

template <class... _Types>
struct _Variant_destroy_layer_ : _Variant_base<_Types...> { 
    using _Variant_base<_Types...>::_Variant_base;

    constexpr ~_Variant_destroy_layer_() noexcept { 
        this->_Destroy();
    }

    _Variant_destroy_layer_()                               = default;
    _Variant_destroy_layer_(const _Variant_destroy_layer_&) = default;
    _Variant_destroy_layer_(_Variant_destroy_layer_&&)      = default;
    _Variant_destroy_layer_& operator=(const _Variant_destroy_layer_&) = default;
    _Variant_destroy_layer_& operator=(_Variant_destroy_layer_&&) = default;
};

template <class... _Types>
using _Variant_destroy_layer = conditional_t<conjunction_v<is_trivially_destructible<_Types>...>,
    _Variant_base<_Types...>, _Variant_destroy_layer_<_Types...>>;


#pragma warning(push)
#pragma warning(disable : 4242) 
#pragma warning(disable : 4244) 
#pragma warning(disable : 4365) 
#pragma warning(disable : 5215) 
#line 942 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\variant"


template <size_t _Idx, class _TargetType>
auto _Construct_array(_TargetType(&&)[1]) -> _Meta_list<integral_constant<size_t, _Idx>, _TargetType>;

template <size_t _Idx, class _TargetType, class _InitializerType>
using _Variant_type_resolver = decltype(_Construct_array<_Idx, _TargetType>({::std:: declval<_InitializerType>()}));
#line 951 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\variant"

template <size_t _Idx, class _TargetType>
struct _Variant_init_single_overload {

    template <class _InitializerType>
    auto operator()(_TargetType, _InitializerType&&) -> _Variant_type_resolver<_Idx, _TargetType, _InitializerType>;


#line 961 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\variant"
};

template <class _Indices, class... _Types>
struct _Variant_init_overload_set_;

template <size_t... _Indices, class... _Types>
struct _Variant_init_overload_set_<index_sequence<_Indices...>, _Types...>
    : _Variant_init_single_overload<_Indices, _Types>... {
    using _Variant_init_single_overload<_Indices, _Types>::operator()...;
};

template <class... _Types>
using _Variant_init_overload_set = _Variant_init_overload_set_<index_sequence_for<_Types...>, _Types...>;

template <class Enable, class _Ty, class... _Types>
struct _Variant_init_helper {}; 

template <class _Ty, class... _Types>
struct _Variant_init_helper<
    void_t<decltype(_Variant_init_overload_set<_Types...>{}(::std:: declval<_Ty>(), ::std:: declval<_Ty>()))>, _Ty,
    _Types...> {
    
    
    using type = decltype(_Variant_init_overload_set<_Types...>{}(::std:: declval<_Ty>(), ::std:: declval<_Ty>()));
};

template <class _Ty, class... _Types> 
using _Variant_init_type = _Meta_front<_Meta_pop_front<typename _Variant_init_helper<void, _Ty, _Types...>::type>>;

template <class _Ty, class... _Types> 
using _Variant_init_index = _Meta_front<typename _Variant_init_helper<void, _Ty, _Types...>::type>;


#pragma warning(pop)
#line 997 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\variant"

template <class>
inline constexpr bool _Is_in_place_index_specialization = false;
template <size_t _Idx>
inline constexpr bool _Is_in_place_index_specialization<in_place_index_t<_Idx>> = true;

template <class... _Types>
class variant : private _SMF_control<_Variant_destroy_layer<_Types...>, _Types...> { 
public:
    static_assert(conjunction_v<is_object<_Types>..., negation<is_array<_Types>>..., is_destructible<_Types>...>,
        "variant<Types...> requires all of the Types to meet the Cpp17Destructible requirements "
        "N4828 [variant.variant]/2.");
    static_assert(sizeof...(_Types) > 0,
        "variant<> (with no template arguments) may not be instantiated (N4835 [variant.variant]/3).");
    using _Mybase = _SMF_control<_Variant_destroy_layer<_Types...>, _Types...>;

    template <class _First = _Meta_front<variant>, enable_if_t<is_default_constructible_v<_First>, int> = 0>
    constexpr variant() noexcept(is_nothrow_default_constructible_v<_First>)
        : _Mybase(in_place_index<0>) {} 

    template <class _Ty,
        enable_if_t<sizeof...(_Types) != 0 
                        && !is_same_v<_Remove_cvref_t<_Ty>, variant> 
                        && !_Is_specialization_v<_Remove_cvref_t<_Ty>, in_place_type_t> 
                        && !_Is_in_place_index_specialization<_Remove_cvref_t<_Ty>> 
                        && is_constructible_v<_Variant_init_type<_Ty, _Types...>, _Ty>, 
            int> = 0>
    constexpr variant(_Ty&& _Obj) noexcept(is_nothrow_constructible_v<_Variant_init_type<_Ty, _Types...>, _Ty>)
        : _Mybase(in_place_index<_Variant_init_index<_Ty, _Types...>::value>, static_cast<_Ty&&>(_Obj)) {
        
    }

    template <class _Ty, class... _UTypes, class _Idx = _Meta_find_unique_index<variant, _Ty>,
        enable_if_t<_Idx::value != _Meta_npos && is_constructible_v<_Ty, _UTypes...>, int> = 0>
    constexpr explicit variant(in_place_type_t<_Ty>, _UTypes&&... _Args) noexcept(
        is_nothrow_constructible_v<_Ty, _UTypes...>) 
        : _Mybase(in_place_index<_Idx::value>, static_cast<_UTypes&&>(_Args)...) {
        
    }
    template <class _Ty, class _Elem, class... _UTypes, class _Idx = _Meta_find_unique_index<variant, _Ty>,
        enable_if_t<_Idx::value != _Meta_npos && is_constructible_v<_Ty, initializer_list<_Elem>&, _UTypes...>, int> =
            0>
    constexpr explicit variant(in_place_type_t<_Ty>, initializer_list<_Elem> _Ilist, _UTypes&&... _Args) noexcept(
        is_nothrow_constructible_v<_Ty, initializer_list<_Elem>&, _UTypes...>) 
        : _Mybase(in_place_index<_Idx::value>, _Ilist, static_cast<_UTypes&&>(_Args)...) {
        
    }

    template <size_t _Idx, class... _UTypes,
        enable_if_t<is_constructible_v<_Meta_at_c<variant, _Idx>, _UTypes...>, int> = 0>
    constexpr explicit variant(in_place_index_t<_Idx>, _UTypes&&... _Args) noexcept(
        is_nothrow_constructible_v<_Meta_at_c<variant, _Idx>, _UTypes...>) 
        : _Mybase(in_place_index<_Idx>, static_cast<_UTypes&&>(_Args)...) {
        
    }
    template <size_t _Idx, class _Elem, class... _UTypes,
        enable_if_t<is_constructible_v<_Meta_at_c<variant, _Idx>, initializer_list<_Elem>&, _UTypes...>, int> = 0>
    constexpr explicit variant(in_place_index_t<_Idx>, initializer_list<_Elem> _Ilist, _UTypes&&... _Args) noexcept(
        is_constructible_v<_Meta_at_c<variant, _Idx>, initializer_list<_Elem>&, _UTypes...>) 
        : _Mybase(in_place_index<_Idx>, _Ilist, static_cast<_UTypes&&>(_Args)...) {
        
    }

    template <class _Ty, enable_if_t<!is_same_v<_Remove_cvref_t<_Ty>, variant> 
                                         && is_constructible_v<_Variant_init_type<_Ty, _Types...>, _Ty> 
                                         && is_assignable_v<_Variant_init_type<_Ty, _Types...>&, _Ty>, 
                             int> = 0>
    constexpr variant& operator=(_Ty&& _Obj) noexcept(
        is_nothrow_assignable_v<_Variant_init_type<_Ty, _Types...>&, _Ty>&&
            is_nothrow_constructible_v<_Variant_init_type<_Ty, _Types...>, _Ty>) {
        
        constexpr size_t _TargetIdx = _Variant_init_index<_Ty, _Types...>::value;
        if (index() == _TargetIdx) {
            auto& _Target = _Variant_raw_get<_TargetIdx>(_Storage());
            _Target       = static_cast<_Ty&&>(_Obj);
        } else {
            using _TargetTy = _Variant_init_type<_Ty, _Types...>;
            if constexpr (_Variant_should_directly_construct_v<_TargetTy, _Ty>) {
                this->_Reset();
                _Emplace_valueless<_TargetIdx>(static_cast<_Ty&&>(_Obj));
            } else {
                _TargetTy _Temp(static_cast<_Ty&&>(_Obj));
                this->_Reset();
                _Emplace_valueless<_TargetIdx>(::std:: move(_Temp));
            }
        }

        return *this;
    }

    using _Mybase::_Storage;

    template <class _Ty, class... _ArgTypes, size_t _Idx = _Meta_find_unique_index<variant, _Ty>::value,
        enable_if_t<_Idx != _Meta_npos && is_constructible_v<_Ty, _ArgTypes...>, int> = 0>
    constexpr _Ty& emplace(_ArgTypes&&... _Args) noexcept(
        is_nothrow_constructible_v<_Ty, _ArgTypes...>)  {
        
        this->_Reset();
        return _Emplace_valueless<_Idx>(static_cast<_ArgTypes&&>(_Args)...);
    }
    template <class _Ty, class _Elem, class... _ArgTypes, size_t _Idx = _Meta_find_unique_index<variant, _Ty>::value,
        enable_if_t<_Idx != _Meta_npos && is_constructible_v<_Ty, initializer_list<_Elem>&, _ArgTypes...>, int> = 0>
    constexpr _Ty& emplace(initializer_list<_Elem> _Ilist, _ArgTypes&&... _Args) noexcept(
        is_nothrow_constructible_v<_Ty, initializer_list<_Elem>&, _ArgTypes...>)  {
        
        this->_Reset();
        return _Emplace_valueless<_Idx>(_Ilist, static_cast<_ArgTypes&&>(_Args)...);
    }

    template <size_t _Idx, class... _ArgTypes,
        enable_if_t<is_constructible_v<_Meta_at_c<variant, _Idx>, _ArgTypes...>, int> = 0>
    constexpr _Meta_at_c<variant, _Idx>& emplace(_ArgTypes&&... _Args) noexcept(
        is_nothrow_constructible_v<_Meta_at_c<variant, _Idx>, _ArgTypes...>)  {
        
        this->_Reset();
        return _Emplace_valueless<_Idx>(static_cast<_ArgTypes&&>(_Args)...);
    }
    template <size_t _Idx, class _Elem, class... _ArgTypes,
        enable_if_t<is_constructible_v<_Meta_at_c<variant, _Idx>, initializer_list<_Elem>&, _ArgTypes...>, int> = 0>
    constexpr _Meta_at_c<variant, _Idx>& emplace(initializer_list<_Elem> _Ilist, _ArgTypes&&... _Args) noexcept(
        is_nothrow_constructible_v<_Meta_at_c<variant, _Idx>, initializer_list<_Elem>&,
            _ArgTypes...>)  {
        
        this->_Reset();
        return _Emplace_valueless<_Idx>(_Ilist, static_cast<_ArgTypes&&>(_Args)...);
    }

    using _Mybase::index;
    using _Mybase::valueless_by_exception;


    constexpr void swap(variant& _That) noexcept(
        conjunction_v<is_nothrow_move_constructible<_Types>..., is_nothrow_swappable<_Types>...>) {
        
        
        static_assert(conjunction_v<is_move_constructible<_Types>...>,
            "variant<Types...>::swap requires all of the Types... to be move constructible. (N4835 [variant.swap]/1)");
        static_assert(disjunction_v<negation<is_move_constructible<_Types>>..., conjunction<is_swappable<_Types>...>>,
            "variant<Types...>::swap requires all of the Types... to be swappable. (N4835 [variant.swap]/1)");
        if constexpr (conjunction_v<_Is_trivially_swappable<_Types>...>) {
            using _BaseTy = _Variant_base<_Types...>;
            ::std:: swap(static_cast<_BaseTy&>(*this), static_cast<_BaseTy&>(_That));
        } else if constexpr (sizeof...(_Types) < 32) {
            
            _Variant_raw_visit(index(), _Storage(),
                [this, &_That](auto _My_ref) noexcept(
                    conjunction_v<is_nothrow_move_constructible<_Types>..., is_nothrow_swappable<_Types>...>) {
                    _Variant_raw_visit(_That.index(), _That._Storage(),
                        [this, &_That, _My_ref](auto _That_ref) noexcept(
                            conjunction_v<is_nothrow_move_constructible<_Types>..., is_nothrow_swappable<_Types>...>) {
                            constexpr size_t _That_idx = decltype(_That_ref)::_Idx;


                            constexpr size_t _My_idx = decltype(_My_ref)::_Idx;
#line 1156 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\variant"
                            if constexpr (_My_idx == _That_idx) { 
                                if constexpr (_My_idx != variant_npos) { 
                                    _Swap_adl(_My_ref._Val, _That_ref._Val);
                                }
                            } else if constexpr (_My_idx == variant_npos) { 
                                this->_Emplace_valueless<_That_idx>(::std:: move(_That_ref._Val));
                                _That.template _Reset<_That_idx>();
                            } else if constexpr (_That_idx == variant_npos) { 
                                _That._Emplace_valueless<_My_idx>(::std:: move(_My_ref._Val));
                                this->template _Reset<_My_idx>();
                            } else { 


                                auto _Tmp = ::std:: move(_My_ref._Val);
#line 1173 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\variant"
                                this->template _Reset<_My_idx>();
                                this->_Emplace_valueless<_That_idx>(::std:: move(_That_ref._Val));
                                _That.template _Reset<_That_idx>();
                                _That._Emplace_valueless<_My_idx>(::std:: move(_Tmp));
                            }
                        });
                });
        } else {
            if (this->_Which == _That._Which) {
                _Variant_raw_visit(static_cast<size_t>(this->_Which), _That._Storage(),
                    [this](auto _Ref) noexcept(conjunction_v<is_nothrow_swappable<_Types>...>) {
                        constexpr size_t _Idx = decltype(_Ref)::_Idx;
                        if constexpr (_Idx != variant_npos) {
                            _Swap_adl(_Variant_raw_get<_Idx>(this->_Storage()), _Ref._Val);
                        }
                    });
            } else {
                variant _Tmp = ::std:: move(*this);
                this->_Emplace_from(::std:: move(_That));
                _That._Emplace_from(::std:: move(_Tmp));
            }
        }
    }


private:
    template <size_t _Idx, class... _ArgTypes>
    constexpr _Meta_at_c<variant, _Idx>& _Emplace_valueless(_ArgTypes&&... _Args) noexcept(
        is_nothrow_constructible_v<_Meta_at_c<variant, _Idx>, _ArgTypes...>) {
        
        ;
        _Construct_in_place(_Storage(), integral_constant<size_t, _Idx>{}, static_cast<_ArgTypes&&>(_Args)...);
        this->_Set_index(_Idx);
        return _Variant_raw_get<_Idx>(_Storage());
    }

    constexpr void _Emplace_from(variant&& _That) noexcept(conjunction_v<is_nothrow_move_constructible<_Types>...>) {
        
        this->_Reset();
        _Variant_raw_visit(_That.index(), _That._Storage(),
            [this](auto _Ref) noexcept(conjunction_v<is_nothrow_move_constructible<_Types>...>) {
                constexpr size_t _Idx = decltype(_Ref)::_Idx;
                if constexpr (_Idx != variant_npos) {
                    this->_Emplace_valueless<_Idx>(::std:: move(_Ref._Val));
                }
            });
    }
};

template <class _Ty, class... _Types>
[[nodiscard]] constexpr bool holds_alternative(
    const variant<_Types...>& _Var) noexcept { 
    constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
    static_assert(_Idx != _Meta_npos, "holds_alternative<T>(const variant<Types...>&) requires T to occur exactly "
                                      "once in Types. (N4835 [variant.get]/1)");
    return _Var.index() == _Idx;
}

template <size_t _Idx, class... _Types>
[[nodiscard]] constexpr decltype(auto) get(
    variant<_Types...>& _Var) { 
    static_assert(_Idx < sizeof...(_Types), "variant index out of bounds");
    if (_Var.index() == _Idx) {
        return _Variant_raw_get<_Idx>(_Var._Storage());
    }

    _Throw_bad_variant_access();
}
template <size_t _Idx, class... _Types>
[[nodiscard]] constexpr decltype(auto) get(
    variant<_Types...>&& _Var) { 
    static_assert(_Idx < sizeof...(_Types), "variant index out of bounds");
    if (_Var.index() == _Idx) {
        return _Variant_raw_get<_Idx>(::std:: move(_Var)._Storage());
    }

    _Throw_bad_variant_access();
}
template <size_t _Idx, class... _Types>
[[nodiscard]] constexpr decltype(auto) get(
    const variant<_Types...>& _Var) { 
    static_assert(_Idx < sizeof...(_Types), "variant index out of bounds");
    if (_Var.index() == _Idx) {
        return _Variant_raw_get<_Idx>(_Var._Storage());
    }

    _Throw_bad_variant_access();
}
template <size_t _Idx, class... _Types>
[[nodiscard]] constexpr decltype(auto) get(
    const variant<_Types...>&& _Var) { 
    static_assert(_Idx < sizeof...(_Types), "variant index out of bounds");
    if (_Var.index() == _Idx) {
        return _Variant_raw_get<_Idx>(::std:: move(_Var)._Storage());
    }

    _Throw_bad_variant_access();
}

template <class _Ty, class... _Types>
[[nodiscard]] constexpr decltype(auto) get(
    variant<_Types...>& _Var) { 
    constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
    static_assert(_Idx < sizeof...(_Types),
        "get<T>(variant<Types...>&) requires T to occur exactly once in Types. (N4835 [variant.get]/5)");
    return ::std:: get<_Idx>(_Var);
}
template <class _Ty, class... _Types>
[[nodiscard]] constexpr decltype(auto) get(
    variant<_Types...>&& _Var) { 
    constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
    static_assert(_Idx < sizeof...(_Types),
        "get<T>(variant<Types...>&&) requires T to occur exactly once in Types. (N4835 [variant.get]/5)");
    return ::std:: get<_Idx>(::std:: move(_Var));
}
template <class _Ty, class... _Types>
[[nodiscard]] constexpr decltype(auto) get(
    const variant<_Types...>& _Var) { 
    constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
    static_assert(_Idx < sizeof...(_Types),
        "get<T>(const variant<Types...>&) requires T to occur exactly once in Types. (N4835 [variant.get]/5)");
    return ::std:: get<_Idx>(_Var);
}
template <class _Ty, class... _Types>
[[nodiscard]] constexpr decltype(auto) get(
    const variant<_Types...>&& _Var) { 
    constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
    static_assert(_Idx < sizeof...(_Types),
        "get<T>(const variant<Types...>&&) requires T to occur exactly once in Types. (N4835 [variant.get]/5)");
    return ::std:: get<_Idx>(::std:: move(_Var));
}

template <size_t _Idx, class... _Types>
[[nodiscard]] constexpr auto get_if(
    variant<_Types...>* _Ptr) noexcept { 
    static_assert(_Idx < sizeof...(_Types), "variant index out of bounds");
    return _Ptr && _Ptr->index() == _Idx ? ::std:: addressof(_Variant_raw_get<_Idx>(_Ptr->_Storage())) : nullptr;
}
template <size_t _Idx, class... _Types>
[[nodiscard]] constexpr auto get_if(const variant<_Types...>*
        _Ptr) noexcept { 
    static_assert(_Idx < sizeof...(_Types), "variant index out of bounds");
    return _Ptr && _Ptr->index() == _Idx ? ::std:: addressof(_Variant_raw_get<_Idx>(_Ptr->_Storage())) : nullptr;
}

template <class _Ty, class... _Types>
[[nodiscard]] constexpr add_pointer_t<_Ty> get_if(
    variant<_Types...>* _Ptr) noexcept { 
    constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
    static_assert(_Idx != _Meta_npos,
        "get_if<T>(variant<Types...> *) requires T to occur exactly once in Types. (N4835 [variant.get]/9)");
    return ::std:: get_if<_Idx>(_Ptr);
}
template <class _Ty, class... _Types>
[[nodiscard]] constexpr add_pointer_t<const _Ty> get_if(
    const variant<_Types...>* _Ptr) noexcept { 
    constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
    static_assert(_Idx != _Meta_npos,
        "get_if<T>(const variant<Types...> *) requires T to occur exactly once in Types. (N4835 [variant.get]/9)");
    return ::std:: get_if<_Idx>(_Ptr);
}

template <class _Op, class _Result, class... _Types>
struct _Variant_relop_visitor2 { 
    const _Variant_storage<_Types...>& _Left;

    template <class _Ty, size_t _Idx>
    [[nodiscard]] constexpr _Result operator()(_Tagged<const _Ty&, _Idx> _Right) const
        noexcept(disjunction_v<bool_constant<_Idx == variant_npos>,
            is_nothrow_invocable_r<_Result, _Op, const _Ty&, const _Ty&>>) {
        
        
        if constexpr (_Idx != variant_npos) {
            return _Op{}(_Variant_raw_get<_Idx>(_Left), _Right._Val);
        } else { 
            return _Op{}(0, 0);
        }
    }
};

template <class... _Types>
[[nodiscard]] constexpr bool operator==(const variant<_Types...>& _Left, const variant<_Types...>& _Right) noexcept(
    conjunction_v<is_nothrow_invocable_r<bool, equal_to<>, const _Types&, const _Types&>...>)  {
    
    using _Visitor            = _Variant_relop_visitor2<equal_to<>, bool, _Types...>;
    const size_t _Right_index = _Right.index();
    return _Left.index() == _Right_index
        && _Variant_raw_visit(_Right_index, _Right._Storage(), _Visitor{_Left._Storage()});
}

template <class... _Types>
[[nodiscard]] constexpr bool operator!=(const variant<_Types...>& _Left, const variant<_Types...>& _Right) noexcept(
    conjunction_v<is_nothrow_invocable_r<bool, not_equal_to<>, const _Types&, const _Types&>...>)  {
    
    using _Visitor            = _Variant_relop_visitor2<not_equal_to<>, bool, _Types...>;
    const size_t _Right_index = _Right.index();
    return _Left.index() != _Right_index
        || _Variant_raw_visit(_Right_index, _Right._Storage(), _Visitor{_Left._Storage()});
}

template <class... _Types>
[[nodiscard]] constexpr bool operator<(const variant<_Types...>& _Left, const variant<_Types...>& _Right) noexcept(
    conjunction_v<is_nothrow_invocable_r<bool, less<>, const _Types&, const _Types&>...>)  {
    
    
    using _Visitor             = _Variant_relop_visitor2<less<>, bool, _Types...>;
    const size_t _Left_offset  = _Left.index() + 1;
    const size_t _Right_offset = _Right.index() + 1;
    return _Left_offset < _Right_offset
        || (_Left_offset == _Right_offset
            && _Variant_raw_visit(_Right_offset - 1, _Right._Storage(), _Visitor{_Left._Storage()}));
}

template <class... _Types>
[[nodiscard]] constexpr bool operator>(const variant<_Types...>& _Left, const variant<_Types...>& _Right) noexcept(
    conjunction_v<is_nothrow_invocable_r<bool, greater<>, const _Types&, const _Types&>...>)  {
    
    
    using _Visitor             = _Variant_relop_visitor2<greater<>, bool, _Types...>;
    const size_t _Left_offset  = _Left.index() + 1;
    const size_t _Right_offset = _Right.index() + 1;
    return _Left_offset > _Right_offset
        || (_Left_offset == _Right_offset
            && _Variant_raw_visit(_Right_offset - 1, _Right._Storage(), _Visitor{_Left._Storage()}));
}

template <class... _Types>
[[nodiscard]] constexpr bool operator<=(const variant<_Types...>& _Left, const variant<_Types...>& _Right) noexcept(
    conjunction_v<is_nothrow_invocable_r<bool, less_equal<>, const _Types&, const _Types&>...>)  {
    
    
    using _Visitor             = _Variant_relop_visitor2<less_equal<>, bool, _Types...>;
    const size_t _Left_offset  = _Left.index() + 1;
    const size_t _Right_offset = _Right.index() + 1;
    return _Left_offset < _Right_offset
        || (_Left_offset == _Right_offset
            && _Variant_raw_visit(_Right_offset - 1, _Right._Storage(), _Visitor{_Left._Storage()}));
}

template <class... _Types>
[[nodiscard]] constexpr bool operator>=(const variant<_Types...>& _Left, const variant<_Types...>& _Right) noexcept(
    conjunction_v<is_nothrow_invocable_r<bool, greater_equal<>, const _Types&, const _Types&>...>)  {
    
    
    using _Visitor             = _Variant_relop_visitor2<greater_equal<>, bool, _Types...>;
    const size_t _Left_offset  = _Left.index() + 1;
    const size_t _Right_offset = _Right.index() + 1;
    return _Left_offset > _Right_offset
        || (_Left_offset == _Right_offset
            && _Variant_raw_visit(_Right_offset - 1, _Right._Storage(), _Visitor{_Left._Storage()}));
}


template <class... _Types>
    requires (three_way_comparable<_Types> && ...)
[[nodiscard]] constexpr common_comparison_category_t<compare_three_way_result_t<_Types>...>
    operator<=>(const variant<_Types...>& _Left, const variant<_Types...>& _Right) noexcept(
        conjunction_v<is_nothrow_invocable_r<common_comparison_category_t<compare_three_way_result_t<_Types>...>,
            compare_three_way, const _Types&, const _Types&>...>)  {
    
    
    using _Visitor             = _Variant_relop_visitor2<compare_three_way,
        common_comparison_category_t<compare_three_way_result_t<_Types>...>, _Types...>;
    const size_t _Left_offset  = _Left.index() + 1;
    const size_t _Right_offset = _Right.index() + 1;
    const auto _Offset_order   = _Left_offset <=> _Right_offset;
    return _Offset_order != 0 ? _Offset_order
                              : _Variant_raw_visit(_Right_offset - 1, _Right._Storage(), _Visitor{_Left._Storage()});
}
#line 1447 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\variant"

template <class... _Variants>
inline constexpr size_t _Variant_total_states =
    (size_t{1} * ... * (variant_size_v<_Variants> + 1)); 

[[nodiscard]] constexpr size_t _Variant_visit_index1(const size_t _Acc) noexcept {
    return _Acc;
}
template <class _FirstTy, class... _RestTys>
[[nodiscard]] constexpr size_t _Variant_visit_index1(size_t _Acc, const _FirstTy& _First,
    const _RestTys&... _Rest) noexcept { 
                                         
    _Acc += (_First.index() + 1) * _Variant_total_states<_RestTys...>;
    return _Variant_visit_index1(_Acc, _Rest...);
}

template <class _Callable, class... _Types>
using _Variant_visit_result_t =
    decltype(::std:: invoke(::std:: declval<_Callable>(), _Variant_raw_get<0>(::std:: declval<_Types>()._Storage())...));

template <class>
struct _Variant_dispatcher;

template <size_t... _Is>
struct _Variant_dispatcher<index_sequence<_Is...>> {
    template <class _Ret, class _Callable, class... _Types, bool _Any_valueless = ((_Is == 0) || ...)>
    [[nodiscard]] static constexpr _Ret _Dispatch2(_Callable&& _Obj, _Types&&... _Args) {
        if constexpr (_Any_valueless) {
            ((void) _Args, ...); 
            _Throw_bad_variant_access();
        }

        else if constexpr (is_void_v<_Ret>) {
            static_cast<void>(::std:: invoke(
                static_cast<_Callable&&>(_Obj), _Variant_raw_get<_Is - 1>(static_cast<_Types&&>(_Args)._Storage())...));
        }
#line 1484 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\variant"
        else {
            return ::std:: invoke(
                static_cast<_Callable&&>(_Obj), _Variant_raw_get<_Is - 1>(static_cast<_Types&&>(_Args)._Storage())...);
        }
    }
};

template <class _Ret, class _Ordinals, class _Callable, class _Variants>
struct _Variant_dispatch_table; 

template <class _Ret, class... _Ordinals, class _Callable, class... _Variants>
struct _Variant_dispatch_table<_Ret, _Meta_list<_Ordinals...>, _Callable,
    _Meta_list<_Variants...>> { 
    using _Dispatch_t                     = _Ret (*)(_Callable&&, _Variants&&...);
    static constexpr _Dispatch_t _Array[] = {
        &_Variant_dispatcher<_Ordinals>::template _Dispatch2<_Ret, _Callable, _Variants...>...};
};

template <class _Callable, class _IndexSequence, class... _Variants>
struct _Variant_single_visit_result; 

template <class _Callable, size_t... _Idxs, class... _Variants>
struct _Variant_single_visit_result<_Callable, index_sequence<_Idxs...>,
    _Variants...> { 
                    
    using type = decltype(::std:: invoke(::std:: declval<_Callable>(),
        _Variant_raw_get<_Idxs == 0 ? 0 : _Idxs - 1>(::std:: declval<_Variants>()._Storage())...));
};

template <class _Callable, class _ListOfIndexVectors, class... _Variants>
struct _Variant_all_visit_results_same; 

template <class _Callable, class... _IndexVectors, class... _Variants>
struct _Variant_all_visit_results_same<_Callable, _Meta_list<_IndexVectors...>, _Variants...>
    : _All_same<typename _Variant_single_visit_result<_Callable, _IndexVectors,
          _Variants...>::type...>::type { 
                                          
};

template <class _To, class _Callable, class _ListOfIndexVectors, class... _Variants>
struct _Variant_all_visit_results_implicitly_convertible; 

template <class _To, class _Callable, class... _IndexVectors, class... _Variants>
struct _Variant_all_visit_results_implicitly_convertible<_To, _Callable, _Meta_list<_IndexVectors...>, _Variants...>
    : _Convertible_from_all<_To,
          typename _Variant_single_visit_result<_Callable, _IndexVectors, _Variants...>::type...>::type {
    
    
};

template <int _Strategy>
struct _Visit_strategy;

template <>
struct _Visit_strategy<-1> { 
                             
    template <class _Ret, class _ListOfIndexVectors, class _Callable, class... _Variants>
    static constexpr _Ret _Visit2(
        size_t _Idx, _Callable&& _Obj, _Variants&&... _Args) { 
        constexpr size_t _Size = _Variant_total_states<_Remove_cvref_t<_Variants>...>;
        static_assert(_Size > 256);
        constexpr auto& _Array =
            _Variant_dispatch_table<_Ret, _ListOfIndexVectors, _Callable, _Meta_list<_Variants...>>::_Array;
        return _Array[_Idx](static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...);
    }
};

template <>
struct _Visit_strategy<0> {
    template <class _Ret, class, class _Callable>
    static constexpr _Ret _Visit2(size_t, _Callable&& _Obj) { 
        if constexpr (is_void_v<_Ret>) {
            return static_cast<void>(static_cast<_Callable&&>(_Obj)());
        } else {
            return static_cast<_Callable&&>(_Obj)();
        }
    }
};


template <>
struct _Visit_strategy<1> {
    template <class _Ret, class _ListOfIndexVectors, class _Callable, class... _Variants>
    static constexpr _Ret _Visit2(
        size_t _Idx, _Callable&& _Obj, _Variants&&... _Args) { 
        constexpr size_t _Size = _Variant_total_states<_Remove_cvref_t<_Variants>...>; static_assert(_Size > (4) / 4 && _Size <= (4)); switch (_Idx) { case (0): if constexpr ((0) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 1): if constexpr ((0 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 2): if constexpr ((0 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 3): if constexpr ((0 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); default: __assume(false); };
    }
};

template <>
struct _Visit_strategy<2> {
    template <class _Ret, class _ListOfIndexVectors, class _Callable, class... _Variants>
    static constexpr _Ret _Visit2(
        size_t _Idx, _Callable&& _Obj, _Variants&&... _Args) { 
        constexpr size_t _Size = _Variant_total_states<_Remove_cvref_t<_Variants>...>; static_assert(_Size > (16) / 4 && _Size <= (16)); switch (_Idx) { case (0): if constexpr ((0) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 1): if constexpr ((0 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 2): if constexpr ((0 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 3): if constexpr ((0 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 4): if constexpr ((0 + 4) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 4)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 4 + 1): if constexpr ((0 + 4 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 4 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 4 + 2): if constexpr ((0 + 4 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 4 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 4 + 3): if constexpr ((0 + 4 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 4 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 8): if constexpr ((0 + 8) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 8)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 8 + 1): if constexpr ((0 + 8 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 8 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 8 + 2): if constexpr ((0 + 8 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 8 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 8 + 3): if constexpr ((0 + 8 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 8 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 12): if constexpr ((0 + 12) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 12)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 12 + 1): if constexpr ((0 + 12 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 12 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 12 + 2): if constexpr ((0 + 12 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 12 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 12 + 3): if constexpr ((0 + 12 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 12 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); default: __assume(false); };
    }
};

template <>
struct _Visit_strategy<3> {
    template <class _Ret, class _ListOfIndexVectors, class _Callable, class... _Variants>
    static constexpr _Ret _Visit2(
        size_t _Idx, _Callable&& _Obj, _Variants&&... _Args) { 
        constexpr size_t _Size = _Variant_total_states<_Remove_cvref_t<_Variants>...>; static_assert(_Size > (64) / 4 && _Size <= (64)); switch (_Idx) { case (0): if constexpr ((0) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 1): if constexpr ((0 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 2): if constexpr ((0 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 3): if constexpr ((0 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 4): if constexpr ((0 + 4) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 4)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 4 + 1): if constexpr ((0 + 4 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 4 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 4 + 2): if constexpr ((0 + 4 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 4 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 4 + 3): if constexpr ((0 + 4 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 4 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 8): if constexpr ((0 + 8) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 8)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 8 + 1): if constexpr ((0 + 8 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 8 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 8 + 2): if constexpr ((0 + 8 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 8 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 8 + 3): if constexpr ((0 + 8 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 8 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 12): if constexpr ((0 + 12) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 12)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 12 + 1): if constexpr ((0 + 12 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 12 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 12 + 2): if constexpr ((0 + 12 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 12 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 12 + 3): if constexpr ((0 + 12 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 12 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16): if constexpr ((0 + 16) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16 + 1): if constexpr ((0 + 16 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16 + 2): if constexpr ((0 + 16 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16 + 3): if constexpr ((0 + 16 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16 + 4): if constexpr ((0 + 16 + 4) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16 + 4)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16 + 4 + 1): if constexpr ((0 + 16 + 4 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16 + 4 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16 + 4 + 2): if constexpr ((0 + 16 + 4 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16 + 4 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16 + 4 + 3): if constexpr ((0 + 16 + 4 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16 + 4 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16 + 8): if constexpr ((0 + 16 + 8) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16 + 8)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16 + 8 + 1): if constexpr ((0 + 16 + 8 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16 + 8 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16 + 8 + 2): if constexpr ((0 + 16 + 8 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16 + 8 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16 + 8 + 3): if constexpr ((0 + 16 + 8 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16 + 8 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16 + 12): if constexpr ((0 + 16 + 12) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16 + 12)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16 + 12 + 1): if constexpr ((0 + 16 + 12 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16 + 12 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16 + 12 + 2): if constexpr ((0 + 16 + 12 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16 + 12 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16 + 12 + 3): if constexpr ((0 + 16 + 12 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16 + 12 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32): if constexpr ((0 + 32) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32 + 1): if constexpr ((0 + 32 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32 + 2): if constexpr ((0 + 32 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32 + 3): if constexpr ((0 + 32 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32 + 4): if constexpr ((0 + 32 + 4) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32 + 4)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32 + 4 + 1): if constexpr ((0 + 32 + 4 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32 + 4 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32 + 4 + 2): if constexpr ((0 + 32 + 4 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32 + 4 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32 + 4 + 3): if constexpr ((0 + 32 + 4 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32 + 4 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32 + 8): if constexpr ((0 + 32 + 8) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32 + 8)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32 + 8 + 1): if constexpr ((0 + 32 + 8 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32 + 8 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32 + 8 + 2): if constexpr ((0 + 32 + 8 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32 + 8 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32 + 8 + 3): if constexpr ((0 + 32 + 8 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32 + 8 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32 + 12): if constexpr ((0 + 32 + 12) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32 + 12)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32 + 12 + 1): if constexpr ((0 + 32 + 12 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32 + 12 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32 + 12 + 2): if constexpr ((0 + 32 + 12 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32 + 12 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32 + 12 + 3): if constexpr ((0 + 32 + 12 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32 + 12 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48): if constexpr ((0 + 48) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48 + 1): if constexpr ((0 + 48 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48 + 2): if constexpr ((0 + 48 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48 + 3): if constexpr ((0 + 48 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48 + 4): if constexpr ((0 + 48 + 4) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48 + 4)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48 + 4 + 1): if constexpr ((0 + 48 + 4 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48 + 4 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48 + 4 + 2): if constexpr ((0 + 48 + 4 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48 + 4 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48 + 4 + 3): if constexpr ((0 + 48 + 4 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48 + 4 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48 + 8): if constexpr ((0 + 48 + 8) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48 + 8)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48 + 8 + 1): if constexpr ((0 + 48 + 8 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48 + 8 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48 + 8 + 2): if constexpr ((0 + 48 + 8 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48 + 8 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48 + 8 + 3): if constexpr ((0 + 48 + 8 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48 + 8 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48 + 12): if constexpr ((0 + 48 + 12) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48 + 12)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48 + 12 + 1): if constexpr ((0 + 48 + 12 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48 + 12 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48 + 12 + 2): if constexpr ((0 + 48 + 12 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48 + 12 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48 + 12 + 3): if constexpr ((0 + 48 + 12 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48 + 12 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); default: __assume(false); };
    }
};

template <>
struct _Visit_strategy<4> {
    template <class _Ret, class _ListOfIndexVectors, class _Callable, class... _Variants>
    static constexpr _Ret _Visit2(
        size_t _Idx, _Callable&& _Obj, _Variants&&... _Args) { 
        constexpr size_t _Size = _Variant_total_states<_Remove_cvref_t<_Variants>...>; static_assert(_Size > (256) / 4 && _Size <= (256)); switch (_Idx) { case (0): if constexpr ((0) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 1): if constexpr ((0 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 2): if constexpr ((0 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 3): if constexpr ((0 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 4): if constexpr ((0 + 4) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 4)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 4 + 1): if constexpr ((0 + 4 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 4 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 4 + 2): if constexpr ((0 + 4 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 4 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 4 + 3): if constexpr ((0 + 4 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 4 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 8): if constexpr ((0 + 8) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 8)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 8 + 1): if constexpr ((0 + 8 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 8 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 8 + 2): if constexpr ((0 + 8 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 8 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 8 + 3): if constexpr ((0 + 8 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 8 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 12): if constexpr ((0 + 12) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 12)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 12 + 1): if constexpr ((0 + 12 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 12 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 12 + 2): if constexpr ((0 + 12 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 12 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 12 + 3): if constexpr ((0 + 12 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 12 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16): if constexpr ((0 + 16) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16 + 1): if constexpr ((0 + 16 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16 + 2): if constexpr ((0 + 16 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16 + 3): if constexpr ((0 + 16 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16 + 4): if constexpr ((0 + 16 + 4) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16 + 4)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16 + 4 + 1): if constexpr ((0 + 16 + 4 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16 + 4 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16 + 4 + 2): if constexpr ((0 + 16 + 4 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16 + 4 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16 + 4 + 3): if constexpr ((0 + 16 + 4 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16 + 4 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16 + 8): if constexpr ((0 + 16 + 8) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16 + 8)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16 + 8 + 1): if constexpr ((0 + 16 + 8 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16 + 8 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16 + 8 + 2): if constexpr ((0 + 16 + 8 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16 + 8 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16 + 8 + 3): if constexpr ((0 + 16 + 8 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16 + 8 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16 + 12): if constexpr ((0 + 16 + 12) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16 + 12)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16 + 12 + 1): if constexpr ((0 + 16 + 12 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16 + 12 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16 + 12 + 2): if constexpr ((0 + 16 + 12 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16 + 12 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 16 + 12 + 3): if constexpr ((0 + 16 + 12 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 16 + 12 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32): if constexpr ((0 + 32) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32 + 1): if constexpr ((0 + 32 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32 + 2): if constexpr ((0 + 32 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32 + 3): if constexpr ((0 + 32 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32 + 4): if constexpr ((0 + 32 + 4) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32 + 4)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32 + 4 + 1): if constexpr ((0 + 32 + 4 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32 + 4 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32 + 4 + 2): if constexpr ((0 + 32 + 4 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32 + 4 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32 + 4 + 3): if constexpr ((0 + 32 + 4 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32 + 4 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32 + 8): if constexpr ((0 + 32 + 8) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32 + 8)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32 + 8 + 1): if constexpr ((0 + 32 + 8 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32 + 8 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32 + 8 + 2): if constexpr ((0 + 32 + 8 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32 + 8 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32 + 8 + 3): if constexpr ((0 + 32 + 8 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32 + 8 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32 + 12): if constexpr ((0 + 32 + 12) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32 + 12)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32 + 12 + 1): if constexpr ((0 + 32 + 12 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32 + 12 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32 + 12 + 2): if constexpr ((0 + 32 + 12 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32 + 12 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 32 + 12 + 3): if constexpr ((0 + 32 + 12 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 32 + 12 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48): if constexpr ((0 + 48) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48 + 1): if constexpr ((0 + 48 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48 + 2): if constexpr ((0 + 48 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48 + 3): if constexpr ((0 + 48 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48 + 4): if constexpr ((0 + 48 + 4) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48 + 4)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48 + 4 + 1): if constexpr ((0 + 48 + 4 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48 + 4 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48 + 4 + 2): if constexpr ((0 + 48 + 4 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48 + 4 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48 + 4 + 3): if constexpr ((0 + 48 + 4 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48 + 4 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48 + 8): if constexpr ((0 + 48 + 8) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48 + 8)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48 + 8 + 1): if constexpr ((0 + 48 + 8 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48 + 8 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48 + 8 + 2): if constexpr ((0 + 48 + 8 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48 + 8 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48 + 8 + 3): if constexpr ((0 + 48 + 8 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48 + 8 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48 + 12): if constexpr ((0 + 48 + 12) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48 + 12)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48 + 12 + 1): if constexpr ((0 + 48 + 12 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48 + 12 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48 + 12 + 2): if constexpr ((0 + 48 + 12 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48 + 12 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 48 + 12 + 3): if constexpr ((0 + 48 + 12 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 48 + 12 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64): if constexpr ((0 + 64) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 1): if constexpr ((0 + 64 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 2): if constexpr ((0 + 64 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 3): if constexpr ((0 + 64 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 4): if constexpr ((0 + 64 + 4) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 4)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 4 + 1): if constexpr ((0 + 64 + 4 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 4 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 4 + 2): if constexpr ((0 + 64 + 4 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 4 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 4 + 3): if constexpr ((0 + 64 + 4 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 4 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 8): if constexpr ((0 + 64 + 8) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 8)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 8 + 1): if constexpr ((0 + 64 + 8 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 8 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 8 + 2): if constexpr ((0 + 64 + 8 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 8 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 8 + 3): if constexpr ((0 + 64 + 8 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 8 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 12): if constexpr ((0 + 64 + 12) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 12)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 12 + 1): if constexpr ((0 + 64 + 12 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 12 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 12 + 2): if constexpr ((0 + 64 + 12 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 12 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 12 + 3): if constexpr ((0 + 64 + 12 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 12 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 16): if constexpr ((0 + 64 + 16) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 16)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 16 + 1): if constexpr ((0 + 64 + 16 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 16 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 16 + 2): if constexpr ((0 + 64 + 16 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 16 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 16 + 3): if constexpr ((0 + 64 + 16 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 16 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 16 + 4): if constexpr ((0 + 64 + 16 + 4) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 16 + 4)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 16 + 4 + 1): if constexpr ((0 + 64 + 16 + 4 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 16 + 4 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 16 + 4 + 2): if constexpr ((0 + 64 + 16 + 4 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 16 + 4 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 16 + 4 + 3): if constexpr ((0 + 64 + 16 + 4 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 16 + 4 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 16 + 8): if constexpr ((0 + 64 + 16 + 8) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 16 + 8)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 16 + 8 + 1): if constexpr ((0 + 64 + 16 + 8 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 16 + 8 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 16 + 8 + 2): if constexpr ((0 + 64 + 16 + 8 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 16 + 8 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 16 + 8 + 3): if constexpr ((0 + 64 + 16 + 8 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 16 + 8 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 16 + 12): if constexpr ((0 + 64 + 16 + 12) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 16 + 12)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 16 + 12 + 1): if constexpr ((0 + 64 + 16 + 12 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 16 + 12 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 16 + 12 + 2): if constexpr ((0 + 64 + 16 + 12 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 16 + 12 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 16 + 12 + 3): if constexpr ((0 + 64 + 16 + 12 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 16 + 12 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 32): if constexpr ((0 + 64 + 32) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 32)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 32 + 1): if constexpr ((0 + 64 + 32 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 32 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 32 + 2): if constexpr ((0 + 64 + 32 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 32 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 32 + 3): if constexpr ((0 + 64 + 32 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 32 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 32 + 4): if constexpr ((0 + 64 + 32 + 4) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 32 + 4)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 32 + 4 + 1): if constexpr ((0 + 64 + 32 + 4 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 32 + 4 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 32 + 4 + 2): if constexpr ((0 + 64 + 32 + 4 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 32 + 4 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 32 + 4 + 3): if constexpr ((0 + 64 + 32 + 4 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 32 + 4 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 32 + 8): if constexpr ((0 + 64 + 32 + 8) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 32 + 8)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 32 + 8 + 1): if constexpr ((0 + 64 + 32 + 8 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 32 + 8 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 32 + 8 + 2): if constexpr ((0 + 64 + 32 + 8 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 32 + 8 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 32 + 8 + 3): if constexpr ((0 + 64 + 32 + 8 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 32 + 8 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 32 + 12): if constexpr ((0 + 64 + 32 + 12) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 32 + 12)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 32 + 12 + 1): if constexpr ((0 + 64 + 32 + 12 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 32 + 12 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 32 + 12 + 2): if constexpr ((0 + 64 + 32 + 12 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 32 + 12 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 32 + 12 + 3): if constexpr ((0 + 64 + 32 + 12 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 32 + 12 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 48): if constexpr ((0 + 64 + 48) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 48)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 48 + 1): if constexpr ((0 + 64 + 48 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 48 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 48 + 2): if constexpr ((0 + 64 + 48 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 48 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 48 + 3): if constexpr ((0 + 64 + 48 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 48 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 48 + 4): if constexpr ((0 + 64 + 48 + 4) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 48 + 4)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 48 + 4 + 1): if constexpr ((0 + 64 + 48 + 4 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 48 + 4 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 48 + 4 + 2): if constexpr ((0 + 64 + 48 + 4 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 48 + 4 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 48 + 4 + 3): if constexpr ((0 + 64 + 48 + 4 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 48 + 4 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 48 + 8): if constexpr ((0 + 64 + 48 + 8) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 48 + 8)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 48 + 8 + 1): if constexpr ((0 + 64 + 48 + 8 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 48 + 8 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 48 + 8 + 2): if constexpr ((0 + 64 + 48 + 8 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 48 + 8 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 48 + 8 + 3): if constexpr ((0 + 64 + 48 + 8 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 48 + 8 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 48 + 12): if constexpr ((0 + 64 + 48 + 12) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 48 + 12)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 48 + 12 + 1): if constexpr ((0 + 64 + 48 + 12 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 48 + 12 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 48 + 12 + 2): if constexpr ((0 + 64 + 48 + 12 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 48 + 12 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 64 + 48 + 12 + 3): if constexpr ((0 + 64 + 48 + 12 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 64 + 48 + 12 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128): if constexpr ((0 + 128) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 1): if constexpr ((0 + 128 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 2): if constexpr ((0 + 128 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 3): if constexpr ((0 + 128 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 4): if constexpr ((0 + 128 + 4) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 4)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 4 + 1): if constexpr ((0 + 128 + 4 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 4 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 4 + 2): if constexpr ((0 + 128 + 4 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 4 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 4 + 3): if constexpr ((0 + 128 + 4 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 4 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 8): if constexpr ((0 + 128 + 8) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 8)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 8 + 1): if constexpr ((0 + 128 + 8 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 8 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 8 + 2): if constexpr ((0 + 128 + 8 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 8 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 8 + 3): if constexpr ((0 + 128 + 8 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 8 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 12): if constexpr ((0 + 128 + 12) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 12)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 12 + 1): if constexpr ((0 + 128 + 12 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 12 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 12 + 2): if constexpr ((0 + 128 + 12 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 12 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 12 + 3): if constexpr ((0 + 128 + 12 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 12 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 16): if constexpr ((0 + 128 + 16) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 16)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 16 + 1): if constexpr ((0 + 128 + 16 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 16 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 16 + 2): if constexpr ((0 + 128 + 16 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 16 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 16 + 3): if constexpr ((0 + 128 + 16 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 16 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 16 + 4): if constexpr ((0 + 128 + 16 + 4) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 16 + 4)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 16 + 4 + 1): if constexpr ((0 + 128 + 16 + 4 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 16 + 4 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 16 + 4 + 2): if constexpr ((0 + 128 + 16 + 4 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 16 + 4 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 16 + 4 + 3): if constexpr ((0 + 128 + 16 + 4 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 16 + 4 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 16 + 8): if constexpr ((0 + 128 + 16 + 8) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 16 + 8)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 16 + 8 + 1): if constexpr ((0 + 128 + 16 + 8 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 16 + 8 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 16 + 8 + 2): if constexpr ((0 + 128 + 16 + 8 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 16 + 8 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 16 + 8 + 3): if constexpr ((0 + 128 + 16 + 8 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 16 + 8 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 16 + 12): if constexpr ((0 + 128 + 16 + 12) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 16 + 12)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 16 + 12 + 1): if constexpr ((0 + 128 + 16 + 12 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 16 + 12 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 16 + 12 + 2): if constexpr ((0 + 128 + 16 + 12 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 16 + 12 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 16 + 12 + 3): if constexpr ((0 + 128 + 16 + 12 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 16 + 12 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 32): if constexpr ((0 + 128 + 32) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 32)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 32 + 1): if constexpr ((0 + 128 + 32 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 32 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 32 + 2): if constexpr ((0 + 128 + 32 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 32 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 32 + 3): if constexpr ((0 + 128 + 32 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 32 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 32 + 4): if constexpr ((0 + 128 + 32 + 4) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 32 + 4)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 32 + 4 + 1): if constexpr ((0 + 128 + 32 + 4 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 32 + 4 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 32 + 4 + 2): if constexpr ((0 + 128 + 32 + 4 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 32 + 4 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 32 + 4 + 3): if constexpr ((0 + 128 + 32 + 4 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 32 + 4 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 32 + 8): if constexpr ((0 + 128 + 32 + 8) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 32 + 8)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 32 + 8 + 1): if constexpr ((0 + 128 + 32 + 8 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 32 + 8 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 32 + 8 + 2): if constexpr ((0 + 128 + 32 + 8 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 32 + 8 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 32 + 8 + 3): if constexpr ((0 + 128 + 32 + 8 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 32 + 8 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 32 + 12): if constexpr ((0 + 128 + 32 + 12) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 32 + 12)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 32 + 12 + 1): if constexpr ((0 + 128 + 32 + 12 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 32 + 12 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 32 + 12 + 2): if constexpr ((0 + 128 + 32 + 12 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 32 + 12 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 32 + 12 + 3): if constexpr ((0 + 128 + 32 + 12 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 32 + 12 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 48): if constexpr ((0 + 128 + 48) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 48)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 48 + 1): if constexpr ((0 + 128 + 48 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 48 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 48 + 2): if constexpr ((0 + 128 + 48 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 48 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 48 + 3): if constexpr ((0 + 128 + 48 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 48 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 48 + 4): if constexpr ((0 + 128 + 48 + 4) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 48 + 4)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 48 + 4 + 1): if constexpr ((0 + 128 + 48 + 4 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 48 + 4 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 48 + 4 + 2): if constexpr ((0 + 128 + 48 + 4 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 48 + 4 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 48 + 4 + 3): if constexpr ((0 + 128 + 48 + 4 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 48 + 4 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 48 + 8): if constexpr ((0 + 128 + 48 + 8) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 48 + 8)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 48 + 8 + 1): if constexpr ((0 + 128 + 48 + 8 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 48 + 8 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 48 + 8 + 2): if constexpr ((0 + 128 + 48 + 8 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 48 + 8 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 48 + 8 + 3): if constexpr ((0 + 128 + 48 + 8 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 48 + 8 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 48 + 12): if constexpr ((0 + 128 + 48 + 12) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 48 + 12)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 48 + 12 + 1): if constexpr ((0 + 128 + 48 + 12 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 48 + 12 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 48 + 12 + 2): if constexpr ((0 + 128 + 48 + 12 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 48 + 12 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 128 + 48 + 12 + 3): if constexpr ((0 + 128 + 48 + 12 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 128 + 48 + 12 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192): if constexpr ((0 + 192) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 1): if constexpr ((0 + 192 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 2): if constexpr ((0 + 192 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 3): if constexpr ((0 + 192 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 4): if constexpr ((0 + 192 + 4) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 4)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 4 + 1): if constexpr ((0 + 192 + 4 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 4 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 4 + 2): if constexpr ((0 + 192 + 4 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 4 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 4 + 3): if constexpr ((0 + 192 + 4 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 4 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 8): if constexpr ((0 + 192 + 8) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 8)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 8 + 1): if constexpr ((0 + 192 + 8 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 8 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 8 + 2): if constexpr ((0 + 192 + 8 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 8 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 8 + 3): if constexpr ((0 + 192 + 8 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 8 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 12): if constexpr ((0 + 192 + 12) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 12)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 12 + 1): if constexpr ((0 + 192 + 12 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 12 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 12 + 2): if constexpr ((0 + 192 + 12 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 12 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 12 + 3): if constexpr ((0 + 192 + 12 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 12 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 16): if constexpr ((0 + 192 + 16) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 16)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 16 + 1): if constexpr ((0 + 192 + 16 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 16 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 16 + 2): if constexpr ((0 + 192 + 16 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 16 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 16 + 3): if constexpr ((0 + 192 + 16 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 16 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 16 + 4): if constexpr ((0 + 192 + 16 + 4) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 16 + 4)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 16 + 4 + 1): if constexpr ((0 + 192 + 16 + 4 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 16 + 4 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 16 + 4 + 2): if constexpr ((0 + 192 + 16 + 4 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 16 + 4 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 16 + 4 + 3): if constexpr ((0 + 192 + 16 + 4 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 16 + 4 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 16 + 8): if constexpr ((0 + 192 + 16 + 8) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 16 + 8)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 16 + 8 + 1): if constexpr ((0 + 192 + 16 + 8 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 16 + 8 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 16 + 8 + 2): if constexpr ((0 + 192 + 16 + 8 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 16 + 8 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 16 + 8 + 3): if constexpr ((0 + 192 + 16 + 8 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 16 + 8 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 16 + 12): if constexpr ((0 + 192 + 16 + 12) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 16 + 12)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 16 + 12 + 1): if constexpr ((0 + 192 + 16 + 12 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 16 + 12 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 16 + 12 + 2): if constexpr ((0 + 192 + 16 + 12 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 16 + 12 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 16 + 12 + 3): if constexpr ((0 + 192 + 16 + 12 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 16 + 12 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 32): if constexpr ((0 + 192 + 32) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 32)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 32 + 1): if constexpr ((0 + 192 + 32 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 32 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 32 + 2): if constexpr ((0 + 192 + 32 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 32 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 32 + 3): if constexpr ((0 + 192 + 32 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 32 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 32 + 4): if constexpr ((0 + 192 + 32 + 4) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 32 + 4)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 32 + 4 + 1): if constexpr ((0 + 192 + 32 + 4 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 32 + 4 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 32 + 4 + 2): if constexpr ((0 + 192 + 32 + 4 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 32 + 4 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 32 + 4 + 3): if constexpr ((0 + 192 + 32 + 4 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 32 + 4 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 32 + 8): if constexpr ((0 + 192 + 32 + 8) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 32 + 8)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 32 + 8 + 1): if constexpr ((0 + 192 + 32 + 8 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 32 + 8 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 32 + 8 + 2): if constexpr ((0 + 192 + 32 + 8 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 32 + 8 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 32 + 8 + 3): if constexpr ((0 + 192 + 32 + 8 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 32 + 8 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 32 + 12): if constexpr ((0 + 192 + 32 + 12) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 32 + 12)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 32 + 12 + 1): if constexpr ((0 + 192 + 32 + 12 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 32 + 12 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 32 + 12 + 2): if constexpr ((0 + 192 + 32 + 12 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 32 + 12 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 32 + 12 + 3): if constexpr ((0 + 192 + 32 + 12 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 32 + 12 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 48): if constexpr ((0 + 192 + 48) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 48)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 48 + 1): if constexpr ((0 + 192 + 48 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 48 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 48 + 2): if constexpr ((0 + 192 + 48 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 48 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 48 + 3): if constexpr ((0 + 192 + 48 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 48 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 48 + 4): if constexpr ((0 + 192 + 48 + 4) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 48 + 4)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 48 + 4 + 1): if constexpr ((0 + 192 + 48 + 4 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 48 + 4 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 48 + 4 + 2): if constexpr ((0 + 192 + 48 + 4 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 48 + 4 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 48 + 4 + 3): if constexpr ((0 + 192 + 48 + 4 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 48 + 4 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 48 + 8): if constexpr ((0 + 192 + 48 + 8) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 48 + 8)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 48 + 8 + 1): if constexpr ((0 + 192 + 48 + 8 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 48 + 8 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 48 + 8 + 2): if constexpr ((0 + 192 + 48 + 8 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 48 + 8 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 48 + 8 + 3): if constexpr ((0 + 192 + 48 + 8 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 48 + 8 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 48 + 12): if constexpr ((0 + 192 + 48 + 12) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 48 + 12)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 48 + 12 + 1): if constexpr ((0 + 192 + 48 + 12 + 1) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 48 + 12 + 1)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 48 + 12 + 2): if constexpr ((0 + 192 + 48 + 12 + 2) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 48 + 12 + 2)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); case (0 + 192 + 48 + 12 + 3): if constexpr ((0 + 192 + 48 + 12 + 3) < _Size) { using _Indices = _Meta_at_c<_ListOfIndexVectors, (0 + 192 + 48 + 12 + 3)>; return _Variant_dispatcher<_Indices>::template _Dispatch2<_Ret, _Callable, _Variants...>( static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...); } __assume(false); default: __assume(false); };
    }
};


template <class... _Types>
variant<_Types...>& _As_variant_(variant<_Types...>&);
template <class... _Types>
const variant<_Types...>& _As_variant_(const variant<_Types...>&);
template <class... _Types>
variant<_Types...>&& _As_variant_(variant<_Types...>&&);
template <class... _Types>
const variant<_Types...>&& _As_variant_(const variant<_Types...>&&);
template <class _Ty>
using _As_variant = 
    decltype(_As_variant_(::std:: declval<_Ty>()));

template <size_t _Size, class _Ret, class _ListOfIndexVectors, class _Callable, class... _Variants>
constexpr _Ret _Visit_impl(_Callable&& _Obj, _Variants&&... _Args) {
    constexpr int _Strategy = _Size == 1   ? 0
                            : _Size <= 4   ? 1
                            : _Size <= 16  ? 2
                            : _Size <= 64  ? 3
                            : _Size <= 256 ? 4
                                           : -1;
    return _Visit_strategy<_Strategy>::template _Visit2<_Ret, _ListOfIndexVectors>(
        _Variant_visit_index1(0, static_cast<_As_variant<_Variants>&>(_Args)...), static_cast<_Callable&&>(_Obj),
        static_cast<_As_variant<_Variants>&&>(_Args)...);
}

template <class _Callable, class... _Variants, class = void_t<_As_variant<_Variants>...>>
constexpr _Variant_visit_result_t<_Callable, _As_variant<_Variants>...> visit(_Callable&& _Obj, _Variants&&... _Args) {
    
    constexpr auto _Size = _Variant_total_states<_Remove_cvref_t<_As_variant<_Variants>>...>;
    using _ListOfIndexLists =
        _Meta_list<_Meta_as_list<make_index_sequence<1 + variant_size_v<_Remove_cvref_t<_As_variant<_Variants>>>>>...>;
    using _ListOfIndexVectors =
        _Meta_transform<_Meta_quote<_Meta_as_integer_sequence>, _Meta_cartesian_product<_ListOfIndexLists>>;
    using _Ret = _Variant_visit_result_t<_Callable, _As_variant<_Variants>...>;
    static_assert(_Variant_all_visit_results_same<_Callable, _ListOfIndexVectors, _As_variant<_Variants>...>::value,
        "visit() requires the result of all potential invocations to have the same type and value category "
        "(N4835 [variant.visit]/2).");

    return _Visit_impl<_Size, _Ret, _ListOfIndexVectors>(
        static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...);
}


template <class _Ret, class _Callable, class... _Variants, class = void_t<_As_variant<_Variants>...>>
constexpr _Ret visit(_Callable&& _Obj, _Variants&&... _Args) {
    constexpr auto _Size = _Variant_total_states<_Remove_cvref_t<_As_variant<_Variants>>...>;
    using _ListOfIndexLists =
        _Meta_list<_Meta_as_list<make_index_sequence<1 + variant_size_v<_Remove_cvref_t<_As_variant<_Variants>>>>>...>;
    using _ListOfIndexVectors =
        _Meta_transform<_Meta_quote<_Meta_as_integer_sequence>, _Meta_cartesian_product<_ListOfIndexLists>>;
    if constexpr (!is_void_v<_Ret>) {
        static_assert(_Variant_all_visit_results_implicitly_convertible<_Ret, _Callable, _ListOfIndexVectors,
                          _As_variant<_Variants>...>::value,
            "visit<R>() requires the result of all potential invocations to be implicitly convertible to R "
            "(N4835 [variant.visit]/2).");
    }

    return _Visit_impl<_Size, _Ret, _ListOfIndexVectors>(
        static_cast<_Callable&&>(_Obj), static_cast<_Variants&&>(_Args)...);
}
#line 1681 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\variant"

[[nodiscard]] constexpr bool operator==(monostate, monostate) noexcept {
    return true;
}


[[nodiscard]] constexpr strong_ordering operator<=>(monostate, monostate) noexcept {
    return strong_ordering::equal;
}


#line 1707 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\variant"

template <class... _Types,
    enable_if_t<conjunction_v<is_move_constructible<_Types>..., is_swappable<_Types>...>, int> = 0>
constexpr void swap(variant<_Types...>& _Left, variant<_Types...>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
    _Left.swap(_Right);
}

struct _Variant_hash_visitor { 
    template <class _Ty, size_t _Idx>
    [[nodiscard]] size_t operator()(_Tagged<const _Ty&, _Idx> _Obj) const
        noexcept(disjunction_v<bool_constant<_Idx == variant_npos>,
            is_nothrow_invocable<hash<_Ty>, const _Ty&>>) { 
        if constexpr (_Idx == variant_npos) { 
            return 0;
        } else { 
            return hash<_Ty>{}(_Obj._Val);
        }
    }
};

template <class... _Types>
struct hash<variant<_Types...>> : _Conditionally_enabled_hash<variant<_Types...>,
                                      conjunction_v<is_default_constructible<hash<remove_const_t<_Types>>>...>> {
    [[nodiscard]] static size_t _Do_hash(const variant<_Types...>& _Var) noexcept(
        conjunction_v<_Is_nothrow_hashable<remove_const_t<_Types>>...>) {
        
        return _Variant_raw_visit(_Var.index(), _Var._Storage(), _Variant_hash_visitor{});
    }
};

template <>
struct hash<monostate> {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef monostate _Unnameable_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef size_t _Unnameable_result;

    [[nodiscard]] size_t operator()(monostate) const noexcept {
        return 1729; 
    }
};

}


#pragma warning(pop)
#pragma pack(pop)
#line 1760 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\variant"
#line 1761 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\variant"
#line 1762 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\variant"
#line 32 "all-std.cxx"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\version"


#pragma once


#line 11 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\version"
#line 33 "all-std.cxx"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory_resource"


#pragma once


#line 15 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory_resource"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mutex"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\thread"


#pragma once


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\process.h"


#pragma once


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_startup.h"


#pragma once


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\math.h"


#line 13 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_startup.h"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\vcruntime_startup.h"


#pragma once


#pragma warning(push)
#pragma warning(disable:   4514 4820 )

__pragma(pack(push, 8)) extern "C" {


typedef enum _crt_argv_mode
{
    _crt_argv_no_arguments,
    _crt_argv_unexpanded_arguments,
    _crt_argv_expanded_arguments,
} _crt_argv_mode;

typedef enum _crt_exit_return_mode
{
    _crt_exit_terminate_process,
    _crt_exit_return_to_caller
} _crt_exit_return_mode;

typedef enum _crt_exit_cleanup_mode
{
    _crt_exit_full_cleanup,
    _crt_exit_quick_cleanup,
    _crt_exit_no_cleanup
} _crt_exit_cleanup_mode;

extern _crt_exit_return_mode __current_exit_return_mode;


__vcrt_bool __cdecl __vcrt_initialize(void);
__vcrt_bool __cdecl __vcrt_uninitialize(  __vcrt_bool _Terminating);
__vcrt_bool __cdecl __vcrt_uninitialize_critical(void);
__vcrt_bool __cdecl __vcrt_thread_attach(void);
__vcrt_bool __cdecl __vcrt_thread_detach(void);

int __cdecl __isa_available_init(void);
_crt_argv_mode __cdecl _get_startup_argv_mode(void);


} __pragma(pack(pop))

#pragma warning(pop) 
#line 14 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_startup.h"

#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


struct _EXCEPTION_POINTERS;

 int __cdecl _seh_filter_dll(
      unsigned long               _ExceptionNum,
      struct _EXCEPTION_POINTERS* _ExceptionPtr
    );

 int __cdecl _seh_filter_exe(
      unsigned long               _ExceptionNum,
      struct _EXCEPTION_POINTERS* _ExceptionPtr
    );


typedef enum _crt_app_type
{
    _crt_unknown_app,
    _crt_console_app,
    _crt_gui_app
} _crt_app_type;

 _crt_app_type __cdecl _query_app_type(void);

 void __cdecl _set_app_type(
      _crt_app_type _Type
    );

typedef int (__cdecl *_UserMathErrorFunctionPointer)(struct _exception *);

 void __cdecl __setusermatherr(
    _UserMathErrorFunctionPointer _UserMathErrorFunction
    );

int __cdecl _is_c_termination_complete(void);


 errno_t __cdecl _configure_narrow_argv(
      _crt_argv_mode mode
    );

 errno_t __cdecl _configure_wide_argv(
      _crt_argv_mode mode
    );


int __cdecl _initialize_narrow_environment(void);
int __cdecl _initialize_wide_environment(void);

 char**    __cdecl _get_initial_narrow_environment(void);
 wchar_t** __cdecl _get_initial_wide_environment(void);

char*    __cdecl _get_narrow_winmain_command_line(void);
wchar_t* __cdecl _get_wide_winmain_command_line(void);

 char**    __cdecl __p__acmdln(void);
 wchar_t** __cdecl __p__wcmdln(void);


#line 104 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_startup.h"


typedef void (__cdecl* _PVFV)(void);
typedef int  (__cdecl* _PIFV)(void);
typedef void (__cdecl* _PVFI)(int);


     void __cdecl _initterm(
            _PVFV*  _First,
                                     _PVFV*  _Last
        );

     int  __cdecl _initterm_e(
               _PIFV*  _First,
                                     _PIFV*  _Last
        );
#line 127 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_startup.h"


typedef struct _onexit_table_t
{
    _PVFV* _first;
    _PVFV* _last;
    _PVFV* _end;
} _onexit_table_t;

 int __cdecl _initialize_onexit_table(
      _onexit_table_t* _Table
    );

 int __cdecl _register_onexit_function(
      _onexit_table_t* _Table,
      _onexit_t        _Function
    );

 int __cdecl _execute_onexit_table(
      _onexit_table_t* _Table
    );

 int __cdecl _crt_atexit(
      _PVFV _Function
    );

 int __cdecl _crt_at_quick_exit(
      _PVFV _Function
    );


    __crt_bool __cdecl __acrt_initialize(void);

     
    __crt_bool __cdecl __acrt_uninitialize(
          __crt_bool _Terminating
        );

     
    __crt_bool __cdecl __acrt_uninitialize_critical(
          __crt_bool _Terminating
        );

     
    __crt_bool __cdecl __acrt_thread_attach(void);

     
    __crt_bool __cdecl __acrt_thread_detach(void);

#line 194 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\corecrt_startup.h"


} __pragma(pack(pop))

#pragma warning(pop) 
#line 15 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\process.h"


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


     __declspec(noreturn) void __cdecl exit(  int _Code);
     __declspec(noreturn) void __cdecl _exit(  int _Code);
     __declspec(noreturn) void __cdecl _Exit(  int _Code);
     __declspec(noreturn) void __cdecl quick_exit(  int _Code);
     __declspec(noreturn) void __cdecl abort(void);

     int __cdecl system(  char const* _Command);

     void __cdecl _cexit(void);
     void __cdecl _c_exit(void);

    typedef void (__stdcall *_tls_callback_type)(void *, unsigned long, void *);
     void __cdecl _register_thread_local_exe_atexit_callback(  _tls_callback_type _Callback);

#line 57 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\process.h"


typedef void     (__cdecl*   _beginthread_proc_type  )(void*);
typedef unsigned (__stdcall* _beginthreadex_proc_type)(void*);

 uintptr_t __cdecl _beginthread(
          _beginthread_proc_type _StartAddress,
          unsigned               _StackSize,
      void*                  _ArgList
    );

 void __cdecl _endthread(void);

 
 uintptr_t __cdecl _beginthreadex(
       void*                    _Security,
           unsigned                 _StackSize,
           _beginthreadex_proc_type _StartAddress,
       void*                    _ArgList,
           unsigned                 _InitFlag,
      unsigned*                _ThrdAddr
    );

 void __cdecl _endthreadex(
      unsigned _ReturnCode
    );


     int __cdecl _getpid(void);

     intptr_t __cdecl _cwait(
          int*     _TermStat,
               intptr_t _ProcHandle,
               int      _Action
        );

     intptr_t __cdecl _execl(
          char const* _FileName,
          char const* _Arguments,
        ...);

     intptr_t __cdecl _execle(
          char const* _FileName,
          char const* _Arguments,
        ...);

     intptr_t __cdecl _execlp(
          char const* _FileName,
          char const* _Arguments,
        ...);

     intptr_t __cdecl _execlpe(
          char const* _FileName,
          char const* _Arguments,
        ...);

     intptr_t __cdecl _execv(
          char const*        _FileName,
          char const* const* _Arguments
        );

     intptr_t __cdecl _execve(
              char const*        _FileName,
              char const* const* _Arguments,
          char const* const* _Environment
        );

     intptr_t __cdecl _execvp(
          char const*        _FileName,
          char const* const* _Arguments
        );

     intptr_t __cdecl _execvpe(
              char const*        _FileName,
              char const* const* _Arguments,
          char const* const* _Environment
        );

     intptr_t __cdecl _spawnl(
            int         _Mode,
          char const* _FileName,
          char const* _Arguments,
        ...);

     intptr_t __cdecl _spawnle(
            int         _Mode,
          char const* _FileName,
          char const* _Arguments,
        ...);

     intptr_t __cdecl _spawnlp(
            int         _Mode,
          char const* _FileName,
          char const* _Arguments,
        ...);

     intptr_t __cdecl _spawnlpe(
            int         _Mode,
          char const* _FileName,
          char const* _Arguments,
        ...);

     intptr_t __cdecl _spawnv(
            int                _Mode,
          char const*        _FileName,
          char const* const* _Arguments
        );

     intptr_t __cdecl _spawnve(
                int                _Mode,
              char const*        _FileName,
              char const* const* _Arguments,
          char const* const* _Environment
        );

     intptr_t __cdecl _spawnvp(
            int                _Mode,
          char const*        _FileName,
          char const* const* _Arguments
        );

     intptr_t __cdecl _spawnvpe(
                int                _Mode,
              char const*        _FileName,
              char const* const* _Arguments,
          char const* const* _Environment
        );

    __declspec(deprecated("This function or variable has been superceded by newer library " "or operating system functionality. Consider using " "LoadLibrary" " " "instead. See online help for details."))
     intptr_t __cdecl _loaddll(
          char* _FileName
        );

    __declspec(deprecated("This function or variable has been superceded by newer library " "or operating system functionality. Consider using " "FreeLibrary" " " "instead. See online help for details."))
     int __cdecl _unloaddll(
          intptr_t _Handle
        );

    typedef int (__cdecl* _GetDllProcAddrProcType)(void);

    __declspec(deprecated("This function or variable has been superceded by newer library " "or operating system functionality. Consider using " "GetProcAddress" " " "instead. See online help for details."))
     _GetDllProcAddrProcType __cdecl _getdllprocaddr(
                intptr_t _Handle,
          char*    _ProcedureName,
                intptr_t _Ordinal
        );

#line 233 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\process.h"


        __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_cwait" ". See online help for details."))
         intptr_t __cdecl cwait(
              int*     _TermStat,
                   intptr_t _ProcHandle,
                   int      _Action
            );

        __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_execl" ". See online help for details."))
         intptr_t __cdecl execl(
              char const* _FileName,
              char const* _Arguments,
            ...);

        __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_execle" ". See online help for details."))
         intptr_t __cdecl execle(
              char const* _FileName,
              char const* _Arguments,
            ...);

        __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_execlp" ". See online help for details."))
         intptr_t __cdecl execlp(
              char const* _FileName,
              char const* _Arguments,
            ...);

        __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_execlpe" ". See online help for details."))
         intptr_t __cdecl execlpe(
              char const* _FileName,
              char const* _Arguments,
            ...);

        __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_execv" ". See online help for details."))
         intptr_t __cdecl execv(
              char const*        _FileName,
              char const* const* _Arguments
            );

        __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_execve" ". See online help for details."))
         intptr_t __cdecl execve(
                  char const*        _FileName,
                  char const* const* _Arguments,
              char const* const* _Environment
            );

        __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_execvp" ". See online help for details."))
         intptr_t __cdecl execvp(
              char const*        _FileName,
              char const* const* _Arguments
            );

        __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_execvpe" ". See online help for details."))
         intptr_t __cdecl execvpe(
                  char const*        _FileName,
                  char const* const* _Arguments,
              char const* const* _Environment
            );

        __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_spawnl" ". See online help for details."))
         intptr_t __cdecl spawnl(
                int         _Mode,
              char const* _FileName,
              char const* _Arguments,
            ...);

        __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_spawnle" ". See online help for details."))
         intptr_t __cdecl spawnle(
                int         _Mode,
              char const* _FileName,
              char const* _Arguments,
            ...);

        __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_spawnlp" ". See online help for details."))
         intptr_t __cdecl spawnlp(
                int         _Mode,
              char const* _FileName,
              char const* _Arguments,
            ...);

        __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_spawnlpe" ". See online help for details."))
         intptr_t __cdecl spawnlpe(
                int         _Mode,
              char const* _FileName,
              char const* _Arguments,
            ...);

        __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_spawnv" ". See online help for details."))
         intptr_t __cdecl spawnv(
                int                _Mode,
              char const*        _FileName,
              char const* const* _Arguments);

        __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_spawnve" ". See online help for details."))
         intptr_t __cdecl spawnve(
                    int                _Mode,
                  char const*        _FileName,
                  char const* const* _Arguments,
              char const* const* _Environment
            );

        __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_spawnvp" ". See online help for details."))
         intptr_t __cdecl spawnvp(
                int                _Mode,
              char const*        _FileName,
              char const* const* _Arguments
            );

        __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_spawnvpe" ". See online help for details."))
         intptr_t __cdecl spawnvpe(
                    int                _Mode,
                  char const*        _FileName,
                  char const* const* _Arguments,
              char const* const* _Environment
            );

        __declspec(deprecated("The POSIX name for this item is deprecated. Instead, use the ISO C " "and C++ conformant name: " "_getpid" ". See online help for details."))
         int __cdecl getpid(void);

    #line 367 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\process.h"

#line 369 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\process.h"


} __pragma(pack(pop))

#pragma warning(pop) 
#line 376 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\process.h"
#line 14 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\thread"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stop_token"


#pragma once


#line 15 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stop_token"


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
struct nostopstate_t {
    explicit nostopstate_t() = default;
};

inline constexpr nostopstate_t nostopstate{};

struct _Stop_state;
class stop_token;

class _Stop_callback_base {
    friend _Stop_state;

private:
    using _Callback_fn = void(__cdecl*)(_Stop_callback_base*) noexcept;

public:
    explicit _Stop_callback_base(const _Callback_fn _Fn_) noexcept : _Fn{_Fn_} {}

    _Stop_callback_base(const _Stop_callback_base&) = delete;
    _Stop_callback_base& operator=(const _Stop_callback_base&) = delete;

protected:
    
    
    inline void _Attach(const stop_token& _Token) noexcept;
    inline void _Attach(stop_token&& _Token) noexcept;

    
    inline void _Detach() noexcept;

private:
    template <bool _Transfer_ownership>
    void _Do_attach(conditional_t<_Transfer_ownership, _Stop_state*&, _Stop_state* const> _State) noexcept;

protected:
    _Stop_state* _Parent       = nullptr;
    _Stop_callback_base* _Next = nullptr;
    _Stop_callback_base* _Prev = nullptr;
    _Callback_fn _Fn;
};

struct _Stop_state {
    atomic<uint32_t> _Stop_tokens  = 1; 
    atomic<uint32_t> _Stop_sources = 2; 
    _Locked_pointer<_Stop_callback_base> _Callbacks;
    
    
    atomic<const _Stop_callback_base*> _Current_callback = nullptr;
    _Thrd_id_t _Stopping_thread                          = 0;

    [[nodiscard]] bool _Stop_requested() const noexcept {
        return (_Stop_sources.load() & uint32_t{1}) != 0;
    }

    [[nodiscard]] bool _Stop_possible() const noexcept {
        return _Stop_sources.load() != 0;
    }

    [[nodiscard]] bool _Request_stop() noexcept {
        
        if ((_Stop_sources.fetch_or(uint32_t{1}) & uint32_t{1}) != 0) {
            
            return false;
        }

        _Stopping_thread = _Thrd_id();
        for (;;) {
            auto _Head = _Callbacks._Lock_and_load();
            _Current_callback.store(_Head, memory_order_relaxed);
            _Current_callback.notify_all();
            if (_Head == nullptr) {
                _Callbacks._Store_and_unlock(nullptr);
                return true;
            }

            const auto _Next = ::std:: exchange(_Head->_Next, nullptr);
            ;
            if (_Next != nullptr) {
                _Next->_Prev = nullptr;
            }

            _Callbacks._Store_and_unlock(_Next); 
                                                 

            _Head->_Fn(_Head); 
        }
    }
};

class stop_source;

class stop_token {
    friend stop_source;
    friend _Stop_callback_base;

public:
    stop_token() noexcept : _State{} {}
    stop_token(const stop_token& _Other) noexcept : _State{_Other._State} {
        const auto _Local = _State;
        if (_Local != nullptr) {
            _Local->_Stop_tokens.fetch_add(1, memory_order_relaxed);
        }
    }

    stop_token(stop_token&& _Other) noexcept : _State{::std:: exchange(_Other._State, nullptr)} {}
    stop_token& operator=(const stop_token& _Other) noexcept {
        stop_token{_Other}.swap(*this);
        return *this;
    }

    stop_token& operator=(stop_token&& _Other) noexcept {
        stop_token{::std:: move(_Other)}.swap(*this);
        return *this;
    }

    ~stop_token() {
        const auto _Local = _State;
        if (_Local != nullptr) {
            if (_Local->_Stop_tokens.fetch_sub(1, memory_order_acq_rel) == 1) {
                delete _Local;
            }
        }
    }

    void swap(stop_token& _Other) noexcept {
        ::std:: swap(_State, _Other._State);
    }

    [[nodiscard]] bool stop_requested() const noexcept {
        const auto _Local = _State;
        return _Local != nullptr && _Local->_Stop_requested();
    }

    [[nodiscard]] bool stop_possible() const noexcept {
        const auto _Local = _State;
        return _Local != nullptr && _Local->_Stop_possible();
    }

    [[nodiscard]] friend bool operator==(const stop_token& _Lhs, const stop_token& _Rhs) noexcept = default;

    friend void swap(stop_token& _Lhs, stop_token& _Rhs) noexcept {
        ::std:: swap(_Lhs._State, _Rhs._State);
    }

private:
    explicit stop_token(_Stop_state* const _State_) : _State{_State_} {}

    _Stop_state* _State;
};

class stop_source {
public:
    stop_source() : _State{new _Stop_state} {}
    explicit stop_source(nostopstate_t) noexcept : _State{} {}
    stop_source(const stop_source& _Other) noexcept : _State{_Other._State} {
        const auto _Local = _State;
        if (_Local != nullptr) {
            _Local->_Stop_sources.fetch_add(2, memory_order_relaxed);
        }
    }

    stop_source(stop_source&& _Other) noexcept : _State{::std:: exchange(_Other._State, nullptr)} {}
    stop_source& operator=(const stop_source& _Other) noexcept {
        stop_source{_Other}.swap(*this);
        return *this;
    }

    stop_source& operator=(stop_source&& _Other) noexcept {
        stop_source{::std:: move(_Other)}.swap(*this);
        return *this;
    }

    ~stop_source() {
        const auto _Local = _State;
        if (_Local != nullptr) {
            if ((_Local->_Stop_sources.fetch_sub(2, memory_order_acq_rel) >> 1) == 1) {
                if (_Local->_Stop_tokens.fetch_sub(1, memory_order_acq_rel) == 1) {
                    delete _Local;
                }
            }
        }
    }

    void swap(stop_source& _Other) noexcept {
        ::std:: swap(_State, _Other._State);
    }

    [[nodiscard]] stop_token get_token() const noexcept {
        const auto _Local = _State;
        if (_Local != nullptr) {
            _Local->_Stop_tokens.fetch_add(1, memory_order_relaxed);
        }

        return stop_token{_Local};
    }

    [[nodiscard]] bool stop_requested() const noexcept {
        const auto _Local = _State;
        return _Local != nullptr && _Local->_Stop_requested();
    }

    [[nodiscard]] bool stop_possible() const noexcept {
        return _State != nullptr;
    }

    bool request_stop() noexcept {
        const auto _Local = _State;
        return _Local && _Local->_Request_stop();
    }

    [[nodiscard]] friend bool operator==(const stop_source& _Lhs, const stop_source& _Rhs) noexcept = default;

    friend void swap(stop_source& _Lhs, stop_source& _Rhs) noexcept {
        ::std:: swap(_Lhs._State, _Rhs._State);
    }

private:
    _Stop_state* _State;
};

template <bool _Transfer_ownership>
void _Stop_callback_base::_Do_attach(
    conditional_t<_Transfer_ownership, _Stop_state*&, _Stop_state* const> _State_raw) noexcept {
    const auto _State = _State_raw; 
    if (_State == nullptr) {
        return;
    }

    
    auto _Local_sources = _State->_Stop_sources.load();
    if ((_Local_sources & uint32_t{1}) != 0) {
        
        _Fn(this);
        return;
    }

    if (_Local_sources == 0) {
        return; 
    }

    
    auto _Head = _State->_Callbacks._Lock_and_load();
    
    _Local_sources = _State->_Stop_sources.load();
    if ((_Local_sources & uint32_t{1}) != 0) {
        
        _State->_Callbacks._Store_and_unlock(_Head);
        _Fn(this);
        return;
    }

    if (_Local_sources != 0) {
        
        _Parent = _State;
        _Next   = _Head;
        if constexpr (_Transfer_ownership) {
            _State_raw = nullptr;
        } else {
            _State->_Stop_tokens.fetch_add(1, memory_order_relaxed);
        }

        if (_Head != nullptr) {
            _Head->_Prev = this;
        }

        _Head = this;
    }

    _State->_Callbacks._Store_and_unlock(_Head);
}

inline void _Stop_callback_base::_Attach(const stop_token& _Token) noexcept {
    this->_Do_attach<false>(_Token._State);
}

inline void _Stop_callback_base::_Attach(stop_token&& _Token) noexcept {
    this->_Do_attach<true>(_Token._State);
}

inline void _Stop_callback_base::_Detach() noexcept {
    stop_token _Token{_Parent}; 
    if (_Token._State == nullptr) {
        
        return;
    }

    auto _Head = _Token._State->_Callbacks._Lock_and_load();
    if (this == _Head) {
        
        const auto _Local_next = _Next;
        if (_Local_next != nullptr) {
            _Local_next->_Prev = nullptr;
        }

        ;
        _Token._State->_Callbacks._Store_and_unlock(_Next);
        return;
    }

    const auto _Local_prev = _Prev;
    if (_Local_prev != nullptr) {
        
        
        const auto _Local_next = _Next;
        if (_Local_next != nullptr) {
            _Next->_Prev = _Local_prev;
        }

        _Prev->_Next = _Local_next;
        _Token._State->_Callbacks._Store_and_unlock(_Head);
        return;
    }

    
    ;
    if (_Token._State->_Current_callback.load(memory_order_acquire) != this
        || _Token._State->_Stopping_thread == _Thrd_id()) {
        
        _Token._State->_Callbacks._Store_and_unlock(_Head);
        return;
    }

    
    _Token._State->_Callbacks._Store_and_unlock(_Head);
    _Token._State->_Current_callback.wait(this, memory_order_acquire);
}

template <class _Callback>
class stop_callback : public _Stop_callback_base {
public:
    using callback_type = _Callback;

    template <class _CbInitTy, enable_if_t<is_constructible_v<_Callback, _CbInitTy>, int> = 0>
    explicit stop_callback(const stop_token& _Token, _CbInitTy&& _Cb_) noexcept(
        is_nothrow_constructible_v<_Callback, _CbInitTy>)
        : _Stop_callback_base{_Invoke_by_stop}, _Cb(::std:: forward<_CbInitTy>(_Cb_)) {
        _Attach(_Token);
    }

    template <class _CbInitTy, enable_if_t<is_constructible_v<_Callback, _CbInitTy>, int> = 0>
    explicit stop_callback(stop_token&& _Token, _CbInitTy&& _Cb_) noexcept(
        is_nothrow_constructible_v<_Callback, _CbInitTy>)
        : _Stop_callback_base{_Invoke_by_stop}, _Cb(::std:: forward<_CbInitTy>(_Cb_)) {
        _Attach(::std:: move(_Token));
    }

    ~stop_callback() {
        _Detach();
    }

private:
    static void __cdecl _Invoke_by_stop(_Stop_callback_base* const _This) noexcept 
    {
        ::std:: forward<_Callback>(static_cast<stop_callback*>(_This)->_Cb)();
    }

    _Callback _Cb;
};

template <class _Callback>
stop_callback(stop_token, _Callback) -> stop_callback<_Callback>;

}


#pragma warning(pop)
#pragma pack(pop)
#line 397 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stop_token"
#line 398 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stop_token"
#line 399 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stop_token"
#line 19 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\thread"
#line 20 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\thread"


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {

class jthread;
#line 36 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\thread"

class thread { 
public:
    class id;

    using native_handle_type = void*;

    thread() noexcept : _Thr{} {}

private:

    friend jthread;
#line 49 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\thread"

    template <class _Tuple, size_t... _Indices>
    static unsigned int __stdcall _Invoke(void* _RawVals) noexcept  {
        
        const unique_ptr<_Tuple> _FnVals(static_cast<_Tuple*>(_RawVals));
        _Tuple& _Tup = *_FnVals;
        ::std:: invoke(::std:: move(::std:: get<_Indices>(_Tup))...);
        _Cnd_do_broadcast_at_thread_exit(); 
        return 0;
    }

    template <class _Tuple, size_t... _Indices>
    [[nodiscard]] static constexpr auto _Get_invoke(index_sequence<_Indices...>) noexcept {
        return &_Invoke<_Tuple, _Indices...>;
    }

    template <class _Fn, class... _Args>
    void _Start(_Fn&& _Fx, _Args&&... _Ax) {
        using _Tuple                 = tuple<decay_t<_Fn>, decay_t<_Args>...>;
        auto _Decay_copied           = ::std:: make_unique<_Tuple>(::std:: forward<_Fn>(_Fx), ::std:: forward<_Args>(_Ax)...);
        constexpr auto _Invoker_proc = _Get_invoke<_Tuple>(make_index_sequence<1 + sizeof...(_Args)>{});

#pragma warning(push)
#pragma warning(disable : 5039) 
                                
                                
        _Thr._Hnd =
            reinterpret_cast<void*>(:: _beginthreadex(nullptr, 0, _Invoker_proc, _Decay_copied.get(), 0, &_Thr._Id));
#pragma warning(pop)

        if (_Thr._Hnd) { 
            (void) _Decay_copied.release();
        } else { 
            _Thr._Id = 0;
            _Throw_Cpp_error(_RESOURCE_UNAVAILABLE_TRY_AGAIN);
        }
    }

public:
    template <class _Fn, class... _Args, enable_if_t<!is_same_v<_Remove_cvref_t<_Fn>, thread>, int> = 0>
    [[nodiscard]] explicit thread(_Fn&& _Fx, _Args&&... _Ax) {
        _Start(::std:: forward<_Fn>(_Fx), ::std:: forward<_Args>(_Ax)...);
    }

    ~thread() noexcept {
        if (joinable()) {
            ::std:: terminate();
        }
    }

    thread(thread&& _Other) noexcept : _Thr(::std:: exchange(_Other._Thr, {})) {}

    thread& operator=(thread&& _Other) noexcept {
        if (joinable()) {
            ::std:: terminate();
        }

        _Thr = ::std:: exchange(_Other._Thr, {});
        return *this;
    }

    thread(const thread&) = delete;
    thread& operator=(const thread&) = delete;

    void swap(thread& _Other) noexcept {
        ::std:: swap(_Thr, _Other._Thr);
    }

    [[nodiscard]] bool joinable() const noexcept {
        return _Thr._Id != 0;
    }

    void join() {
        if (!joinable()) {
            _Throw_Cpp_error(_INVALID_ARGUMENT);
        }

        if (_Thr._Id == _Thrd_id()) {
            _Throw_Cpp_error(_RESOURCE_DEADLOCK_WOULD_OCCUR);
        }

        if (_Thrd_join(_Thr, nullptr) != _Thrd_success) {
            _Throw_Cpp_error(_NO_SUCH_PROCESS);
        }

        _Thr = {};
    }

    void detach() {
        if (!joinable()) {
            _Throw_Cpp_error(_INVALID_ARGUMENT);
        }

        _Check_C_return(_Thrd_detach(_Thr));
        _Thr = {};
    }

    [[nodiscard]] id get_id() const noexcept;

    [[nodiscard]] native_handle_type native_handle() noexcept  { 
        return _Thr._Hnd;
    }

    [[nodiscard]] static unsigned int hardware_concurrency() noexcept {
        return _Thrd_hardware_concurrency();
    }

private:
    _Thrd_t _Thr;
};

template <class _Rep, class _Period>
[[nodiscard]] auto _To_absolute_time(const chrono::duration<_Rep, _Period>& _Rel_time) noexcept {
    constexpr auto _Zero                 = chrono::duration<_Rep, _Period>::zero();
    const auto _Now                      = chrono::steady_clock::now();
    decltype(_Now + _Rel_time) _Abs_time = _Now; 
    if (_Rel_time > _Zero) {
        constexpr auto _Forever = (chrono::steady_clock::time_point::max)();
        if (_Abs_time < _Forever - _Rel_time) {
            _Abs_time += _Rel_time;
        } else {
            _Abs_time = _Forever;
        }
    }
    return _Abs_time;
}

namespace this_thread {
    [[nodiscard]] thread::id get_id() noexcept;

    inline void yield() noexcept {
        _Thrd_yield();
    }

    inline void sleep_until(const xtime* _Abs_time) {
        _Thrd_sleep(_Abs_time);
    }

    template <class _Clock, class _Duration>
    void sleep_until(const chrono::time_point<_Clock, _Duration>& _Abs_time) {

        static_assert(chrono::is_clock_v<_Clock>, "Clock type required");
#line 192 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\thread"
        for (;;) {
            const auto _Now = _Clock::now();
            if (_Abs_time <= _Now) {
                return;
            }

            :: xtime _Tgt;
            (void) _To_xtime_10_day_clamped(_Tgt, _Abs_time - _Now);
            _Thrd_sleep(&_Tgt);
        }
    }

    template <class _Rep, class _Period>
    void sleep_for(const chrono::duration<_Rep, _Period>& _Rel_time) {
        sleep_until(_To_absolute_time(_Rel_time));
    }
} 

class thread::id { 
public:
    id() noexcept : _Id(0) {} 

private:
    id(_Thrd_id_t _Other_id) : _Id(_Other_id) {}

    _Thrd_id_t _Id;

    friend thread::id thread::get_id() const noexcept;
    friend thread::id this_thread::get_id() noexcept;
    friend bool operator==(thread::id _Left, thread::id _Right) noexcept;

    friend strong_ordering operator<=>(thread::id _Left, thread::id _Right) noexcept;


#line 227 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\thread"
    template <class _Ch, class _Tr>
    friend basic_ostream<_Ch, _Tr>& operator<<(basic_ostream<_Ch, _Tr>& _Str, thread::id _Id);
    friend hash<thread::id>;
};

[[nodiscard]] inline thread::id thread::get_id() const noexcept {
    return _Thr._Id;
}

[[nodiscard]] inline thread::id this_thread::get_id() noexcept {
    return _Thrd_id();
}

inline void swap(thread& _Left, thread& _Right) noexcept {
    _Left.swap(_Right);
}

[[nodiscard]] inline bool operator==(thread::id _Left, thread::id _Right) noexcept {
    return _Left._Id == _Right._Id;
}


[[nodiscard]] inline strong_ordering operator<=>(thread::id _Left, thread::id _Right) noexcept {
    return _Left._Id <=> _Right._Id;
}


#line 273 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\thread"

template <class _Ch, class _Tr>
basic_ostream<_Ch, _Tr>& operator<<(basic_ostream<_Ch, _Tr>& _Str, thread::id _Id) {
    return _Str << _Id._Id;
}

template <>
struct hash<thread::id> {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef thread::id _Unnameable_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef size_t _Unnameable_result;

    [[nodiscard]] size_t operator()(const thread::id _Keyval) const noexcept {
        return _Hash_representation(_Keyval._Id);
    }
};


class jthread {
public:
    using id                 = thread::id;
    using native_handle_type = thread::native_handle_type;

    jthread() noexcept : _Impl{}, _Ssource{nostopstate} {}

    template <class _Fn, class... _Args, enable_if_t<!is_same_v<remove_cvref_t<_Fn>, jthread>, int> = 0>
    [[nodiscard]] explicit jthread(_Fn&& _Fx, _Args&&... _Ax) {
        if constexpr (is_invocable_v<decay_t<_Fn>, stop_token, decay_t<_Args>...>) {
            _Impl._Start(::std:: forward<_Fn>(_Fx), _Ssource.get_token(), ::std:: forward<_Args>(_Ax)...);
        } else {
            _Impl._Start(::std:: forward<_Fn>(_Fx), ::std:: forward<_Args>(_Ax)...);
        }
    }

    ~jthread() {
        _Try_cancel_and_join();
    }

    jthread(const jthread&)     = delete;
    jthread(jthread&&) noexcept = default;
    jthread& operator=(const jthread&) = delete;

    jthread& operator=(jthread&& _Other) noexcept {
        
        
        _Try_cancel_and_join();
        _Impl    = ::std:: move(_Other._Impl);
        _Ssource = ::std:: move(_Other._Ssource);
        return *this;
    }

    void swap(jthread& _Other) noexcept {
        _Impl.swap(_Other._Impl);
        _Ssource.swap(_Other._Ssource);
    }

    [[nodiscard]] bool joinable() const noexcept {
        return _Impl.joinable();
    }

    void join() {
        _Impl.join();
    }

    void detach() {
        _Impl.detach();
    }

    [[nodiscard]] id get_id() const noexcept {
        return _Impl.get_id();
    }

    [[nodiscard]] native_handle_type native_handle() noexcept  {
        return _Impl.native_handle();
    }

    [[nodiscard]] stop_source get_stop_source() noexcept {
        return _Ssource;
    }

    [[nodiscard]] stop_token get_stop_token() const noexcept {
        return _Ssource.get_token();
    }

    bool request_stop() noexcept {
        return _Ssource.request_stop();
    }

    friend void swap(jthread& _Lhs, jthread& _Rhs) noexcept {
        _Lhs.swap(_Rhs);
    }

    [[nodiscard]] static unsigned int hardware_concurrency() noexcept {
        return thread::hardware_concurrency();
    }

private:
    void _Try_cancel_and_join() noexcept {
        if (_Impl.joinable()) {
            _Ssource.request_stop();
            _Impl.join();
        }
    }

    thread _Impl;
    stop_source _Ssource;
};
#line 382 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\thread"
}


#pragma warning(pop)
#pragma pack(pop)
#line 389 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\thread"
#line 390 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\thread"
#line 20 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mutex"


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {


class condition_variable;
class condition_variable_any;

class _Mutex_base { 
public:
    _Mutex_base(int _Flags = 0) noexcept {
        _Mtx_init_in_situ(_Mymtx(), _Flags | _Mtx_try);
    }

    ~_Mutex_base() noexcept {
        _Mtx_destroy_in_situ(_Mymtx());
    }

    _Mutex_base(const _Mutex_base&) = delete;
    _Mutex_base& operator=(const _Mutex_base&) = delete;

    void lock() {
        _Check_C_return(_Mtx_lock(_Mymtx()));
    }

    [[nodiscard]] bool try_lock() {
        const auto _Res = _Mtx_trylock(_Mymtx());
        switch (_Res) {
        case _Thrd_success:
            return true;
        case _Thrd_busy:
            return false;
        default:
            _Throw_C_error(_Res);
        }
    }

    void unlock() {
        _Mtx_unlock(_Mymtx());
    }

    using native_handle_type = void*;

    [[nodiscard]] native_handle_type native_handle() {
        return _Mtx_getconcrtcs(_Mymtx());
    }

private:
    friend condition_variable;
    friend condition_variable_any;

    aligned_storage_t<_Mtx_internal_imp_size, _Mtx_internal_imp_alignment> _Mtx_storage;

    _Mtx_t _Mymtx() noexcept { 
        return reinterpret_cast<_Mtx_t>(&_Mtx_storage);
    }
};

class mutex : public _Mutex_base { 
public:
     mutex() noexcept 
        : _Mutex_base() {}

    mutex(const mutex&) = delete;
    mutex& operator=(const mutex&) = delete;
};

class recursive_mutex : public _Mutex_base { 
public:
    recursive_mutex() : _Mutex_base(_Mtx_recursive) {}

    [[nodiscard]] bool try_lock() noexcept {
        return _Mutex_base::try_lock();
    }

    recursive_mutex(const recursive_mutex&) = delete;
    recursive_mutex& operator=(const recursive_mutex&) = delete;
};
#line 107 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mutex"

struct adopt_lock_t { 
    explicit adopt_lock_t() = default;
};

struct defer_lock_t { 
    explicit defer_lock_t() = default;
};

struct try_to_lock_t { 
    explicit try_to_lock_t() = default;
};

inline constexpr adopt_lock_t adopt_lock{};
inline constexpr defer_lock_t defer_lock{};
inline constexpr try_to_lock_t try_to_lock{};

template <class _Mutex>
class unique_lock { 
public:
    using mutex_type = _Mutex;

    unique_lock() noexcept : _Pmtx(nullptr), _Owns(false) {}

    [[nodiscard]] explicit unique_lock(_Mutex& _Mtx)
        : _Pmtx(::std:: addressof(_Mtx)), _Owns(false) { 
        _Pmtx->lock();
        _Owns = true;
    }

    [[nodiscard]] unique_lock(_Mutex& _Mtx, adopt_lock_t)
        : _Pmtx(::std:: addressof(_Mtx)), _Owns(true) {} 

    unique_lock(_Mutex& _Mtx, defer_lock_t) noexcept
        : _Pmtx(::std:: addressof(_Mtx)), _Owns(false) {} 

    [[nodiscard]] unique_lock(_Mutex& _Mtx, try_to_lock_t)
        : _Pmtx(::std:: addressof(_Mtx)), _Owns(_Pmtx->try_lock()) {} 

    template <class _Rep, class _Period>
    [[nodiscard]] unique_lock(_Mutex& _Mtx, const chrono::duration<_Rep, _Period>& _Rel_time)
        : _Pmtx(::std:: addressof(_Mtx)), _Owns(_Pmtx->try_lock_for(_Rel_time)) {} 

    template <class _Clock, class _Duration>
    [[nodiscard]] unique_lock(_Mutex& _Mtx, const chrono::time_point<_Clock, _Duration>& _Abs_time)
        : _Pmtx(::std:: addressof(_Mtx)), _Owns(_Pmtx->try_lock_until(_Abs_time)) {
        

        static_assert(chrono::is_clock_v<_Clock>, "Clock type required");
#line 157 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mutex"
    }

    [[nodiscard]] unique_lock(_Mutex& _Mtx, const xtime* _Abs_time)
        : _Pmtx(::std:: addressof(_Mtx)), _Owns(false) { 
        _Owns = _Pmtx->try_lock_until(_Abs_time);
    }

    [[nodiscard]] unique_lock(unique_lock&& _Other) noexcept : _Pmtx(_Other._Pmtx), _Owns(_Other._Owns) {
        _Other._Pmtx = nullptr;
        _Other._Owns = false;
    }

    unique_lock& operator=(unique_lock&& _Other) {
        if (this != ::std:: addressof(_Other)) {
            if (_Owns) {
                _Pmtx->unlock();
            }

            _Pmtx        = _Other._Pmtx;
            _Owns        = _Other._Owns;
            _Other._Pmtx = nullptr;
            _Other._Owns = false;
        }
        return *this;
    }

    ~unique_lock() noexcept {
        if (_Owns) {
            _Pmtx->unlock();
        }
    }

    unique_lock(const unique_lock&) = delete;
    unique_lock& operator=(const unique_lock&) = delete;

    void lock() { 
        _Validate();
        _Pmtx->lock();
        _Owns = true;
    }

    [[nodiscard]] bool try_lock() {
        _Validate();
        _Owns = _Pmtx->try_lock();
        return _Owns;
    }

    template <class _Rep, class _Period>
    [[nodiscard]] bool try_lock_for(const chrono::duration<_Rep, _Period>& _Rel_time) {
        _Validate();
        _Owns = _Pmtx->try_lock_for(_Rel_time);
        return _Owns;
    }

    template <class _Clock, class _Duration>
    [[nodiscard]] bool try_lock_until(const chrono::time_point<_Clock, _Duration>& _Abs_time) {

        static_assert(chrono::is_clock_v<_Clock>, "Clock type required");
#line 216 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mutex"
        _Validate();
        _Owns = _Pmtx->try_lock_until(_Abs_time);
        return _Owns;
    }

    [[nodiscard]] bool try_lock_until(const xtime* _Abs_time) {
        _Validate();
        _Owns = _Pmtx->try_lock_until(_Abs_time);
        return _Owns;
    }

    void unlock() {
        if (!_Pmtx || !_Owns) {
            _Throw_system_error(errc::operation_not_permitted);
        }

        _Pmtx->unlock();
        _Owns = false;
    }

    void swap(unique_lock& _Other) noexcept {
        ::std:: swap(_Pmtx, _Other._Pmtx);
        ::std:: swap(_Owns, _Other._Owns);
    }

    _Mutex* release() noexcept {
        _Mutex* _Res = _Pmtx;
        _Pmtx        = nullptr;
        _Owns        = false;
        return _Res;
    }

    [[nodiscard]] bool owns_lock() const noexcept {
        return _Owns;
    }

    explicit operator bool() const noexcept {
        return _Owns;
    }

    [[nodiscard]] _Mutex* mutex() const noexcept {
        return _Pmtx;
    }

private:
    _Mutex* _Pmtx;
    bool _Owns;

    void _Validate() const { 
        if (!_Pmtx) {
            _Throw_system_error(errc::operation_not_permitted);
        }

        if (_Owns) {
            _Throw_system_error(errc::resource_deadlock_would_occur);
        }
    }
};

template <class _Mutex>
void swap(unique_lock<_Mutex>& _Left, unique_lock<_Mutex>& _Right) noexcept {
    _Left.swap(_Right);
}

template <size_t... _Indices, class... _LockN>
void _Lock_from_locks(const int _Target, index_sequence<_Indices...>, _LockN&... _LkN) { 
    int _Ignored[] = {((static_cast<int>(_Indices) == _Target ? (void) _LkN.lock() : void()), 0)...};
    (void) _Ignored;
}

template <size_t... _Indices, class... _LockN>
bool _Try_lock_from_locks(
    const int _Target, index_sequence<_Indices...>, _LockN&... _LkN) { 
    bool _Result{};
    int _Ignored[] = {((static_cast<int>(_Indices) == _Target ? (void) (_Result = _LkN.try_lock()) : void()), 0)...};
    (void) _Ignored;
    return _Result;
}

template <size_t... _Indices, class... _LockN>
void _Unlock_locks(const int _First, const int _Last, index_sequence<_Indices...>, _LockN&... _LkN) noexcept
 {
    
    int _Ignored[] = {
        ((_First <= static_cast<int>(_Indices) && static_cast<int>(_Indices) < _Last ? (void) _LkN.unlock() : void()),
            0)...};
    (void) _Ignored;
}

template <class... _LockN>
int _Try_lock_range(const int _First, const int _Last, _LockN&... _LkN) {
    using _Indices = index_sequence_for<_LockN...>;
    int _Next      = _First;
    try {
    for (; _Next != _Last; ++_Next) {
        if (!_Try_lock_from_locks(_Next, _Indices{}, _LkN...)) { 
            _Unlock_locks(_First, _Next, _Indices{}, _LkN...);
            return _Next;
        }
    }
    } catch (...) {
    _Unlock_locks(_First, _Next, _Indices{}, _LkN...);
    throw;
    }

    return -1;
}

template <class _Lock0, class _Lock1, class _Lock2, class... _LockN>
int _Try_lock1(_Lock0& _Lk0, _Lock1& _Lk1, _Lock2& _Lk2, _LockN&... _LkN) { 
    return _Try_lock_range(0, sizeof...(_LockN) + 3, _Lk0, _Lk1, _Lk2, _LkN...);
}

template <class _Lock0, class _Lock1>
int _Try_lock1(_Lock0& _Lk0, _Lock1& _Lk1) {
    
    if (!_Lk0.try_lock()) {
        return 0;
    }

    try {
    if (!_Lk1.try_lock()) {
        _Lk0.unlock();
        return 1;
    }
    } catch (...) {
    _Lk0.unlock();
    throw;
    }

    return -1;
}

template <class _Lock0, class _Lock1, class... _LockN>
[[nodiscard]] int try_lock(_Lock0& _Lk0, _Lock1& _Lk1, _LockN&... _LkN) { 
    return _Try_lock1(_Lk0, _Lk1, _LkN...);
}

template <class... _LockN>
int _Lock_attempt(const int _Hard_lock, _LockN&... _LkN) {
    
    using _Indices = index_sequence_for<_LockN...>;
    _Lock_from_locks(_Hard_lock, _Indices{}, _LkN...);
    int _Failed        = -1;
    int _Backout_start = _Hard_lock; 

    try {
    _Failed = _Try_lock_range(0, _Hard_lock, _LkN...);
    if (_Failed == -1) {
        _Backout_start = 0; 
        _Failed        = _Try_lock_range(_Hard_lock + 1, sizeof...(_LockN), _LkN...);
        if (_Failed == -1) { 
            return -1;
        }
    }
    } catch (...) {
    _Unlock_locks(_Backout_start, _Hard_lock + 1, _Indices{}, _LkN...);
    throw;
    }

    
    _Unlock_locks(_Backout_start, _Hard_lock + 1, _Indices{}, _LkN...);
    ::std:: this_thread::yield();
    return _Failed;
}

template <class _Lock0, class _Lock1, class _Lock2, class... _LockN>
void _Lock_nonmember1(_Lock0& _Lk0, _Lock1& _Lk1, _Lock2& _Lk2, _LockN&... _LkN) {
    
    int _Hard_lock = 0;
    while (_Hard_lock != -1) {
        _Hard_lock = _Lock_attempt(_Hard_lock, _Lk0, _Lk1, _Lk2, _LkN...);
    }
}

template <class _Lock0, class _Lock1>
bool _Lock_attempt_small(_Lock0& _Lk0, _Lock1& _Lk1) {
    
    _Lk0.lock();
    try {
    if (_Lk1.try_lock()) {
        return false;
    }
    } catch (...) {
    _Lk0.unlock();
    throw;
    }

    _Lk0.unlock();
    ::std:: this_thread::yield();
    return true;
}

template <class _Lock0, class _Lock1>
void _Lock_nonmember1(_Lock0& _Lk0, _Lock1& _Lk1) {
    
    while (_Lock_attempt_small(_Lk0, _Lk1) && _Lock_attempt_small(_Lk1, _Lk0)) { 
    }
}

template <class _Lock0, class _Lock1, class... _LockN>
void lock(_Lock0& _Lk0, _Lock1& _Lk1, _LockN&... _LkN) { 
    _Lock_nonmember1(_Lk0, _Lk1, _LkN...);
}

template <class _Mutex>
class [[nodiscard]] lock_guard { 
public:
    using mutex_type = _Mutex;

    explicit lock_guard(_Mutex& _Mtx) : _MyMutex(_Mtx) { 
        _MyMutex.lock();
    }

    lock_guard(_Mutex& _Mtx, adopt_lock_t) : _MyMutex(_Mtx) {} 

    ~lock_guard() noexcept {
        _MyMutex.unlock();
    }

    lock_guard(const lock_guard&) = delete;
    lock_guard& operator=(const lock_guard&) = delete;

private:
    _Mutex& _MyMutex;
};


template <class... _Mutexes>
class [[nodiscard]] scoped_lock { 
public:
    explicit scoped_lock(_Mutexes&... _Mtxes) : _MyMutexes(_Mtxes...) { 
        ::std:: lock(_Mtxes...);
    }

    explicit scoped_lock(adopt_lock_t, _Mutexes&... _Mtxes) : _MyMutexes(_Mtxes...) {} 

    ~scoped_lock() noexcept {
        ::std:: apply([](_Mutexes&... _Mtxes) { (..., (void) _Mtxes.unlock()); }, _MyMutexes);
    }

    scoped_lock(const scoped_lock&) = delete;
    scoped_lock& operator=(const scoped_lock&) = delete;

private:
    tuple<_Mutexes&...> _MyMutexes;
};

template <class _Mutex>
class [[nodiscard]] scoped_lock<_Mutex> {
public:
    using mutex_type = _Mutex;

    explicit scoped_lock(_Mutex& _Mtx) : _MyMutex(_Mtx) { 
        _MyMutex.lock();
    }

    explicit scoped_lock(adopt_lock_t, _Mutex& _Mtx) : _MyMutex(_Mtx) {} 

    ~scoped_lock() noexcept {
        _MyMutex.unlock();
    }

    scoped_lock(const scoped_lock&) = delete;
    scoped_lock& operator=(const scoped_lock&) = delete;

private:
    _Mutex& _MyMutex;
};

template <>
class scoped_lock<> {
public:
    explicit scoped_lock() {}
    explicit scoped_lock(adopt_lock_t) {}
    ~scoped_lock() noexcept {}

    scoped_lock(const scoped_lock&) = delete;
    scoped_lock& operator=(const scoped_lock&) = delete;
};
#line 497 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mutex"


#line 503 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mutex"


#line 506 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mutex"


extern "C" [[nodiscard]] int __declspec(dllimport) __stdcall __std_init_once_begin_initialize(
    void** _LpInitOnce, unsigned long _DwFlags, int* _FPending, void** _LpContext) noexcept;


extern "C" [[nodiscard]] int __declspec(dllimport) __stdcall __std_init_once_complete(
    void** _LpInitOnce, unsigned long _DwFlags, void* _LpContext) noexcept;

extern "C" [[noreturn]] void __stdcall __std_init_once_link_alternate_names_and_abort() noexcept;


inline constexpr unsigned long _Init_once_init_failed = 0x4UL;

struct _Init_once_completer {
    once_flag& _Once;
    unsigned long _DwFlags;
    ~_Init_once_completer() {
        if (__std_init_once_complete(&_Once._Opaque, _DwFlags, nullptr) == 0) {
            __std_init_once_link_alternate_names_and_abort();
        }
    }
};

template <class _Fn, class... _Args>
void(call_once)(once_flag& _Once, _Fn&& _Fx, _Args&&... _Ax) noexcept(
    noexcept(::std:: invoke(::std:: forward<_Fn>(_Fx), ::std:: forward<_Args>(_Ax)...)))  {
    
    
    int _Pending;
    if (__std_init_once_begin_initialize(&_Once._Opaque, 0, &_Pending, nullptr) == 0) {
        :: abort();
    }

    if (_Pending != 0) {
        _Init_once_completer _Op{_Once, _Init_once_init_failed};
        ::std:: invoke(::std:: forward<_Fn>(_Fx), ::std:: forward<_Args>(_Ax)...);
        _Op._DwFlags = 0;
    }
}


enum class cv_status { 
    no_timeout,
    timeout
};

class condition_variable { 
public:
    using native_handle_type = _Cnd_t;

    condition_variable() {
        _Cnd_init_in_situ(_Mycnd());
    }

    ~condition_variable() noexcept {
        _Cnd_destroy_in_situ(_Mycnd());
    }

    condition_variable(const condition_variable&) = delete;
    condition_variable& operator=(const condition_variable&) = delete;

    void notify_one() noexcept { 
        _Cnd_signal(_Mycnd());
    }

    void notify_all() noexcept { 
        _Cnd_broadcast(_Mycnd());
    }

    void wait(unique_lock<mutex>& _Lck) { 
        
        _Cnd_wait(_Mycnd(), _Lck.mutex()->_Mymtx());
    }

    template <class _Predicate>
    void wait(unique_lock<mutex>& _Lck, _Predicate _Pred) { 
        while (!_Pred()) {
            wait(_Lck);
        }
    }

    template <class _Rep, class _Period>
    cv_status wait_for(unique_lock<mutex>& _Lck, const chrono::duration<_Rep, _Period>& _Rel_time) {
        
        if (_Rel_time <= chrono::duration<_Rep, _Period>::zero()) {
            return cv_status::timeout;
        }

        
        :: xtime _Tgt;
        const bool _Clamped     = _To_xtime_10_day_clamped(_Tgt, _Rel_time);
        const cv_status _Result = wait_until(_Lck, &_Tgt);
        if (_Clamped) {
            return cv_status::no_timeout;
        }

        return _Result;
    }

    template <class _Rep, class _Period, class _Predicate>
    bool wait_for(unique_lock<mutex>& _Lck, const chrono::duration<_Rep, _Period>& _Rel_time, _Predicate _Pred) {
        
        return _Wait_until1(_Lck, _To_absolute_time(_Rel_time), _Pred);
    }

    template <class _Clock, class _Duration>
    cv_status wait_until(unique_lock<mutex>& _Lck, const chrono::time_point<_Clock, _Duration>& _Abs_time) {
        

        static_assert(chrono::is_clock_v<_Clock>, "Clock type required");
#line 639 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mutex"
        for (;;) {
            const auto _Now = _Clock::now();
            if (_Abs_time <= _Now) {
                return cv_status::timeout;
            }

            :: xtime _Tgt;
            (void) _To_xtime_10_day_clamped(_Tgt, _Abs_time - _Now);
            const cv_status _Result = wait_until(_Lck, &_Tgt);
            if (_Result == cv_status::no_timeout) {
                return cv_status::no_timeout;
            }
        }
    }

    template <class _Clock, class _Duration, class _Predicate>
    bool wait_until(
        unique_lock<mutex>& _Lck, const chrono::time_point<_Clock, _Duration>& _Abs_time, _Predicate _Pred) {
        

        static_assert(chrono::is_clock_v<_Clock>, "Clock type required");
#line 661 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mutex"
        return _Wait_until1(_Lck, _Abs_time, _Pred);
    }

    cv_status wait_until(unique_lock<mutex>& _Lck, const xtime* _Abs_time) {
        
        if (!_Mtx_current_owns(_Lck.mutex()->_Mymtx())) {
            _Throw_Cpp_error(_OPERATION_NOT_PERMITTED);
        }

        
        const int _Res = _Cnd_timedwait(_Mycnd(), _Lck.mutex()->_Mymtx(), _Abs_time);
        switch (_Res) {
        case _Thrd_success:
            return cv_status::no_timeout;
        case _Thrd_timedout:
            return cv_status::timeout;
        default:
            _Throw_C_error(_Res);
        }
    }

    template <class _Predicate>
    bool wait_until(unique_lock<mutex>& _Lck, const xtime* _Abs_time, _Predicate _Pred) {
        
        return _Wait_until1(_Lck, _Abs_time, _Pred);
    }

    [[nodiscard]] native_handle_type native_handle() {
        return _Mycnd();
    }

    void _Register(unique_lock<mutex>& _Lck, int* _Ready) { 
        _Cnd_register_at_thread_exit(_Mycnd(), _Lck.release()->_Mymtx(), _Ready);
    }

    void _Unregister(mutex& _Mtx) { 
        _Cnd_unregister_at_thread_exit(_Mtx._Mymtx());
    }

private:
    aligned_storage_t<_Cnd_internal_imp_size, _Cnd_internal_imp_alignment> _Cnd_storage;

    _Cnd_t _Mycnd() noexcept { 
        return reinterpret_cast<_Cnd_t>(&_Cnd_storage);
    }

    template <class _Predicate>
    bool _Wait_until1(unique_lock<mutex>& _Lck, const xtime* _Abs_time, _Predicate& _Pred) {
        
        while (!_Pred()) {
            if (wait_until(_Lck, _Abs_time) == cv_status::timeout) {
                return _Pred();
            }
        }

        return true;
    }

    template <class _Clock, class _Duration, class _Predicate>
    bool _Wait_until1(
        unique_lock<mutex>& _Lck, const chrono::time_point<_Clock, _Duration>& _Abs_time, _Predicate& _Pred) {
        while (!_Pred()) {
            const auto _Now = _Clock::now();
            if (_Abs_time <= _Now) {
                return false;
            }

            :: xtime _Tgt;
            const bool _Clamped = _To_xtime_10_day_clamped(_Tgt, _Abs_time - _Now);
            if (wait_until(_Lck, &_Tgt) == cv_status::timeout && !_Clamped) {
                return _Pred();
            }
        }

        return true;
    }
};

struct _UInt_is_zero {
    const unsigned int& _UInt;

    [[nodiscard]] bool operator()() const {
        return _UInt == 0;
    }
};

class timed_mutex { 
public:
    timed_mutex() noexcept : _My_locked(0) {}

    timed_mutex(const timed_mutex&) = delete;
    timed_mutex& operator=(const timed_mutex&) = delete;

    void lock() { 
        unique_lock<mutex> _Lock(_My_mutex);
        while (_My_locked != 0) {
            _My_cond.wait(_Lock);
        }

        _My_locked = 0xffffffff;
    }

    [[nodiscard]] bool try_lock() noexcept { 
        lock_guard<mutex> _Lock(_My_mutex);
        if (_My_locked != 0) {
            return false;
        } else {
            _My_locked = 0xffffffff;
            return true;
        }
    }

    void unlock() { 
        {
            
            lock_guard<mutex> _Lock(_My_mutex);
            _My_locked = 0;
        }
        _My_cond.notify_one();
    }

    template <class _Rep, class _Period>
    [[nodiscard]] bool try_lock_for(const chrono::duration<_Rep, _Period>& _Rel_time) { 
        return try_lock_until(_To_absolute_time(_Rel_time));
    }

    template <class _Time>
    bool _Try_lock_until(_Time _Abs_time) { 
        unique_lock<mutex> _Lock(_My_mutex);
        if (!_My_cond.wait_until(_Lock, _Abs_time, _UInt_is_zero{_My_locked})) {
            return false;
        }

        _My_locked = 0xffffffff;
        return true;
    }

    template <class _Clock, class _Duration>
    [[nodiscard]] bool try_lock_until(const chrono::time_point<_Clock, _Duration>& _Abs_time) {
        

        static_assert(chrono::is_clock_v<_Clock>, "Clock type required");
#line 804 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mutex"
        return _Try_lock_until(_Abs_time);
    }

    [[nodiscard]] bool try_lock_until(const xtime* _Abs_time) { 
        return _Try_lock_until(_Abs_time);
    }

private:
    mutex _My_mutex;
    condition_variable _My_cond;
    unsigned int _My_locked;
};

class recursive_timed_mutex { 
public:
    recursive_timed_mutex() noexcept : _My_locked(0) {}

    recursive_timed_mutex(const recursive_timed_mutex&) = delete;
    recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete;

    void lock() { 
        const thread::id _Tid = this_thread::get_id();

        unique_lock<mutex> _Lock(_My_mutex);

        if (_Tid == _My_owner) {
            if (_My_locked < 0xffffffff) {
                ++_My_locked;
            } else {
                _Throw_system_error(errc::device_or_resource_busy);
            }
        } else {
            while (_My_locked != 0) {
                _My_cond.wait(_Lock);
            }

            _My_locked = 1;
            _My_owner  = _Tid;
        }
    }

    [[nodiscard]] bool try_lock() noexcept { 
        const thread::id _Tid = this_thread::get_id();

        lock_guard<mutex> _Lock(_My_mutex);

        if (_Tid == _My_owner) {
            if (_My_locked < 0xffffffff) {
                ++_My_locked;
            } else {
                return false;
            }
        } else {
            if (_My_locked != 0) {
                return false;
            } else {
                _My_locked = 1;
                _My_owner  = _Tid;
            }
        }
        return true;
    }

    void unlock() { 
        bool _Do_notify = false;

        {
            lock_guard<mutex> _Lock(_My_mutex);
            --_My_locked;
            if (_My_locked == 0) {
                _Do_notify = true;
                _My_owner  = thread::id();
            }
        }

        if (_Do_notify) {
            _My_cond.notify_one();
        }
    }

    template <class _Rep, class _Period>
    [[nodiscard]] bool try_lock_for(const chrono::duration<_Rep, _Period>& _Rel_time) { 
        return try_lock_until(_To_absolute_time(_Rel_time));
    }

    template <class _Time>
    bool _Try_lock_until(_Time _Abs_time) { 
        const thread::id _Tid = this_thread::get_id();

        unique_lock<mutex> _Lock(_My_mutex);

        if (_Tid == _My_owner) {
            if (_My_locked < 0xffffffff) {
                ++_My_locked;
            } else {
                return false;
            }
        } else {
            if (!_My_cond.wait_until(_Lock, _Abs_time, _UInt_is_zero{_My_locked})) {
                return false;
            }

            _My_locked = 1;
            _My_owner  = _Tid;
        }
        return true;
    }

    template <class _Clock, class _Duration>
    [[nodiscard]] bool try_lock_until(const chrono::time_point<_Clock, _Duration>& _Abs_time) {
        

        static_assert(chrono::is_clock_v<_Clock>, "Clock type required");
#line 918 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mutex"
        return _Try_lock_until(_Abs_time);
    }

    [[nodiscard]] bool try_lock_until(const xtime* _Abs_time) { 
        return _Try_lock_until(_Abs_time);
    }

private:
    mutex _My_mutex;
    condition_variable _My_cond;
    unsigned int _My_locked;
    thread::id _My_owner;
};
#line 932 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mutex"
}


#pragma warning(pop)
#pragma pack(pop)
#line 938 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mutex"
#line 939 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mutex"
#line 22 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory_resource"
#line 23 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory_resource"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {

namespace pmr {

    extern "C"  memory_resource* __cdecl _Aligned_set_default_resource(memory_resource*) noexcept;
    extern "C"  memory_resource* __cdecl _Unaligned_set_default_resource(memory_resource*) noexcept;

    inline memory_resource* set_default_resource(memory_resource* const _Resource) noexcept {

        return _Aligned_set_default_resource(_Resource);


#line 44 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory_resource"
    }

    extern "C" [[nodiscard]]  memory_resource* __cdecl null_memory_resource() noexcept;

    class _Identity_equal_resource : public memory_resource {
    protected:
        bool do_is_equal(const memory_resource& _That) const noexcept override {
            return this == &_That;
        }
    };

    class _Unaligned_new_delete_resource_impl final
        : public _Identity_equal_resource { 
        void* do_allocate(const size_t _Bytes, const size_t _Align) override {
            if (_Align > 8u) {
                _Xbad_alloc();
            }

            return ::operator new(_Bytes);
        }

        void do_deallocate(void* const _Ptr, const size_t _Bytes, size_t) noexcept override  {
            ::operator delete(_Ptr, _Bytes);
        }
    };

    extern "C"  _Unaligned_new_delete_resource_impl* __cdecl _Unaligned_new_delete_resource() noexcept;


    class _Aligned_new_delete_resource_impl final
        : public _Identity_equal_resource { 
        void* do_allocate(const size_t _Bytes, const size_t _Align) override {
            if (_Align > 8u) {
                return ::operator new (_Bytes, align_val_t{_Align});
            }

            return ::operator new(_Bytes);
        }

        void do_deallocate(void* const _Ptr, const size_t _Bytes, const size_t _Align) noexcept override
         {
            if (_Align > 8u) {
                return ::operator delete (_Ptr, _Bytes, align_val_t{_Align});
            }

            ::operator delete(_Ptr, _Bytes);
        }
    };

    extern "C"  _Aligned_new_delete_resource_impl* __cdecl _Aligned_new_delete_resource() noexcept;

    [[nodiscard]] inline memory_resource* new_delete_resource() noexcept {
        return _Aligned_new_delete_resource();
    }


#line 105 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory_resource"

    template <class _Tag = void>
    struct _Double_link { 
        _Double_link* _Next;
        _Double_link* _Prev;
    };

    template <class _Ty, class _Tag = void>
    struct _Intrusive_list { 
        using _Link_type = _Double_link<_Tag>;

        constexpr _Intrusive_list() noexcept { 
            
        }

        _Intrusive_list(const _Intrusive_list&) = delete;
        _Intrusive_list& operator=(const _Intrusive_list&) = delete;

        static constexpr _Link_type* _As_link(_Ty* const _Ptr) noexcept {
            
            static_assert(is_base_of_v<_Link_type, _Ty>);
            return static_cast<_Link_type*>(_Ptr);
        }

        static constexpr _Ty* _As_item(_Link_type* const _Ptr) noexcept { 
            static_assert(is_base_of_v<_Link_type, _Ty>);
            return static_cast<_Ty*>(_Ptr);
        }

        constexpr void _Push_front(_Ty* const _Item) noexcept { 
            static_assert(is_base_of_v<_Link_type, _Ty>);
            const auto _Ptr    = static_cast<_Link_type*>(_Item);
            _Ptr->_Next        = _Head._Next;
            _Head._Next->_Prev = _Ptr;
            _Ptr->_Prev        = &_Head;
            _Head._Next        = _Ptr;
        }

        static constexpr void _Remove(_Ty* const _Item) noexcept { 
            static_assert(is_base_of_v<_Link_type, _Ty>);
            const auto _Ptr    = static_cast<_Link_type*>(_Item);
            _Ptr->_Next->_Prev = _Ptr->_Prev;
            _Ptr->_Prev->_Next = _Ptr->_Next;
        }

        constexpr void _Clear() noexcept { 
            _Head._Next = &_Head;
            _Head._Prev = &_Head;
        }

        _Link_type _Head{&_Head, &_Head};
    };

    template <class _Tag = void>
    struct _Single_link { 
        _Single_link* _Next;
    };

    template <class _Ty, class _Tag = void>
    struct _Intrusive_stack { 
        using _Link_type = _Single_link<_Tag>;

        constexpr _Intrusive_stack() noexcept = default;
        constexpr _Intrusive_stack(_Intrusive_stack&& _That) noexcept : _Head{_That._Head} {
            _That._Head = nullptr;
        }
        constexpr _Intrusive_stack& operator=(_Intrusive_stack&& _That) noexcept {
            _Head       = _That._Head;
            _That._Head = nullptr;
            return *this;
        }

        static constexpr _Link_type* _As_link(_Ty* const _Ptr) noexcept {
            static_assert(is_base_of_v<_Link_type, _Ty>);
            return static_cast<_Link_type*>(_Ptr);
        }

        static constexpr _Ty* _As_item(_Link_type* const _Ptr) noexcept {
            static_assert(is_base_of_v<_Link_type, _Ty>);
            return static_cast<_Ty*>(_Ptr);
        }

        constexpr bool _Empty() const noexcept {
            return _Head == nullptr;
        }

        constexpr _Ty* _Top() const noexcept {
            return _As_item(_Head);
        }

        constexpr void _Push(_Ty* const _Item) noexcept {
            const auto _Ptr = _As_link(_Item);
            _Ptr->_Next     = _Head;
            _Head           = _Ptr;
        }

        constexpr _Ty* _Pop() noexcept { 
            const auto _Result = _Head;
            _Head              = _Head->_Next;
            return _As_item(_Result);
        }

        constexpr void _Remove(_Ty* const _Item) noexcept {
            const auto _Ptr = _As_link(_Item);
            for (_Link_type** _Foo = ::std:: addressof(_Head); *_Foo; _Foo = ::std:: addressof((*_Foo)->_Next)) {
                if (*_Foo == _Ptr) {
                    *_Foo = _Ptr->_Next;
                    break;
                }
            }
        }

        _Link_type* _Head = nullptr;
    };

    struct pool_options {
        size_t max_blocks_per_chunk        = 0;
        size_t largest_required_pool_block = 0;
    };

    inline void _Check_alignment(void* const _Ptr, const size_t _Align) noexcept {
        ;
#line 228 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory_resource"
        (void) _Ptr;
        (void) _Align;
    }

    struct unsynchronized_pool_resource : _Identity_equal_resource {
        unsynchronized_pool_resource() noexcept { 
            _Setup_options();
        }
        unsynchronized_pool_resource(
            const pool_options& _Opts, memory_resource* const _Resource) noexcept 
            : _Options(_Opts), _Pools{_Resource} { 
            ;
#line 241 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory_resource"
            _Setup_options();
        }
        explicit unsynchronized_pool_resource(memory_resource* const _Resource) noexcept 
            : _Pools{_Resource} { 
            ;
#line 247 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory_resource"
            _Setup_options();
        }
        explicit unsynchronized_pool_resource(const pool_options& _Opts) noexcept 
            : _Options(_Opts) { 
            _Setup_options();
        }

        unsynchronized_pool_resource(const unsynchronized_pool_resource&) = delete;
        unsynchronized_pool_resource& operator=(const unsynchronized_pool_resource&) = delete;

        ~unsynchronized_pool_resource() noexcept override {
            
            release();
        }

        [[nodiscard]] memory_resource* upstream_resource() const noexcept  {
            
            return _Pools.get_allocator().resource();
        }

        [[nodiscard]] pool_options options() const noexcept  {
            
            return _Options;
        }

        void release() noexcept  {
            
            for (auto& _Al : _Pools) {
                _Al._Clear(*this);
            }
            _Pools.clear();
            _Pools.shrink_to_fit();

            auto* _Ptr = _Chunks._Head._Next;
            _Chunks._Clear();
            memory_resource* const _Resource = upstream_resource();
            while (_Ptr != &_Chunks._Head) {
                const auto _Chunk = _Chunks._As_item(_Ptr);
                _Ptr              = _Ptr->_Next;
                _Resource->deallocate(_Chunk->_Base_address(), _Chunk->_Size, _Chunk->_Align);
            }
        }

    protected:
        void* do_allocate(size_t _Bytes, const size_t _Align) override {
            
            if (_Bytes <= _Options.largest_required_pool_block) {
                auto _Result = _Find_pool(_Bytes, _Align);
                if (_Result.first == _Pools.end() || _Result.first->_Log_of_size != _Result.second) {
                    _Result.first = _Pools.emplace(_Result.first, _Result.second);
                }

                return _Result.first->_Allocate(*this);
            }

            return _Allocate_oversized(_Bytes, _Align);
        }

        void do_deallocate(void* const _Ptr, const size_t _Bytes, const size_t _Align) override {
            
            if (_Bytes <= _Options.largest_required_pool_block) {
                const auto _Result = _Find_pool(_Bytes, _Align);
                if (_Result.first != _Pools.end() && _Result.first->_Log_of_size == _Result.second) {
                    _Result.first->_Deallocate(*this, _Ptr);
                }
            } else {
                _Deallocate_oversized(_Ptr, _Bytes, _Align);
            }
        }

    private:
        struct _Oversized_header
            : _Double_link<> { 
            size_t _Size;
            size_t _Align;

            void* _Base_address() const { 
                return const_cast<char*>(reinterpret_cast<const char*>(this + 1) - _Size);
            }
        };

        static_assert(alignof(_Oversized_header) == alignof(void*));
        static_assert(sizeof(_Oversized_header) == 4 * sizeof(void*));

        static constexpr bool _Prepare_oversized(size_t& _Bytes, size_t& _Align) noexcept {
            
            _Align = (::std:: max)(_Align, alignof(_Oversized_header));

            if (_Bytes > 0xffffffffui32 - sizeof(_Oversized_header) - alignof(_Oversized_header) + 1) {
                
                return false;
            }

            
            _Bytes = (_Bytes + sizeof(_Oversized_header) + alignof(_Oversized_header) - 1)
                   & ~(alignof(_Oversized_header) - 1);

            return true;
        }

        void* _Allocate_oversized(size_t _Bytes, size_t _Align) {
            
            if (!_Prepare_oversized(_Bytes, _Align)) { 
                _Xbad_alloc();
            }

            memory_resource* const _Resource = upstream_resource();
            void* const _Ptr                 = _Resource->allocate(_Bytes, _Align);
            _Check_alignment(_Ptr, _Align);

            _Oversized_header* const _Hdr = reinterpret_cast<_Oversized_header*>(static_cast<char*>(_Ptr) + _Bytes) - 1;

            _Hdr->_Size  = _Bytes;
            _Hdr->_Align = _Align;
            _Chunks._Push_front(_Hdr);

            return _Ptr;
        }

        void _Deallocate_oversized(void* _Ptr, size_t _Bytes, size_t _Align) noexcept {
            
            if (!_Prepare_oversized(_Bytes, _Align)) {
                

            }

            _Oversized_header* _Hdr = reinterpret_cast<_Oversized_header*>(reinterpret_cast<char*>(_Ptr) + _Bytes) - 1;

            ;
#line 381 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory_resource"
            _Chunks._Remove(_Hdr);
            upstream_resource()->deallocate(_Ptr, _Bytes, _Align);
        }

        struct _Pool { 
            struct _Chunk
                : _Single_link<> { 
                _Intrusive_stack<_Single_link<>> _Free_blocks{}; 
                size_t _Free_count; 
                size_t _Capacity; 
                char* _Base; 
                size_t _Next_available = 0; 
                size_t _Id; 

                _Chunk(_Pool& _Al, void* const _Base_, const size_t _Capacity_) noexcept
                    : _Free_count{_Capacity_}, _Capacity{_Capacity_}, _Base{static_cast<char*>(_Base_)},
                      _Id{_Al._All_chunks._Empty() ? 0 : _Al._All_chunks._Top()->_Id + 1} {
                    
                }

                _Chunk(const _Chunk&) = delete;
                _Chunk& operator=(const _Chunk&) = delete;
            };

            _Chunk* _Unfull_chunk = nullptr; 
            _Intrusive_stack<_Chunk> _All_chunks{}; 
            size_t _Next_capacity = _Default_next_capacity; 
                                                            
            size_t _Block_size; 
            size_t _Log_of_size; 
            _Chunk* _Empty_chunk = nullptr; 

            static constexpr size_t _Default_next_capacity = 4;
            static_assert(_Default_next_capacity > 1);

            explicit _Pool(const size_t _Log_of_size_) noexcept
                : _Block_size{size_t{1} << _Log_of_size_}, _Log_of_size{_Log_of_size_} {
                
            }

            _Pool(_Pool&& _That) noexcept
                : _Unfull_chunk{::std:: exchange(_That._Unfull_chunk, nullptr)}, _All_chunks{::std:: move(_That._All_chunks)},
                  _Next_capacity{::std:: exchange(_That._Next_capacity, _Default_next_capacity)},
                  _Block_size{_That._Block_size}, _Log_of_size{_That._Log_of_size}, _Empty_chunk{::std:: exchange(
                                                                                        _That._Empty_chunk, nullptr)} {}

            _Pool& operator=(_Pool&& _That) noexcept {
                _Unfull_chunk  = ::std:: exchange(_That._Unfull_chunk, nullptr);
                _All_chunks    = ::std:: move(_That._All_chunks);
                _Next_capacity = ::std:: exchange(_That._Next_capacity, _Default_next_capacity);
                _Block_size    = _That._Block_size;
                _Log_of_size   = _That._Log_of_size;
                _Empty_chunk   = ::std:: exchange(_That._Empty_chunk, nullptr);
                return *this;
            }

            void _Clear(unsynchronized_pool_resource& _Pool_resource) noexcept {
                
                _Intrusive_stack<_Chunk> _Tmp{};
                ::std:: swap(_Tmp, _All_chunks);
                memory_resource* const _Resource = _Pool_resource.upstream_resource();
                while (!_Tmp._Empty()) {
                    const auto _Ptr = _Tmp._Pop();
                    _Resource->deallocate(_Ptr->_Base, _Size_for_capacity(_Ptr->_Capacity), _Block_size);
                }

                _Unfull_chunk  = nullptr;
                _Next_capacity = _Default_next_capacity;
                _Empty_chunk   = nullptr;
            }

            void* _Allocate(unsynchronized_pool_resource& _Pool_resource) { 
                for (;; _Unfull_chunk = _All_chunks._As_item(_Unfull_chunk->_Next)) {
                    if (!_Unfull_chunk) {
                        _Increase_capacity(_Pool_resource);
                    } else if (!_Unfull_chunk->_Free_blocks._Empty()) {
                        if (_Unfull_chunk == _Empty_chunk) { 
                            _Empty_chunk = nullptr;
                        }
                        --_Unfull_chunk->_Free_count;
                        return _Unfull_chunk->_Free_blocks._Pop();
                    }

                    if (_Unfull_chunk->_Next_available < _Unfull_chunk->_Capacity) {
                        if (_Unfull_chunk == _Empty_chunk) { 
                            _Empty_chunk = nullptr;
                        }
                        --_Unfull_chunk->_Free_count;
                        char* const _Block = _Unfull_chunk->_Base + _Unfull_chunk->_Next_available * _Block_size;
                        ++_Unfull_chunk->_Next_available;
                        *(reinterpret_cast<_Chunk**>(_Block + _Block_size) - 1) = _Unfull_chunk;
                        return _Block;
                    }
                }
            }

            void _Deallocate(unsynchronized_pool_resource& _Pool_resource, void* const _Ptr) noexcept {
                
                _Chunk* _Current = *(reinterpret_cast<_Chunk**>(static_cast<char*>(_Ptr) + _Block_size) - 1);

                _Current->_Free_blocks._Push(::new (_Ptr) _Single_link<>);

                if (_Current->_Free_count++ == 0) {
                    
                    if (!_Unfull_chunk || _Unfull_chunk->_Id < _Current->_Id) {
                        _Unfull_chunk = _Current;
                    }

                    return;
                }

                if (_Current->_Free_count < _Current->_Capacity) {
                    return;
                }

                if (!_Empty_chunk) {
                    _Empty_chunk = _Current;
                    return;
                }

                
                if (_Empty_chunk->_Id < _Current->_Id) {
                    ::std:: swap(_Current, _Empty_chunk);
                }

                _All_chunks._Remove(_Current);
                _Pool_resource.upstream_resource()->deallocate(
                    _Current->_Base, _Size_for_capacity(_Current->_Capacity), _Block_size);
            }

            size_t _Size_for_capacity(const size_t _Capacity) const noexcept {
                
                return (_Capacity << _Log_of_size) + sizeof(_Chunk);
            }

            void _Increase_capacity(unsynchronized_pool_resource& _Pool_resource) {
                
                const size_t _Size               = _Size_for_capacity(_Next_capacity);
                memory_resource* const _Resource = _Pool_resource.upstream_resource();
                void* const _Ptr                 = _Resource->allocate(_Size, _Block_size);
                _Check_alignment(_Ptr, _Block_size);

                void* const _Tmp = static_cast<char*>(_Ptr) + _Size - sizeof(_Chunk);
                _Unfull_chunk    = ::new (_Tmp) _Chunk{*this, _Ptr, _Next_capacity};
                _Empty_chunk     = _Unfull_chunk;
                _All_chunks._Push(_Unfull_chunk);

                
                _Next_capacity =
                    (::std:: min)(_Next_capacity << 1, (::std:: min)((2147483647i32 - sizeof(_Chunk)) >> _Log_of_size,
                                                        _Pool_resource._Options.max_blocks_per_chunk));
            }
        };

        void _Setup_options() noexcept { 
            constexpr auto _Max_blocks_per_chunk_limit = static_cast<size_t>(2147483647i32);
            constexpr auto _Largest_required_pool_block_limit =
                static_cast<size_t>((2147483647i32 >> 4) + 1); 
            static_assert(_Is_pow_2(_Largest_required_pool_block_limit));

            if (_Options.max_blocks_per_chunk - 1 >= _Max_blocks_per_chunk_limit) {
                _Options.max_blocks_per_chunk = _Max_blocks_per_chunk_limit;
            }

            if (_Options.largest_required_pool_block - 1 < sizeof(void*)) {
                _Options.largest_required_pool_block = sizeof(void*);
            } else if (_Options.largest_required_pool_block - 1 >= _Largest_required_pool_block_limit) {
                _Options.largest_required_pool_block = _Largest_required_pool_block_limit;
            } else {
                _Options.largest_required_pool_block = static_cast<size_t>(1)
                                                    << _Ceiling_of_log_2(_Options.largest_required_pool_block);
            }
        }

        pair<pmr::vector<_Pool>::iterator, unsigned char> _Find_pool(
            const size_t _Bytes, const size_t _Align) noexcept {
            
            const size_t _Size      = (::std:: max)(_Bytes + sizeof(void*), _Align);
            const auto _Log_of_size = static_cast<unsigned char>(_Ceiling_of_log_2(_Size));
            return {::std:: lower_bound(_Pools.begin(), _Pools.end(), _Log_of_size,
                        [](const _Pool& _Al, const unsigned char _Log) { return _Al._Log_of_size < _Log; }),
                _Log_of_size};
        }

        pool_options _Options{}; 
        _Intrusive_list<_Oversized_header> _Chunks{}; 
        pmr::vector<_Pool> _Pools{}; 
    };


    class synchronized_pool_resource : public unsynchronized_pool_resource {
    public:
        using unsynchronized_pool_resource::unsynchronized_pool_resource;

        void release() noexcept  {
            lock_guard<mutex> _Guard{_Mtx};
            this->unsynchronized_pool_resource::release();
        }

    protected:
        void* do_allocate(const size_t _Bytes, const size_t _Align) override {
            lock_guard<mutex> _Guard{_Mtx};
            return this->unsynchronized_pool_resource::do_allocate(_Bytes, _Align);
        }

        void do_deallocate(void* const _Ptr, const size_t _Bytes, const size_t _Align) override {
            lock_guard<mutex> _Guard{_Mtx};
            this->unsynchronized_pool_resource::do_deallocate(_Ptr, _Bytes, _Align);
        }

    private:
        mutable mutex _Mtx;
    };
#line 595 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory_resource"

    class monotonic_buffer_resource : public _Identity_equal_resource {
    public:
        explicit monotonic_buffer_resource(memory_resource* const _Upstream) noexcept 
            : _Resource{_Upstream} {} 

        monotonic_buffer_resource(const size_t _Initial_size, memory_resource* const _Upstream) noexcept 
            : _Next_buffer_size(_Round(_Initial_size)), _Resource{_Upstream} {
            
        }

        monotonic_buffer_resource(void* const _Buffer, const size_t _Buffer_size,
            memory_resource* const _Upstream) noexcept 
            : _Current_buffer(_Buffer), _Space_available(_Buffer_size),
              _Next_buffer_size(_Buffer_size ? _Scale(_Buffer_size) : _Min_allocation), _Resource{_Upstream} {
            
        }

        monotonic_buffer_resource() = default;

        explicit monotonic_buffer_resource(const size_t _Initial_size) noexcept 
            : _Next_buffer_size(_Round(_Initial_size)) {} 

        monotonic_buffer_resource(void* const _Buffer, const size_t _Buffer_size) noexcept 
            : _Current_buffer(_Buffer), _Space_available(_Buffer_size),
              _Next_buffer_size(_Buffer_size ? _Scale(_Buffer_size) : _Min_allocation) {
            
        }

        ~monotonic_buffer_resource() noexcept override {
            release();
        }

        monotonic_buffer_resource(const monotonic_buffer_resource&) = delete;
        monotonic_buffer_resource& operator=(const monotonic_buffer_resource&) = delete;

        void release() noexcept  {
            if (_Chunks._Empty()) {
                
                return;
            }

            _Current_buffer  = nullptr;
            _Space_available = 0;

            
            const size_t _Unscaled = (_Next_buffer_size / 3 * 2 + alignof(_Header) - 1) & _Max_allocation;
            _Next_buffer_size      = (::std:: max)(_Unscaled, _Min_allocation);

            _Intrusive_stack<_Header> _Tmp{};
            ::std:: swap(_Tmp, _Chunks);
            while (!_Tmp._Empty()) {
                const auto _Ptr = _Tmp._Pop();
                _Resource->deallocate(_Ptr->_Base_address(), _Ptr->_Size, _Ptr->_Align);
            }
        }

        [[nodiscard]] memory_resource* upstream_resource() const noexcept  {
            
            return _Resource;
        }

    protected:
        void* do_allocate(const size_t _Bytes, const size_t _Align) override {
            
            if (!::std:: align(_Align, _Bytes, _Current_buffer, _Space_available)) {
                _Increase_capacity(_Bytes, _Align);
            }

            void* const _Result = _Current_buffer;
            _Current_buffer     = static_cast<char*>(_Current_buffer) + _Bytes;
            _Space_available -= _Bytes;
            return _Result;
        }

        void do_deallocate(void*, size_t, size_t) override {} 

    private:
        struct _Header : _Single_link<> { 
            size_t _Size;
            size_t _Align;

            _Header(const size_t _Size_, const size_t _Align_) : _Size{_Size_}, _Align{_Align_} {}

            void* _Base_address() const { 
                return const_cast<char*>(reinterpret_cast<const char*>(this + 1) - _Size);
            }
        };

        static constexpr size_t _Min_allocation = 2 * sizeof(_Header);
        static constexpr size_t _Max_allocation = 0 - alignof(_Header);

        static constexpr size_t _Round(const size_t _Size) noexcept {
            
            
            if (_Size < _Min_allocation) {
                return _Min_allocation;
            }

            if (_Size >= _Max_allocation) {
                return _Max_allocation;
            }

            
            return (_Size + alignof(_Header) - 1) & _Max_allocation;
        }

        static constexpr size_t _Scale(const size_t _Size) noexcept {
            
            
            constexpr auto _Max_size = (_Max_allocation - alignof(_Header) + 1) / 3 * 2;
            if (_Size >= _Max_size) {
                return _Max_allocation;
            }

            return (_Size + (_Size + 1) / 2 + alignof(_Header) - 1) & _Max_allocation;
        }

        void _Increase_capacity(const size_t _Bytes, const size_t _Align) { 
            if (_Bytes > _Max_allocation - sizeof(_Header)) {
                _Xbad_alloc();
            }

            size_t _New_size = _Next_buffer_size;
            if (_New_size < _Bytes + sizeof(_Header)) {
                _New_size = (_Bytes + sizeof(_Header) + alignof(_Header) - 1) & _Max_allocation;
            }

            const size_t _New_align = (::std:: max)(alignof(_Header), _Align);

            void* _New_buffer = _Resource->allocate(_New_size, _New_align);
            _Check_alignment(_New_buffer, _New_align);

            _Current_buffer  = _New_buffer;
            _Space_available = _New_size - sizeof(_Header);
            _New_buffer      = static_cast<char*>(_New_buffer) + _Space_available;
            _Chunks._Push(::new (_New_buffer) _Header{_New_size, _New_align});

            _Next_buffer_size = _Scale(_New_size);
        }

        void* _Current_buffer    = nullptr; 
        size_t _Space_available  = 0; 
        size_t _Next_buffer_size = _Min_allocation; 
        _Intrusive_stack<_Header> _Chunks{}; 
        memory_resource* _Resource = ::std:: pmr::get_default_resource(); 
    };
} 

}


#pragma warning(pop)
#pragma pack(pop)
#line 753 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory_resource"
#line 754 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory_resource"
#line 755 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\memory_resource"
#line 35 "all-std.cxx"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\scoped_allocator"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
template <class _Alloc, class = void>
struct _Scoped_outermost_helper { 
    static decltype(auto) _Fn(_Alloc& _Al) { 
        return _Al;
    }
};

template <class _Alloc>
struct _Scoped_outermost_helper<_Alloc,
    void_t<decltype(::std:: declval<_Alloc&>().outer_allocator())>> { 
    using _Outer_alloc = decltype(::std:: declval<_Alloc&>().outer_allocator());

    static decltype(auto) _Fn(_Alloc& _Al) { 
        return _Scoped_outermost_helper<_Outer_alloc>::_Fn(_Al.outer_allocator());
    }
};

template <class _Alloc>
decltype(auto) _Scoped_outermost(_Alloc& _Al) { 
    return _Scoped_outermost_helper<_Alloc>::_Fn(_Al);
}

template <class _Alloc>
using _Scoped_outermost_t = remove_reference_t<decltype(_Scoped_outermost(::std:: declval<_Alloc&>()))>;

template <class _Alloc>
using _Scoped_outermost_traits = allocator_traits<_Scoped_outermost_t<_Alloc>>;

template <class _Outer, class... _Inner>
class scoped_allocator_adaptor;

template <class _Outer, class... _Inner>
struct _Scoped_base;

struct _Secret_scoped_allocator_construct_tag {
    explicit _Secret_scoped_allocator_construct_tag() = default;
};

template <class _Outer, class _Inner0, class... _Inner>
struct _Scoped_base<_Outer, _Inner0, _Inner...> : _Outer { 
    using _Myadaptor           = scoped_allocator_adaptor<_Outer, _Inner0, _Inner...>;
    using inner_allocator_type = scoped_allocator_adaptor<_Inner0, _Inner...>;

    inner_allocator_type _Inner_obj;

    inner_allocator_type& _Get_inner_object(_Myadaptor&) {
        return _Inner_obj;
    }

    const inner_allocator_type& _Get_inner_object(const _Myadaptor&) const {
        return _Inner_obj;
    }

    _Scoped_base() : _Outer(), _Inner_obj() {} 

    template <class _Other1, class... _Other2,
        enable_if_t<sizeof...(_Other2) != 0 || !is_base_of_v<_Scoped_base, decay_t<_Other1>>, int> = 0>
    _Scoped_base(_Other1&& _Outer_arg, _Other2&&... _Inner_args)
        : _Outer(::std:: forward<_Other1>(_Outer_arg)), _Inner_obj(::std:: forward<_Other2>(_Inner_args)...) {
        
    }

    _Scoped_base(const _Scoped_base&) = default;
    _Scoped_base(_Scoped_base&&)      = default;
    _Scoped_base& operator=(const _Scoped_base&) = default;
    _Scoped_base& operator=(_Scoped_base&&) = default;

    [[nodiscard]] _Myadaptor select_on_container_copy_construction() const { 
        return _Myadaptor(_Secret_scoped_allocator_construct_tag{},
            allocator_traits<_Outer>::select_on_container_copy_construction(static_cast<const _Outer&>(*this)),
            _Inner_obj.select_on_container_copy_construction());
    }
};

template <class _Outer>
struct _Scoped_base<_Outer> : _Outer { 
    using _Myadaptor           = scoped_allocator_adaptor<_Outer>;
    using inner_allocator_type = scoped_allocator_adaptor<_Outer>;

    inner_allocator_type& _Get_inner_object(_Myadaptor& _Self) {
        return _Self;
    }

    const inner_allocator_type& _Get_inner_object(const _Myadaptor& _Self) const {
        return _Self;
    }

    _Scoped_base() : _Outer() {} 

    template <class _Other1, enable_if_t<!is_base_of_v<_Scoped_base, decay_t<_Other1>>, int> = 0>
    _Scoped_base(_Other1&& _Outer_arg) : _Outer(::std:: forward<_Other1>(_Outer_arg)) {} 

    _Scoped_base(const _Scoped_base&) = default;
    _Scoped_base(_Scoped_base&&)      = default;
    _Scoped_base& operator=(const _Scoped_base&) = default;
    _Scoped_base& operator=(_Scoped_base&&) = default;

    [[nodiscard]] _Myadaptor select_on_container_copy_construction() const { 
        return _Myadaptor(
            allocator_traits<_Outer>::select_on_container_copy_construction(static_cast<const _Outer&>(*this)));
    }
};

template <class _Outer, class... _Inner>
class scoped_allocator_adaptor : public _Scoped_base<_Outer, _Inner...> { 
    using _Mybase       = _Scoped_base<_Outer, _Inner...>;
    using _Outer_traits = allocator_traits<_Outer>;

public:
    using outer_allocator_type = _Outer;
    using inner_allocator_type = typename _Mybase::inner_allocator_type;

    using value_type         = typename _Outer_traits::value_type;
    using pointer            = typename _Outer_traits::pointer;
    using const_pointer      = typename _Outer_traits::const_pointer;
    using void_pointer       = typename _Outer_traits::void_pointer;
    using const_void_pointer = typename _Outer_traits::const_void_pointer;

    using size_type       = typename _Outer_traits::size_type;
    using difference_type = typename _Outer_traits::difference_type;

    template <class _Other>
    struct rebind { 
        using _Other_alloc = typename _Get_rebind_type<_Outer, _Other>::type;
        using other        = scoped_allocator_adaptor<_Other_alloc, _Inner...>;
    };

    using propagate_on_container_copy_assignment =
        bool_constant<disjunction_v<typename allocator_traits<_Outer>::propagate_on_container_copy_assignment,
            typename allocator_traits<_Inner>::propagate_on_container_copy_assignment...>>;

    using propagate_on_container_move_assignment =
        bool_constant<disjunction_v<typename allocator_traits<_Outer>::propagate_on_container_move_assignment,
            typename allocator_traits<_Inner>::propagate_on_container_move_assignment...>>;

    using propagate_on_container_swap =
        bool_constant<disjunction_v<typename allocator_traits<_Outer>::propagate_on_container_swap,
            typename allocator_traits<_Inner>::propagate_on_container_swap...>>;

    using is_always_equal = bool_constant<conjunction_v<typename allocator_traits<_Outer>::is_always_equal,
        typename allocator_traits<_Inner>::is_always_equal...>>;

    scoped_allocator_adaptor() = default; 

    template <class _Other, enable_if_t<is_constructible_v<_Outer, _Other>, int> = 0>
    scoped_allocator_adaptor(_Other&& _Other_arg, const _Inner&... _Inner_args) noexcept
        : _Mybase(::std:: forward<_Other>(_Other_arg), _Inner_args...) {
        
    }

    scoped_allocator_adaptor(const scoped_allocator_adaptor& _Right) noexcept : _Mybase(_Right) {}

    scoped_allocator_adaptor(scoped_allocator_adaptor&& _Right) noexcept : _Mybase(::std:: move(_Right)) {}

    template <class _Other, bool _Enabled = sizeof...(_Inner) != 0 && is_constructible_v<_Outer, const _Other&>,
        enable_if_t<_Enabled, int> = 0>
    scoped_allocator_adaptor(const scoped_allocator_adaptor<_Other, _Inner...>& _Right) noexcept
        : _Mybase(_Right.outer_allocator(), _Right.inner_allocator()) {}

    template <class _Other, bool _Enabled = sizeof...(_Inner) != 0 && is_constructible_v<_Outer, _Other>,
        enable_if_t<_Enabled, int> = 0>
    scoped_allocator_adaptor(scoped_allocator_adaptor<_Other, _Inner...>&& _Right) noexcept
        : _Mybase(::std:: move(_Right.outer_allocator()), ::std:: move(_Right.inner_allocator())) {}

    scoped_allocator_adaptor(_Secret_scoped_allocator_construct_tag, const outer_allocator_type& _Outer_arg,
        const inner_allocator_type& _Inner_arg) noexcept
        : _Mybase(_Outer_arg, _Inner_arg) {}

    scoped_allocator_adaptor& operator=(const scoped_allocator_adaptor&) = default;
    scoped_allocator_adaptor& operator=(scoped_allocator_adaptor&&) = default;

    [[nodiscard]] inner_allocator_type& inner_allocator() noexcept { 
        return this->_Get_inner_object(*this);
    }

    [[nodiscard]] const inner_allocator_type& inner_allocator() const noexcept { 
        return this->_Get_inner_object(*this);
    }

    [[nodiscard]] outer_allocator_type& outer_allocator() noexcept { 
        return static_cast<_Outer&>(*this);
    }

    [[nodiscard]] const outer_allocator_type& outer_allocator() const noexcept { 
        return static_cast<const _Outer&>(*this);
    }

    [[nodiscard]] __declspec(allocator) pointer
        allocate( size_type _Count) { 
        return _Outer_traits::allocate(outer_allocator(), _Count);
    }

    [[nodiscard]] __declspec(allocator) pointer allocate(
         size_type _Count, const_void_pointer _Hint) { 
        return _Outer_traits::allocate(outer_allocator(), _Count, _Hint);
    }

    void deallocate(pointer _Ptr, size_type _Count) { 
        return _Outer_traits::deallocate(outer_allocator(), _Ptr, _Count);
    }

    [[nodiscard]] size_type max_size() const { 
        return _Outer_traits::max_size(outer_allocator());
    }

    template <class _Ty, class... _Types>
    void construct(_Ty* _Ptr, _Types&&... _Args) { 

        ::std:: apply(
            [_Ptr, this](auto&&... _New_args) {
                _Scoped_outermost_traits<scoped_allocator_adaptor>::construct(
                    _Scoped_outermost(*this), _Ptr, ::std:: forward<decltype(_New_args)>(_New_args)...);
            },
            ::std:: uses_allocator_construction_args<_Ty>(inner_allocator(), ::std:: forward<_Types>(_Args)...));


#line 238 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\scoped_allocator"
    }

    template <class _Ty>
    void destroy(_Ty* _Ptr) { 
        _Scoped_outermost_traits<scoped_allocator_adaptor>::destroy(_Scoped_outermost(*this), _Ptr);
    }

    
};


template <class _Outer, class... _Inner>
scoped_allocator_adaptor(_Outer, _Inner...) -> scoped_allocator_adaptor<_Outer, _Inner...>;
#line 252 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\scoped_allocator"

template <class _Outer1, class _Outer2, class _Inner1, class... _Inner>
[[nodiscard]] bool operator==(const scoped_allocator_adaptor<_Outer1, _Inner1, _Inner...>& _Left,
    const scoped_allocator_adaptor<_Outer2, _Inner1, _Inner...>& _Right) noexcept {
    return _Left.outer_allocator() == _Right.outer_allocator() && _Left.inner_allocator() == _Right.inner_allocator();
}

template <class _Outer1, class _Outer2>
[[nodiscard]] bool operator==(
    const scoped_allocator_adaptor<_Outer1>& _Left, const scoped_allocator_adaptor<_Outer2>& _Right) noexcept {
    return _Left.outer_allocator() == _Right.outer_allocator();
}


#line 272 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\scoped_allocator"

}


#pragma warning(pop)
#pragma pack(pop)
#line 279 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\scoped_allocator"
#line 280 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\scoped_allocator"
#line 37 "all-std.cxx"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cinttypes"


#pragma once


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\inttypes.h"


#pragma once


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


typedef struct
{
    intmax_t quot;
    intmax_t rem;
} _Lldiv_t;

typedef _Lldiv_t imaxdiv_t;


 intmax_t __cdecl imaxabs(
      intmax_t _Number
    );

 
 imaxdiv_t __cdecl imaxdiv(
      intmax_t _Numerator,
      intmax_t _Denominator
    );

 intmax_t __cdecl strtoimax(
                        char const* _String,
        char**      _EndPtr,
                          int         _Radix
    );

 intmax_t __cdecl _strtoimax_l(
                        char const* _String,
        char**      _EndPtr,
                          int         _Radix,
                      _locale_t   _Locale
    );

 uintmax_t __cdecl strtoumax(
                        char const* _String,
        char**      _EndPtr,
                          int         _Radix
    );

 uintmax_t __cdecl _strtoumax_l(
                        char const* _String,
        char**      _EndPtr,
                          int         _Radix,
                      _locale_t   _Locale
    );

 intmax_t __cdecl wcstoimax(
                        wchar_t const* _String,
        wchar_t**      _EndPtr,
                          int            _Radix
    );

 intmax_t __cdecl _wcstoimax_l(
                        wchar_t const* _String,
        wchar_t**      _EndPtr,
                          int            _Radix,
                      _locale_t      _Locale
    );

 uintmax_t __cdecl wcstoumax(
                        wchar_t const* _String,
        wchar_t**      _EndPtr,
                          int            _Radix
    );

 uintmax_t __cdecl _wcstoumax_l(
                        wchar_t const* _String,
        wchar_t**      _EndPtr,
                          int            _Radix,
                      _locale_t      _Locale
    );


#line 132 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\inttypes.h"


#line 151 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\inttypes.h"


#line 170 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\inttypes.h"


#line 189 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\inttypes.h"


#line 208 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\inttypes.h"


#line 227 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\inttypes.h"


#line 253 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\inttypes.h"


#line 272 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\inttypes.h"


#line 291 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\inttypes.h"


#line 310 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\inttypes.h"


#line 329 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\inttypes.h"


} __pragma(pack(pop))


#pragma warning(pop) 
#line 342 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\inttypes.h"
#line 14 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cinttypes"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
using :: imaxdiv_t; 

using :: imaxabs;
using :: imaxdiv;
using :: strtoimax;
using :: strtoumax;
using :: wcstoimax;
using :: wcstoumax;
}


#pragma warning(pop)
#pragma pack(pop)

#line 39 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cinttypes"
#line 40 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cinttypes"
#line 39 "all-std.cxx"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cassert"


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\assert.h"


#line 11 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\assert.h"


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


     void __cdecl _wassert(
          wchar_t const* _Message,
          wchar_t const* _File,
            unsigned       _Line
        );

    
#line 42 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\assert.h"


} __pragma(pack(pop))

#pragma warning(pop) 
#line 10 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cassert"
#line 43 "all-std.cxx"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cuchar"


#pragma once


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\uchar.h"


#pragma once


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


#line 22 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\uchar.h"


#line 26 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\uchar.h"

typedef unsigned short _Char16_t;
typedef unsigned int _Char32_t;


#line 34 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\uchar.h"


   size_t __cdecl mbrtoc16(  char16_t *_Pc16,   const char *_S,   size_t _N,   mbstate_t *_Ps);
   size_t __cdecl c16rtomb(  char *_S,   char16_t _C16,   mbstate_t *_Ps);

   size_t __cdecl mbrtoc32(  char32_t *_Pc32,   const char *_S,   size_t _N,   mbstate_t *_Ps);
   size_t __cdecl c32rtomb(  char *_S,   char32_t _C32,   mbstate_t *_Ps);

} __pragma(pack(pop))

#pragma warning(pop) 


 #line 51 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\uchar.h"
#line 13 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cuchar"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
using :: mbstate_t;
using :: size_t;
using :: mbrtoc16;
using :: c16rtomb;
using :: mbrtoc32;
using :: c32rtomb;
}


#pragma warning(pop)
#pragma pack(pop)

#line 36 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cuchar"
#line 37 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cuchar"
#line 51 "all-std.cxx"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cwctype"


#pragma once


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\wctype.h"


#pragma once


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


typedef wchar_t wctrans_t;
 wint_t __cdecl towctrans(wint_t c, wctrans_t value);
 wctrans_t __cdecl wctrans(const char *name);
 wctype_t __cdecl wctype(const char *name);


} __pragma(pack(pop))

#pragma warning(pop) 
#line 34 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\wctype.h"
#line 13 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cwctype"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
using :: wint_t;
using :: wctrans_t;
using :: wctype_t;

using :: iswalnum;
using :: iswalpha;
using :: iswcntrl;
using :: iswctype;
using :: iswdigit;
using :: iswgraph;
using :: iswlower;
using :: iswprint;
using :: iswpunct;
using :: iswspace;
using :: iswupper;
using :: iswxdigit;
using :: towctrans;
using :: towlower;
using :: towupper;
using :: wctrans;
using :: wctype;

using :: iswblank;
}


#pragma warning(pop)
#pragma pack(pop)

#line 73 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cwctype"
#line 74 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cwctype"
#line 53 "all-std.cxx"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\array"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {


#line 27 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\array"

template <class _Ty, size_t _Size>
class _Array_const_iterator


#line 33 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\array"
{
public:

    using iterator_concept = contiguous_iterator_tag;
#line 38 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\array"
    using iterator_category = random_access_iterator_tag;
    using value_type        = _Ty;
    using difference_type   = ptrdiff_t;
    using pointer           = const _Ty*;
    using reference         = const _Ty&;

    enum { _EEN_SIZE = _Size }; 


    constexpr _Array_const_iterator() noexcept : _Ptr() {}

    constexpr explicit _Array_const_iterator(pointer _Parg, size_t _Off = 0) noexcept : _Ptr(_Parg + _Off) {}

    [[nodiscard]] constexpr reference operator*() const noexcept {
        return *_Ptr;
    }

    [[nodiscard]] constexpr pointer operator->() const noexcept {
        return _Ptr;
    }

    constexpr _Array_const_iterator& operator++() noexcept {
        ++_Ptr;
        return *this;
    }

    constexpr _Array_const_iterator operator++(int) noexcept {
        _Array_const_iterator _Tmp = *this;
        ++_Ptr;
        return _Tmp;
    }

    constexpr _Array_const_iterator& operator--() noexcept {
        --_Ptr;
        return *this;
    }

    constexpr _Array_const_iterator operator--(int) noexcept {
        _Array_const_iterator _Tmp = *this;
        --_Ptr;
        return _Tmp;
    }

    constexpr _Array_const_iterator& operator+=(const ptrdiff_t _Off) noexcept {
        _Ptr += _Off;
        return *this;
    }

    [[nodiscard]] constexpr _Array_const_iterator operator+(const ptrdiff_t _Off) const noexcept {
        _Array_const_iterator _Tmp = *this;
        _Tmp += _Off;
        return _Tmp;
    }

    constexpr _Array_const_iterator& operator-=(const ptrdiff_t _Off) noexcept {
        _Ptr -= _Off;
        return *this;
    }

    [[nodiscard]] constexpr _Array_const_iterator operator-(const ptrdiff_t _Off) const noexcept {
        _Array_const_iterator _Tmp = *this;
        _Tmp -= _Off;
        return _Tmp;
    }

    [[nodiscard]] constexpr ptrdiff_t operator-(const _Array_const_iterator& _Right) const noexcept {
        return _Ptr - _Right._Ptr;
    }

    [[nodiscard]] constexpr reference operator[](const ptrdiff_t _Off) const noexcept {
        return _Ptr[_Off];
    }

    [[nodiscard]] constexpr bool operator==(const _Array_const_iterator& _Right) const noexcept {
        return _Ptr == _Right._Ptr;
    }


    [[nodiscard]] constexpr strong_ordering operator<=>(const _Array_const_iterator& _Right) const noexcept {
        return _Ptr <=> _Right._Ptr;
    }


#line 140 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\array"

    using _Prevent_inheriting_unwrap = _Array_const_iterator;

    [[nodiscard]] constexpr pointer _Unwrapped() const noexcept {
        return _Ptr;
    }

    static constexpr bool _Unwrap_when_unverified = true;

    constexpr void _Seek_to(pointer _It) noexcept {
        _Ptr = _It;
    }

private:
    pointer _Ptr; 


#line 298 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\array"
};


#line 308 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\array"

template <class _Ty, size_t _Size>
[[nodiscard]] constexpr _Array_const_iterator<_Ty, _Size> operator+(
    const ptrdiff_t _Off, _Array_const_iterator<_Ty, _Size> _Next) noexcept {
    _Next += _Off;
    return _Next;
}


template <class _Ty, size_t _Size>
struct pointer_traits<_Array_const_iterator<_Ty, _Size>> {
    using pointer         = _Array_const_iterator<_Ty, _Size>;
    using element_type    = const _Ty;
    using difference_type = ptrdiff_t;

    [[nodiscard]] static constexpr element_type* to_address(const pointer _Iter) noexcept {
        return _Iter._Unwrapped();
    }
};
#line 328 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\array"

template <class _Ty, size_t _Size>
class _Array_iterator : public _Array_const_iterator<_Ty, _Size> {
public:
    using _Mybase = _Array_const_iterator<_Ty, _Size>;


    using iterator_concept = contiguous_iterator_tag;
#line 337 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\array"
    using iterator_category = random_access_iterator_tag;
    using value_type        = _Ty;
    using difference_type   = ptrdiff_t;
    using pointer           = _Ty*;
    using reference         = _Ty&;

    enum { _EEN_SIZE = _Size }; 

    constexpr _Array_iterator() noexcept {}

    constexpr explicit _Array_iterator(pointer _Parg, size_t _Off = 0) noexcept : _Mybase(_Parg, _Off) {}

    [[nodiscard]] constexpr reference operator*() const noexcept {
        return const_cast<reference>(_Mybase::operator*());
    }

    [[nodiscard]] constexpr pointer operator->() const noexcept {
        return const_cast<pointer>(_Mybase::operator->());
    }

    constexpr _Array_iterator& operator++() noexcept {
        _Mybase::operator++();
        return *this;
    }

    constexpr _Array_iterator operator++(int) noexcept {
        _Array_iterator _Tmp = *this;
        _Mybase::operator++();
        return _Tmp;
    }

    constexpr _Array_iterator& operator--() noexcept {
        _Mybase::operator--();
        return *this;
    }

    constexpr _Array_iterator operator--(int) noexcept {
        _Array_iterator _Tmp = *this;
        _Mybase::operator--();
        return _Tmp;
    }

    constexpr _Array_iterator& operator+=(const ptrdiff_t _Off) noexcept {
        _Mybase::operator+=(_Off);
        return *this;
    }

    [[nodiscard]] constexpr _Array_iterator operator+(const ptrdiff_t _Off) const noexcept {
        _Array_iterator _Tmp = *this;
        _Tmp += _Off;
        return _Tmp;
    }

    constexpr _Array_iterator& operator-=(const ptrdiff_t _Off) noexcept {
        _Mybase::operator-=(_Off);
        return *this;
    }

    using _Mybase::operator-;

    [[nodiscard]] constexpr _Array_iterator operator-(const ptrdiff_t _Off) const noexcept {
        _Array_iterator _Tmp = *this;
        _Tmp -= _Off;
        return _Tmp;
    }

    [[nodiscard]] constexpr reference operator[](const ptrdiff_t _Off) const noexcept {
        return const_cast<reference>(_Mybase::operator[](_Off));
    }

    using _Prevent_inheriting_unwrap = _Array_iterator;

    [[nodiscard]] constexpr pointer _Unwrapped() const noexcept {
        return const_cast<pointer>(_Mybase::_Unwrapped());
    }
};

template <class _Ty, size_t _Size>
[[nodiscard]] constexpr _Array_iterator<_Ty, _Size> operator+(
    const ptrdiff_t _Off, _Array_iterator<_Ty, _Size> _Next) noexcept {
    _Next += _Off;
    return _Next;
}


template <class _Ty, size_t _Size>
struct pointer_traits<_Array_iterator<_Ty, _Size>> {
    using pointer         = _Array_iterator<_Ty, _Size>;
    using element_type    = _Ty;
    using difference_type = ptrdiff_t;

    [[nodiscard]] static constexpr element_type* to_address(const pointer _Iter) noexcept {
        return _Iter._Unwrapped();
    }
};
#line 433 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\array"

template <class _Ty, size_t _Size>
class array { 
public:
    using value_type      = _Ty;
    using size_type       = size_t;
    using difference_type = ptrdiff_t;
    using pointer         = _Ty*;
    using const_pointer   = const _Ty*;
    using reference       = _Ty&;
    using const_reference = const _Ty&;

    using iterator       = _Array_iterator<_Ty, _Size>;
    using const_iterator = _Array_const_iterator<_Ty, _Size>;

    using reverse_iterator       = ::std:: reverse_iterator<iterator>;
    using const_reverse_iterator = ::std:: reverse_iterator<const_iterator>;


#line 456 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\array"

    constexpr void fill(const _Ty& _Value) {
        ::std:: fill_n(_Elems, _Size, _Value);
    }

    constexpr void swap(array& _Other) noexcept(_Is_nothrow_swappable<_Ty>::value) {
        _Swap_ranges_unchecked(_Elems, _Elems + _Size, _Other._Elems);
    }

    [[nodiscard]] constexpr iterator begin() noexcept {
        return iterator(_Elems, 0);
    }

    [[nodiscard]] constexpr const_iterator begin() const noexcept {
        return const_iterator(_Elems, 0);
    }

    [[nodiscard]] constexpr iterator end() noexcept {
        return iterator(_Elems, _Size);
    }

    [[nodiscard]] constexpr const_iterator end() const noexcept {
        return const_iterator(_Elems, _Size);
    }

    [[nodiscard]] constexpr reverse_iterator rbegin() noexcept {
        return reverse_iterator(end());
    }

    [[nodiscard]] constexpr const_reverse_iterator rbegin() const noexcept {
        return const_reverse_iterator(end());
    }

    [[nodiscard]] constexpr reverse_iterator rend() noexcept {
        return reverse_iterator(begin());
    }

    [[nodiscard]] constexpr const_reverse_iterator rend() const noexcept {
        return const_reverse_iterator(begin());
    }

    [[nodiscard]] constexpr const_iterator cbegin() const noexcept {
        return begin();
    }

    [[nodiscard]] constexpr const_iterator cend() const noexcept {
        return end();
    }

    [[nodiscard]] constexpr const_reverse_iterator crbegin() const noexcept {
        return rbegin();
    }

    [[nodiscard]] constexpr const_reverse_iterator crend() const noexcept {
        return rend();
    }

    constexpr _Ty* _Unchecked_begin() noexcept {
        return _Elems;
    }

    constexpr const _Ty* _Unchecked_begin() const noexcept {
        return _Elems;
    }

    constexpr _Ty* _Unchecked_end() noexcept {
        return _Elems + _Size;
    }

    constexpr const _Ty* _Unchecked_end() const noexcept {
        return _Elems + _Size;
    }

    [[nodiscard]] constexpr size_type size() const noexcept {
        return _Size;
    }

    [[nodiscard]] constexpr size_type max_size() const noexcept {
        return _Size;
    }

    [[nodiscard]] constexpr bool empty() const noexcept {
        return false;
    }

    [[nodiscard]] constexpr reference at(size_type _Pos) {
        if (_Size <= _Pos) {
            _Xran();
        }

        return _Elems[_Pos];
    }

    [[nodiscard]] constexpr const_reference at(size_type _Pos) const {
        if (_Size <= _Pos) {
            _Xran();
        }

        return _Elems[_Pos];
    }

    [[nodiscard]] constexpr reference operator[](  size_type _Pos) noexcept  {


#line 561 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\array"

        return _Elems[_Pos];
    }

    [[nodiscard]] constexpr const_reference operator[](  size_type _Pos) const noexcept
     {


#line 570 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\array"

        return _Elems[_Pos];
    }

    [[nodiscard]] constexpr reference front() noexcept  {
        return _Elems[0];
    }

    [[nodiscard]] constexpr const_reference front() const noexcept  {
        return _Elems[0];
    }

    [[nodiscard]] constexpr reference back() noexcept  {
        return _Elems[_Size - 1];
    }

    [[nodiscard]] constexpr const_reference back() const noexcept  {
        return _Elems[_Size - 1];
    }

    [[nodiscard]] constexpr _Ty* data() noexcept {
        return _Elems;
    }

    [[nodiscard]] constexpr const _Ty* data() const noexcept {
        return _Elems;
    }

    [[noreturn]] void _Xran() const {
        _Xout_of_range("invalid array<T, N> subscript");
    }

    _Ty _Elems[_Size];
};


template <class _First, class... _Rest>
struct _Enforce_same {
    static_assert(conjunction_v<is_same<_First, _Rest>...>,
        "N4687 26.3.7.2 [array.cons]/2: "
        "Requires: (is_same_v<T, U> && ...) is true. Otherwise the program is ill-formed.");
    using type = _First;
};

template <class _First, class... _Rest>
array(_First, _Rest...) -> array<typename _Enforce_same<_First, _Rest...>::type, 1 + sizeof...(_Rest)>;
#line 617 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\array"

struct _Empty_array_element {};

template <class _Ty>
class array<_Ty, 0> {
public:
    using value_type      = _Ty;
    using size_type       = size_t;
    using difference_type = ptrdiff_t;
    using pointer         = _Ty*;
    using const_pointer   = const _Ty*;
    using reference       = _Ty&;
    using const_reference = const _Ty&;

    using iterator               = _Array_iterator<_Ty, 0>;
    using const_iterator         = _Array_const_iterator<_Ty, 0>;
    using reverse_iterator       = ::std:: reverse_iterator<iterator>;
    using const_reverse_iterator = ::std:: reverse_iterator<const_iterator>;


#line 639 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\array"

    constexpr void fill(const _Ty&) {}

    constexpr void swap(array&) noexcept {}

    [[nodiscard]] constexpr iterator begin() noexcept {
        return iterator{};
    }

    [[nodiscard]] constexpr const_iterator begin() const noexcept {
        return const_iterator{};
    }

    [[nodiscard]] constexpr iterator end() noexcept {
        return iterator{};
    }

    [[nodiscard]] constexpr const_iterator end() const noexcept {
        return const_iterator{};
    }

    [[nodiscard]] constexpr reverse_iterator rbegin() noexcept {
        return reverse_iterator(end());
    }

    [[nodiscard]] constexpr const_reverse_iterator rbegin() const noexcept {
        return const_reverse_iterator(end());
    }

    [[nodiscard]] constexpr reverse_iterator rend() noexcept {
        return reverse_iterator(begin());
    }

    [[nodiscard]] constexpr const_reverse_iterator rend() const noexcept {
        return const_reverse_iterator(begin());
    }

    [[nodiscard]] constexpr const_iterator cbegin() const noexcept {
        return begin();
    }

    [[nodiscard]] constexpr const_iterator cend() const noexcept {
        return end();
    }

    [[nodiscard]] constexpr const_reverse_iterator crbegin() const noexcept {
        return rbegin();
    }

    [[nodiscard]] constexpr const_reverse_iterator crend() const noexcept {
        return rend();
    }

    constexpr _Ty* _Unchecked_begin() noexcept {
        return nullptr;
    }

    constexpr const _Ty* _Unchecked_begin() const noexcept {
        return nullptr;
    }

    constexpr _Ty* _Unchecked_end() noexcept {
        return nullptr;
    }

    constexpr const _Ty* _Unchecked_end() const noexcept {
        return nullptr;
    }

    [[nodiscard]] constexpr size_type size() const noexcept {
        return 0;
    }

    [[nodiscard]] constexpr size_type max_size() const noexcept {
        return 0;
    }

    [[nodiscard]] constexpr bool empty() const noexcept {
        return true;
    }

    [[noreturn]] reference at(size_type) {
        _Xran();
    }

    [[noreturn]] const_reference at(size_type) const {
        _Xran();
    }

    [[nodiscard]] reference operator[](size_type) noexcept  {


#line 732 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\array"

        return *data();
    }

    [[nodiscard]] const_reference operator[](size_type) const noexcept  {


#line 740 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\array"

        return *data();
    }

    [[nodiscard]] reference front() noexcept  {


#line 748 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\array"

        return *data();
    }

    [[nodiscard]] const_reference front() const noexcept  {


#line 756 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\array"

        return *data();
    }

    [[nodiscard]] reference back() noexcept  {


#line 764 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\array"

        return *data();
    }

    [[nodiscard]] const_reference back() const noexcept  {


#line 772 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\array"

        return *data();
    }

    [[nodiscard]] constexpr _Ty* data() noexcept {
        return nullptr;
    }

    [[nodiscard]] constexpr const _Ty* data() const noexcept {
        return nullptr;
    }

    [[noreturn]] void _Xran() const {
        _Xout_of_range("invalid array<T, 0> subscript");
    }

    conditional_t<disjunction_v<is_default_constructible<_Ty>, _Is_implicitly_default_constructible<_Ty>>, _Ty,
        _Empty_array_element>
        _Elems[1];
};

template <class _Ty, size_t _Size, enable_if_t<_Size == 0 || _Is_swappable<_Ty>::value, int> = 0>
constexpr void swap(array<_Ty, _Size>& _Left, array<_Ty, _Size>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
    return _Left.swap(_Right);
}

template <class _Ty, size_t _Size>
[[nodiscard]] constexpr bool operator==(const array<_Ty, _Size>& _Left, const array<_Ty, _Size>& _Right) {


    return ::std:: equal(_Left._Unchecked_begin(), _Left._Unchecked_end(), _Right._Unchecked_begin());
#line 805 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\array"
}


#line 813 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\array"


template <class _Ty, size_t _Size>
[[nodiscard]] constexpr _Synth_three_way_result<_Ty> operator<=>(
    const array<_Ty, _Size>& _Left, const array<_Ty, _Size>& _Right) {


    return ::std:: lexicographical_compare_three_way(_Left._Unchecked_begin(), _Left._Unchecked_end(),
        _Right._Unchecked_begin(), _Right._Unchecked_end(), _Synth_three_way{});
#line 825 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\array"
}


#line 852 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\array"


template <class _Ty, size_t _Size, size_t... _Idx>
[[nodiscard]] constexpr array<remove_cv_t<_Ty>, _Size> _To_array_lvalue_impl(
    _Ty (&_Array)[_Size], index_sequence<_Idx...>) {
    return {{_Array[_Idx]...}};
}

template <class _Ty, size_t _Size, size_t... _Idx>
[[nodiscard]] constexpr array<remove_cv_t<_Ty>, _Size> _To_array_rvalue_impl(
    _Ty(&&_Array)[_Size], index_sequence<_Idx...>) {
    return {{::std:: move(_Array[_Idx])...}};
}

template <class _Ty, size_t _Size>
[[nodiscard]] constexpr array<remove_cv_t<_Ty>, _Size> to_array(_Ty (&_Array)[_Size]) {
    static_assert(!is_array_v<_Ty>, "N4830 [array.creation]/1: "
                                    "to_array does not accept multidimensional arrays.");
    static_assert(is_constructible_v<_Ty, _Ty&>, "N4830 [array.creation]/1: "
                                                 "to_array requires copy constructible elements.");
    return _To_array_lvalue_impl(_Array, make_index_sequence<_Size>{});
}

template <class _Ty, size_t _Size>
[[nodiscard]] constexpr array<remove_cv_t<_Ty>, _Size> to_array(_Ty(&&_Array)[_Size]) {
    static_assert(!is_array_v<_Ty>, "N4830 [array.creation]/4: "
                                    "to_array does not accept multidimensional arrays.");
    static_assert(is_move_constructible_v<_Ty>, "N4830 [array.creation]/4: "
                                                "to_array requires move constructible elements.");
    return _To_array_rvalue_impl(::std:: move(_Array), make_index_sequence<_Size>{});
}
#line 884 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\array"

template <size_t _Idx, class _Ty, size_t _Size>
[[nodiscard]] constexpr _Ty& get(array<_Ty, _Size>& _Arr) noexcept {
    static_assert(_Idx < _Size, "array index out of bounds");
    return _Arr._Elems[_Idx];
}

template <size_t _Idx, class _Ty, size_t _Size>
[[nodiscard]] constexpr const _Ty& get(const array<_Ty, _Size>& _Arr) noexcept {
    static_assert(_Idx < _Size, "array index out of bounds");
    return _Arr._Elems[_Idx];
}

template <size_t _Idx, class _Ty, size_t _Size>
[[nodiscard]] constexpr _Ty&& get(array<_Ty, _Size>&& _Arr) noexcept {
    static_assert(_Idx < _Size, "array index out of bounds");
    return ::std:: move(_Arr._Elems[_Idx]);
}

template <size_t _Idx, class _Ty, size_t _Size>
[[nodiscard]] constexpr const _Ty&& get(const array<_Ty, _Size>&& _Arr) noexcept {
    static_assert(_Idx < _Size, "array index out of bounds");
    return ::std:: move(_Arr._Elems[_Idx]);
}


#line 915 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\array"
}


#pragma warning(pop)
#pragma pack(pop)
#line 922 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\array"
#line 923 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\array"
#line 57 "all-std.cxx"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"


#pragma once


#line 16 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
template <class _Mydeque>
class _Deque_unchecked_const_iterator {
private:
    using _Size_type = typename _Mydeque::size_type;

    static constexpr int _Block_size = _Mydeque::_Block_size;

public:
    using iterator_category = random_access_iterator_tag;

    using value_type      = typename _Mydeque::value_type;
    using difference_type = typename _Mydeque::difference_type;
    using pointer         = typename _Mydeque::const_pointer;
    using reference       = const value_type&;

    _Deque_unchecked_const_iterator() noexcept : _Mycont(), _Myoff(0) {}

    _Deque_unchecked_const_iterator(_Size_type _Off, const _Container_base12* _Pdeque) noexcept
        : _Mycont(static_cast<const _Mydeque*>(_Pdeque)), _Myoff(_Off) {}

    [[nodiscard]] reference operator*() const noexcept {
        _Size_type _Block = _Mycont->_Getblock(_Myoff);
        _Size_type _Off   = _Myoff % _Block_size;
        return _Mycont->_Map[_Block][_Off];
    }

    [[nodiscard]] pointer operator->() const noexcept {
        return pointer_traits<pointer>::pointer_to(**this);
    }

    _Deque_unchecked_const_iterator& operator++() noexcept {
        ++_Myoff;
        return *this;
    }

    _Deque_unchecked_const_iterator operator++(int) noexcept {
        _Deque_unchecked_const_iterator _Tmp = *this;
        ++_Myoff;
        return _Tmp;
    }

    _Deque_unchecked_const_iterator& operator--() noexcept {
        --_Myoff;
        return *this;
    }

    _Deque_unchecked_const_iterator operator--(int) noexcept {
        _Deque_unchecked_const_iterator _Tmp = *this;
        --_Myoff;
        return _Tmp;
    }

    _Deque_unchecked_const_iterator& operator+=(const difference_type _Off) noexcept {
        _Myoff += _Off;
        return *this;
    }

    [[nodiscard]] _Deque_unchecked_const_iterator operator+(const difference_type _Off) const noexcept {
        _Deque_unchecked_const_iterator _Tmp = *this;
        _Tmp += _Off;
        return _Tmp;
    }

    _Deque_unchecked_const_iterator& operator-=(const difference_type _Off) noexcept {
        _Myoff -= _Off;
        return *this;
    }

    [[nodiscard]] _Deque_unchecked_const_iterator operator-(const difference_type _Off) const noexcept {
        _Deque_unchecked_const_iterator _Tmp = *this;
        _Tmp -= _Off;
        return _Tmp;
    }

    [[nodiscard]] difference_type operator-(const _Deque_unchecked_const_iterator& _Right) const noexcept {
        return static_cast<difference_type>(_Myoff - _Right._Myoff);
    }

    [[nodiscard]] reference operator[](const difference_type _Off) const noexcept {
        return *(*this + _Off);
    }

    [[nodiscard]] bool operator==(const _Deque_unchecked_const_iterator& _Right) const noexcept {
        return _Myoff == _Right._Myoff;
    }


    [[nodiscard]] strong_ordering operator<=>(const _Deque_unchecked_const_iterator& _Right) const noexcept {
        return _Myoff <=> _Right._Myoff;
    }


#line 136 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"

    const _Container_base12* _Getcont() const noexcept { 
        return _Mycont;
    }

    const _Mydeque* _Mycont;
    _Size_type _Myoff; 
};

template <class _Mydeque>
[[nodiscard]] _Deque_unchecked_const_iterator<_Mydeque> operator+(
    typename _Deque_unchecked_const_iterator<_Mydeque>::difference_type _Off,
    _Deque_unchecked_const_iterator<_Mydeque> _Next) noexcept {
    _Next += _Off;
    return _Next;
}

template <class _Mydeque>
class _Deque_unchecked_iterator : public _Deque_unchecked_const_iterator<_Mydeque> {
private:
    using _Size_type = typename _Mydeque::size_type;
    using _Mybase    = _Deque_unchecked_const_iterator<_Mydeque>;

public:
    using iterator_category = random_access_iterator_tag;

    using value_type      = typename _Mydeque::value_type;
    using difference_type = typename _Mydeque::difference_type;
    using pointer         = typename _Mydeque::pointer;
    using reference       = value_type&;

    using _Mybase::_Mybase;

    [[nodiscard]] reference operator*() const noexcept {
        return const_cast<reference>(_Mybase::operator*());
    }

    [[nodiscard]] pointer operator->() const noexcept {
        return pointer_traits<pointer>::pointer_to(**this);
    }

    _Deque_unchecked_iterator& operator++() noexcept {
        _Mybase::operator++();
        return *this;
    }

    _Deque_unchecked_iterator operator++(int) noexcept {
        _Deque_unchecked_iterator _Tmp = *this;
        _Mybase::operator++();
        return _Tmp;
    }

    _Deque_unchecked_iterator& operator--() noexcept {
        _Mybase::operator--();
        return *this;
    }

    _Deque_unchecked_iterator operator--(int) noexcept {
        _Deque_unchecked_iterator _Tmp = *this;
        _Mybase::operator--();
        return _Tmp;
    }

    _Deque_unchecked_iterator& operator+=(const difference_type _Off) noexcept {
        _Mybase::operator+=(_Off);
        return *this;
    }

    [[nodiscard]] _Deque_unchecked_iterator operator+(const difference_type _Off) const noexcept {
        _Deque_unchecked_iterator _Tmp = *this;
        _Tmp += _Off;
        return _Tmp;
    }

    _Deque_unchecked_iterator& operator-=(const difference_type _Off) noexcept {
        _Mybase::operator-=(_Off);
        return *this;
    }

    [[nodiscard]] _Deque_unchecked_iterator operator-(const difference_type _Off) const noexcept {
        _Deque_unchecked_iterator _Tmp = *this;
        _Tmp -= _Off;
        return _Tmp;
    }

    [[nodiscard]] difference_type operator-(const _Mybase& _Right) const noexcept {
        return _Mybase::operator-(_Right);
    }

    [[nodiscard]] reference operator[](const difference_type _Off) const noexcept {
        return const_cast<reference>(_Mybase::operator[](_Off));
    }
};

template <class _Mydeque>
[[nodiscard]] _Deque_unchecked_iterator<_Mydeque> operator+(
    typename _Deque_unchecked_iterator<_Mydeque>::difference_type _Off,
    _Deque_unchecked_iterator<_Mydeque> _Next) noexcept {
    _Next += _Off;
    return _Next;
}

template <class _Mydeque>
class _Deque_const_iterator : public _Iterator_base12 {
private:
    using _Size_type = typename _Mydeque::size_type;

    static constexpr int _Block_size = _Mydeque::_Block_size;

public:
    using iterator_category = random_access_iterator_tag;

    using value_type      = typename _Mydeque::value_type;
    using difference_type = typename _Mydeque::difference_type;
    using pointer         = typename _Mydeque::const_pointer;
    using reference       = const value_type&;

    using _Mydeque_t = _Mydeque; 
    enum { _EEN_DS = _Block_size }; 
    _Deque_const_iterator() noexcept : _Myoff(0) {
        _Setcont(nullptr);
    }

    _Deque_const_iterator(_Size_type _Off, const _Container_base12* _Pdeque) noexcept : _Myoff(_Off) {
        _Setcont(static_cast<const _Mydeque*>(_Pdeque));
    }

    [[nodiscard]] reference operator*() const noexcept {
        const auto _Mycont = static_cast<const _Mydeque*>(this->_Getcont());


#line 270 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"

        _Size_type _Block = _Mycont->_Getblock(_Myoff);
        _Size_type _Off   = _Myoff % _Block_size;
        return _Mycont->_Map[_Block][_Off];
    }

    [[nodiscard]] pointer operator->() const noexcept {
        return pointer_traits<pointer>::pointer_to(**this);
    }

    _Deque_const_iterator& operator++() noexcept {


#line 286 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"

        ++_Myoff;
        return *this;
    }

    _Deque_const_iterator operator++(int) noexcept {
        _Deque_const_iterator _Tmp = *this;
        ++*this;
        return _Tmp;
    }

    _Deque_const_iterator& operator--() noexcept {


#line 303 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"

        --_Myoff;
        return *this;
    }

    _Deque_const_iterator operator--(int) noexcept {
        _Deque_const_iterator _Tmp = *this;
        --*this;
        return _Tmp;
    }

    _Deque_const_iterator& operator+=(const difference_type _Off) noexcept {


#line 324 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"

        _Myoff += _Off;
        return *this;
    }

    [[nodiscard]] _Deque_const_iterator operator+(const difference_type _Off) const noexcept {
        _Deque_const_iterator _Tmp = *this;
        _Tmp += _Off;
        return _Tmp;
    }

    _Deque_const_iterator& operator-=(const difference_type _Off) noexcept {
        return *this += -_Off;
    }

    [[nodiscard]] _Deque_const_iterator operator-(const difference_type _Off) const noexcept {
        _Deque_const_iterator _Tmp = *this;
        _Tmp -= _Off;
        return _Tmp;
    }

    [[nodiscard]] difference_type operator-(const _Deque_const_iterator& _Right) const noexcept {
        _Compat(_Right);
        return static_cast<difference_type>(this->_Myoff - _Right._Myoff);
    }

    [[nodiscard]] reference operator[](const difference_type _Off) const noexcept {
        return *(*this + _Off);
    }

    [[nodiscard]] bool operator==(const _Deque_const_iterator& _Right) const noexcept {
        _Compat(_Right);
        return this->_Myoff == _Right._Myoff;
    }


    [[nodiscard]] strong_ordering operator<=>(const _Deque_const_iterator& _Right) const noexcept {
        _Compat(_Right);
        return this->_Myoff <=> _Right._Myoff;
    }


#line 386 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"

    void _Compat(const _Deque_const_iterator& _Right) const noexcept { 

        (void) _Right;


#line 393 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"
    }

    void _Setcont(const _Mydeque* _Pdeque) noexcept { 
        this->_Adopt(_Pdeque);
    }

    using _Prevent_inheriting_unwrap = _Deque_const_iterator;

    [[nodiscard]] _Deque_unchecked_const_iterator<_Mydeque> _Unwrapped() const noexcept {
        return {this->_Myoff, this->_Getcont()};
    }

    void _Verify_offset(const difference_type _Off) const noexcept {

        (void) _Off;


#line 417 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"
    }


#line 425 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"

    void _Seek_to(const _Deque_unchecked_const_iterator<_Mydeque>& _UIt) noexcept {
        _Myoff = _UIt._Myoff;
    }

    _Size_type _Myoff; 
};

template <class _Mydeque>
[[nodiscard]] _Deque_const_iterator<_Mydeque> operator+(
    typename _Deque_const_iterator<_Mydeque>::difference_type _Off, _Deque_const_iterator<_Mydeque> _Next) noexcept {
    _Next += _Off;
    return _Next;
}

template <class _Mydeque>
class _Deque_iterator : public _Deque_const_iterator<_Mydeque> {
private:
    using _Size_type = typename _Mydeque::size_type;
    using _Mybase    = _Deque_const_iterator<_Mydeque>;

public:
    using _Deque_unchecked_type = _Deque_unchecked_iterator<_Mydeque>;
    using iterator_category     = random_access_iterator_tag;

    using value_type      = typename _Mydeque::value_type;
    using difference_type = typename _Mydeque::difference_type;
    using pointer         = typename _Mydeque::pointer;
    using reference       = value_type&;

    using _Mybase::_Mybase;

    [[nodiscard]] reference operator*() const noexcept {
        return const_cast<reference>(_Mybase::operator*());
    }

    [[nodiscard]] pointer operator->() const noexcept {
        return pointer_traits<pointer>::pointer_to(**this);
    }

    _Deque_iterator& operator++() noexcept {
        _Mybase::operator++();
        return *this;
    }

    _Deque_iterator operator++(int) noexcept {
        _Deque_iterator _Tmp = *this;
        _Mybase::operator++();
        return _Tmp;
    }

    _Deque_iterator& operator--() noexcept {
        _Mybase::operator--();
        return *this;
    }

    _Deque_iterator operator--(int) noexcept {
        _Deque_iterator _Tmp = *this;
        _Mybase::operator--();
        return _Tmp;
    }

    _Deque_iterator& operator+=(const difference_type _Off) noexcept {
        _Mybase::operator+=(_Off);
        return *this;
    }

    [[nodiscard]] _Deque_iterator operator+(const difference_type _Off) const noexcept {
        _Deque_iterator _Tmp = *this;
        _Tmp += _Off;
        return _Tmp;
    }

    _Deque_iterator& operator-=(const difference_type _Off) noexcept {
        _Mybase::operator-=(_Off);
        return *this;
    }

    using _Mybase::operator-;

    [[nodiscard]] _Deque_iterator operator-(const difference_type _Off) const noexcept {
        _Deque_iterator _Tmp = *this;
        _Tmp -= _Off;
        return _Tmp;
    }

    [[nodiscard]] reference operator[](const difference_type _Off) const noexcept {
        return const_cast<reference>(_Mybase::operator[](_Off));
    }

    using _Prevent_inheriting_unwrap = _Deque_iterator;

    [[nodiscard]] _Deque_unchecked_iterator<_Mydeque> _Unwrapped() const noexcept {
        return {this->_Myoff, this->_Getcont()};
    }
};

template <class _Mydeque>
[[nodiscard]] _Deque_iterator<_Mydeque> operator+(
    typename _Deque_iterator<_Mydeque>::difference_type _Off, _Deque_iterator<_Mydeque> _Next) noexcept {
    _Next += _Off;
    return _Next;
}

template <class _Value_type, class _Size_type, class _Difference_type, class _Pointer, class _Const_pointer,
    class _Reference, class _Const_reference, class _Mapptr_type>
struct _Deque_iter_types {
    using value_type      = _Value_type;
    using size_type       = _Size_type;
    using difference_type = _Difference_type;
    using pointer         = _Pointer;
    using const_pointer   = _Const_pointer;
    using _Mapptr         = _Mapptr_type;
};

template <class _Ty>
struct _Deque_simple_types : _Simple_types<_Ty> {
    using _Mapptr = _Ty**;
};

template <class _Val_types>
class _Deque_val : public _Container_base12 {
public:
    using value_type      = typename _Val_types::value_type;
    using size_type       = typename _Val_types::size_type;
    using difference_type = typename _Val_types::difference_type;
    using pointer         = typename _Val_types::pointer;
    using const_pointer   = typename _Val_types::const_pointer;
    using reference       = value_type&;
    using const_reference = const value_type&;
    using _Mapptr         = typename _Val_types::_Mapptr;

private:
    static constexpr size_t _Bytes = sizeof(value_type);

public:
    static constexpr int _Block_size = _Bytes <= 1 ? 16
                                     : _Bytes <= 2 ? 8
                                     : _Bytes <= 4 ? 4
                                     : _Bytes <= 8 ? 2
                                                   : 1; 

    _Deque_val() noexcept : _Map(), _Mapsize(0), _Myoff(0), _Mysize(0) {}

    size_type _Getblock(size_type _Off) const noexcept {
        
        return (_Off / _Block_size) & (_Mapsize - 1);
    }

    _Mapptr _Map; 
    size_type _Mapsize; 
    size_type _Myoff; 
    size_type _Mysize; 
};

template <class _Ty, class _Alloc = allocator<_Ty>>
class deque {
private:
    friend _Tidy_guard<deque>;
    static_assert(!1 || is_same_v<_Ty, typename _Alloc::value_type>,
        "deque<T, Allocator>" " requires that Allocator's value_type match " "T" " (See N4659 26.2.1 [container.requirements.general]/16 allocator_type)" " Either fix the allocator value_type or define _ENFORCE_MATCHING_ALLOCATORS=0" " to suppress this diagnostic.");

    using _Alty           = _Rebind_alloc_t<_Alloc, _Ty>;
    using _Alty_traits    = allocator_traits<_Alty>;
    using _Alpty          = _Rebind_alloc_t<_Alloc, typename _Alty_traits::pointer>;
    using _Alpty_traits   = allocator_traits<_Alpty>;
    using _Mapptr         = typename _Alpty_traits::pointer;
    using _Alproxy_ty     = _Rebind_alloc_t<_Alty, _Container_proxy>;
    using _Alproxy_traits = allocator_traits<_Alproxy_ty>;

    using _Scary_val = _Deque_val<conditional_t<_Is_simple_alloc_v<_Alty>, _Deque_simple_types<_Ty>,
        _Deque_iter_types<_Ty, typename _Alty_traits::size_type, typename _Alty_traits::difference_type,
            typename _Alty_traits::pointer, typename _Alty_traits::const_pointer, _Ty&, const _Ty&, _Mapptr>>>;

    static constexpr int _Minimum_map_size = 8;
    static constexpr int _Block_size       = _Scary_val::_Block_size;

public:
    using allocator_type  = _Alloc;
    using value_type      = _Ty;
    using size_type       = typename _Alty_traits::size_type;
    using difference_type = typename _Alty_traits::difference_type;
    using pointer         = typename _Alty_traits::pointer;
    using const_pointer   = typename _Alty_traits::const_pointer;
    using reference       = _Ty&;
    using const_reference = const _Ty&;

    using iterator                  = _Deque_iterator<_Scary_val>;
    using const_iterator            = _Deque_const_iterator<_Scary_val>;
    using _Unchecked_iterator       = _Deque_unchecked_iterator<_Scary_val>;
    using _Unchecked_const_iterator = _Deque_unchecked_const_iterator<_Scary_val>;

    using reverse_iterator       = ::std:: reverse_iterator<iterator>;
    using const_reverse_iterator = ::std:: reverse_iterator<const_iterator>;
    enum { _EEN_DS = _Block_size }; 

    deque() : _Mypair(_Zero_then_variadic_args_t{}) {
        _Get_data()._Alloc_proxy(static_cast<_Alproxy_ty>(_Getal()));
    }

    explicit deque(const _Alloc& _Al) : _Mypair(_One_then_variadic_args_t{}, _Al) {
        _Get_data()._Alloc_proxy(static_cast<_Alproxy_ty>(_Getal()));
    }

    explicit deque( size_type _Count, const _Alloc& _Al = _Alloc())
        : _Mypair(_One_then_variadic_args_t{}, _Al) {
        _Alproxy_ty _Alproxy(_Getal());
        _Container_proxy_ptr12<_Alproxy_ty> _Proxy(_Alproxy, _Get_data());
        resize(_Count);
        _Proxy._Release();
    }

    deque( size_type _Count, const _Ty& _Val) : _Mypair(_Zero_then_variadic_args_t{}) {
        _Alproxy_ty _Alproxy(_Getal());
        _Container_proxy_ptr12<_Alproxy_ty> _Proxy(_Alproxy, _Get_data());
        _Construct_n(_Count, _Val);
        _Proxy._Release();
    }

    deque( size_type _Count, const _Ty& _Val, const _Alloc& _Al)
        : _Mypair(_One_then_variadic_args_t{}, _Al) {
        _Alproxy_ty _Alproxy(_Getal());
        _Container_proxy_ptr12<_Alproxy_ty> _Proxy(_Alproxy, _Get_data());
        _Construct_n(_Count, _Val);
        _Proxy._Release();
    }

    deque(const deque& _Right)
        : _Mypair(_One_then_variadic_args_t{}, _Alty_traits::select_on_container_copy_construction(_Right._Getal())) {
        _Alproxy_ty _Alproxy(_Getal());
        _Container_proxy_ptr12<_Alproxy_ty> _Proxy(_Alproxy, _Get_data());
        _Construct(_Right._Unchecked_begin(), _Right._Unchecked_end());
        _Proxy._Release();
    }

    deque(const deque& _Right, const _Identity_t<_Alloc>& _Al) : _Mypair(_One_then_variadic_args_t{}, _Al) {
        _Alproxy_ty _Alproxy(_Getal());
        _Container_proxy_ptr12<_Alproxy_ty> _Proxy(_Alproxy, _Get_data());
        _Construct(_Right._Unchecked_begin(), _Right._Unchecked_end());
        _Proxy._Release();
    }

    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
    deque(_Iter _First, _Iter _Last) : _Mypair(_Zero_then_variadic_args_t{}) {
        _Alproxy_ty _Alproxy(_Getal());
        _Container_proxy_ptr12<_Alproxy_ty> _Proxy(_Alproxy, _Get_data());
        _Construct(_First, _Last);
        _Proxy._Release();
    }

    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
    deque(_Iter _First, _Iter _Last, const _Alloc& _Al) : _Mypair(_One_then_variadic_args_t{}, _Al) {
        _Alproxy_ty _Alproxy(_Getal());
        _Container_proxy_ptr12<_Alproxy_ty> _Proxy(_Alproxy, _Get_data());
        _Construct(_First, _Last);
        _Proxy._Release();
    }

private:
    template <class _Iter>
    void _Construct(_Iter _First, _Iter _Last) { 
        _Tidy_guard<deque> _Guard{this};
        for (; _First != _Last; ++_First) {
            emplace_back(*_First);
        }

        _Guard._Target = nullptr;
    }

    void _Construct_n(size_type _Count, const _Ty& _Val) { 
        _Tidy_guard<deque> _Guard{this};
        for (; 0 < _Count; --_Count) {
            _Emplace_back_internal(_Val);
        }

        _Guard._Target = nullptr;
    }

public:
    deque(deque&& _Right) : _Mypair(_One_then_variadic_args_t{}, ::std:: move(_Right._Getal())) {
        _Get_data()._Alloc_proxy(static_cast<_Alproxy_ty>(_Getal()));
        _Take_contents(_Right);
    }

    deque(deque&& _Right, const _Identity_t<_Alloc>& _Al) : _Mypair(_One_then_variadic_args_t{}, _Al) {
        _Alproxy_ty _Alproxy(_Getal());
        if constexpr (!_Alty_traits::is_always_equal::value) {
            if (_Getal() != _Right._Getal()) {
                _Container_proxy_ptr12<_Alproxy_ty> _Proxy(_Alproxy, _Get_data());
                _Construct(::std:: make_move_iterator(_Right._Unchecked_begin()),
                    ::std:: make_move_iterator(_Right._Unchecked_end()));
                _Proxy._Release();
                return;
            }
        }

        _Get_data()._Alloc_proxy(_Alproxy);
        _Take_contents(_Right);
    }

public:
    deque& operator=(deque&& _Right) noexcept(_Alty_traits::is_always_equal::value) {
        if (this == ::std:: addressof(_Right)) {
            return *this;
        }

        auto& _Al                 = _Getal();
        auto& _Right_al           = _Right._Getal();
        constexpr auto _Pocma_val = _Choose_pocma_v<_Alty>;
        if constexpr (_Pocma_val == _Pocma_values::_Propagate_allocators) {
            if (_Al != _Right_al) {
                _Alproxy_ty _Alproxy(_Al);
                _Alproxy_ty _Right_alproxy(_Right_al);
                _Container_proxy_ptr12<_Alproxy_ty> _Proxy(_Right_alproxy, _Leave_proxy_unbound{});
                _Tidy();
                _Pocma(_Al, _Right_al);
                _Proxy._Bind(_Alproxy, ::std:: addressof(_Get_data()));
                _Take_contents(_Right);
                return *this;
            }
        } else if constexpr (_Pocma_val == _Pocma_values::_No_propagate_allocators) {
            if (_Al != _Right_al) {
                assign(::std:: make_move_iterator(_Right._Unchecked_begin()),
                    ::std:: make_move_iterator(_Right._Unchecked_end()));
                return *this;
            }
        }

        _Tidy();
        _Pocma(_Al, _Right_al);
        _Take_contents(_Right);

        return *this;
    }

private:
    void _Take_contents(deque& _Right) noexcept {
        
        
        auto& _My_data    = _Get_data();
        auto& _Right_data = _Right._Get_data();
        _My_data._Swap_proxy_and_iterators(_Right_data);
        _My_data._Map     = _Right_data._Map;
        _My_data._Mapsize = _Right_data._Mapsize;
        _My_data._Myoff   = _Right_data._Myoff;
        _My_data._Mysize  = _Right_data._Mysize;

        _Right_data._Map     = nullptr;
        _Right_data._Mapsize = 0;
        _Right_data._Myoff   = 0;
        _Right_data._Mysize  = 0;
    }

public:
    void push_front(_Ty&& _Val) {
        emplace_front(::std:: move(_Val));
    }

    void push_back(_Ty&& _Val) {
        _Orphan_all();
        _Emplace_back_internal(::std:: move(_Val));
    }

    iterator insert(const_iterator _Where, _Ty&& _Val) {
        return emplace(_Where, ::std:: move(_Val));
    }

    template <class... _Valty>
    decltype(auto) emplace_front(_Valty&&... _Val) {
        _Orphan_all();

        if (_Myoff() % _Block_size == 0 && _Mapsize() <= (_Mysize() + _Block_size) / _Block_size) {
            _Growmap(1);
        }
        _Myoff() &= _Mapsize() * _Block_size - 1;
        size_type _Newoff = _Myoff() != 0 ? _Myoff() : _Mapsize() * _Block_size;
        size_type _Block  = _Getblock(--_Newoff);
        if (_Map()[_Block] == nullptr) {
            _Map()[_Block] = _Getal().allocate(_Block_size);
        }

        _Alty_traits::construct(
            _Getal(), _Unfancy(_Map()[_Block] + _Newoff % _Block_size), ::std:: forward<_Valty>(_Val)...);

        _Myoff() = _Newoff;
        ++_Mysize();


        return front();
#line 815 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"
    }

    template <class... _Valty>
    decltype(auto) emplace_back(_Valty&&... _Val) {
        _Orphan_all();
        _Emplace_back_internal(::std:: forward<_Valty>(_Val)...);


        return back();
#line 825 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"
    }

    template <class... _Valty>
    iterator emplace(const_iterator _Where, _Valty&&... _Val) {
        const auto _Off = static_cast<size_type>(_Where - begin());


#line 834 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"

        if (_Off <= _Mysize() / 2) { 
            emplace_front(::std:: forward<_Valty>(_Val)...);
            ::std:: rotate(begin(), _Next_iter(begin()), begin() + static_cast<difference_type>(1 + _Off));
        } else { 
            emplace_back(::std:: forward<_Valty>(_Val)...);
            ::std:: rotate(begin() + static_cast<difference_type>(_Off), _Prev_iter(end()), end());
        }
        return begin() + static_cast<difference_type>(_Off);
    }

    deque(initializer_list<_Ty> _Ilist, const _Alloc& _Al = allocator_type())
        : _Mypair(_One_then_variadic_args_t{}, _Al) {
        _Alproxy_ty _Alproxy(_Getal());
        _Container_proxy_ptr12<_Alproxy_ty> _Proxy(_Alproxy, _Get_data());
        _Construct(_Ilist.begin(), _Ilist.end());
        _Proxy._Release();
    }

    deque& operator=(initializer_list<_Ty> _Ilist) {
        assign(_Ilist.begin(), _Ilist.end());
        return *this;
    }

    void assign(initializer_list<_Ty> _Ilist) {
        assign(_Ilist.begin(), _Ilist.end());
    }

    iterator insert(const_iterator _Where, initializer_list<_Ty> _Ilist) {
        return insert(_Where, _Ilist.begin(), _Ilist.end());
    }

    ~deque() noexcept {
        _Tidy();
        _Alproxy_ty _Proxy_allocator(_Getal());
        _Delete_plain_internal(_Proxy_allocator, ::std:: exchange(_Get_data()._Myproxy, nullptr));
    }

    deque& operator=(const deque& _Right) {
        if (this == ::std:: addressof(_Right)) {
            return *this;
        }

        auto& _Al       = _Getal();
        auto& _Right_al = _Right._Getal();
        if constexpr (_Choose_pocca_v<_Alty>) {
            if (_Al != _Right_al) {
                _Tidy();
                _Get_data()._Reload_proxy(static_cast<_Alproxy_ty>(_Al), static_cast<_Alproxy_ty>(_Right_al));
            }
        }

        _Pocca(_Al, _Right_al);
        assign(_Right._Unchecked_begin(), _Right._Unchecked_end());

        return *this;
    }

    [[nodiscard]] iterator begin() noexcept {
        return iterator(_Myoff(), ::std:: addressof(_Get_data()));
    }

    [[nodiscard]] const_iterator begin() const noexcept {
        return const_iterator(_Myoff(), ::std:: addressof(_Get_data()));
    }

    [[nodiscard]] iterator end() noexcept {
        return iterator(_Myoff() + _Mysize(), ::std:: addressof(_Get_data()));
    }

    [[nodiscard]] const_iterator end() const noexcept {
        return const_iterator(_Myoff() + _Mysize(), ::std:: addressof(_Get_data()));
    }

    _Unchecked_iterator _Unchecked_begin() noexcept {
        return _Unchecked_iterator(_Myoff(), ::std:: addressof(_Get_data()));
    }

    _Unchecked_const_iterator _Unchecked_begin() const noexcept {
        return _Unchecked_const_iterator(_Myoff(), ::std:: addressof(_Get_data()));
    }

    _Unchecked_iterator _Unchecked_end() noexcept {
        return _Unchecked_iterator(_Myoff() + _Mysize(), ::std:: addressof(_Get_data()));
    }

    _Unchecked_const_iterator _Unchecked_end() const noexcept {
        return _Unchecked_const_iterator(_Myoff() + _Mysize(), ::std:: addressof(_Get_data()));
    }

    iterator _Make_iter(const_iterator _Where) const noexcept {
        return iterator(_Where._Myoff, ::std:: addressof(_Get_data()));
    }

    [[nodiscard]] reverse_iterator rbegin() noexcept {
        return reverse_iterator(end());
    }

    [[nodiscard]] const_reverse_iterator rbegin() const noexcept {
        return const_reverse_iterator(end());
    }

    [[nodiscard]] reverse_iterator rend() noexcept {
        return reverse_iterator(begin());
    }

    [[nodiscard]] const_reverse_iterator rend() const noexcept {
        return const_reverse_iterator(begin());
    }

    [[nodiscard]] const_iterator cbegin() const noexcept {
        return begin();
    }

    [[nodiscard]] const_iterator cend() const noexcept {
        return end();
    }

    [[nodiscard]] const_reverse_iterator crbegin() const noexcept {
        return rbegin();
    }

    [[nodiscard]] const_reverse_iterator crend() const noexcept {
        return rend();
    }

    void shrink_to_fit() {
        size_type _Oldcapacity = _Block_size * _Mapsize();
        size_type _Newcapacity = _Oldcapacity / 2;

        if (_Newcapacity < _Block_size * _Minimum_map_size) {
            _Newcapacity = _Block_size * _Minimum_map_size;
        }

        if ((empty() && 0 < _Mapsize())
            || (!empty() && size() <= _Newcapacity && _Newcapacity < _Oldcapacity)) { 
            deque _Tmp(::std:: make_move_iterator(begin()), ::std:: make_move_iterator(end()));
            swap(_Tmp);
        }
    }

    void resize( size_type _Newsize) {
        while (_Mysize() < _Newsize) {
            emplace_back();
        }

        while (_Newsize < _Mysize()) {
            pop_back();
        }
    }

    void resize( size_type _Newsize, const _Ty& _Val) {
        _Orphan_all();
        while (_Mysize() < _Newsize) {
            _Emplace_back_internal(_Val);
        }

        while (_Newsize < _Mysize()) {
            pop_back();
        }
    }

    [[nodiscard]] size_type size() const noexcept {
        return _Mysize();
    }

    [[nodiscard]] size_type max_size() const noexcept {
        return (::std:: min)(
            static_cast<size_type>((numeric_limits<difference_type>::max)()), _Alty_traits::max_size(_Getal()));
    }

    [[nodiscard]] bool empty() const noexcept {
        return _Mysize() == 0;
    }

    [[nodiscard]] allocator_type get_allocator() const noexcept {
        return static_cast<allocator_type>(_Getal());
    }

    [[nodiscard]] const_reference at(size_type _Pos) const {
        if (_Mysize() <= _Pos) {
            _Xran();
        }

        return *(begin() + static_cast<difference_type>(_Pos));
    }

    [[nodiscard]] reference at(size_type _Pos) {
        if (_Mysize() <= _Pos) {
            _Xran();
        }

        return *(begin() + static_cast<difference_type>(_Pos));
    }

    [[nodiscard]] const_reference operator[](size_type _Pos) const noexcept  {


#line 1033 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"

        return *(_Unchecked_begin() + static_cast<difference_type>(_Pos));
    }

    [[nodiscard]] reference operator[](size_type _Pos) noexcept  {


#line 1041 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"

        return *(_Unchecked_begin() + static_cast<difference_type>(_Pos));
    }

    [[nodiscard]] reference front() noexcept  {


#line 1049 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"

        return *_Unchecked_begin();
    }

    [[nodiscard]] const_reference front() const noexcept  {


#line 1057 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"

        return *_Unchecked_begin();
    }

    [[nodiscard]] reference back() noexcept  {


#line 1065 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"

        return *_Prev_iter(_Unchecked_end());
    }

    [[nodiscard]] const_reference back() const noexcept  {


#line 1073 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"

        return *_Prev_iter(_Unchecked_end());
    }

    void push_front(const _Ty& _Val) {
        emplace_front(_Val);
    }

    void pop_front() noexcept  {


#line 1097 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"
        size_type _Block = _Getblock(_Myoff());
        _Alty_traits::destroy(_Getal(), _Unfancy(_Map()[_Block] + _Myoff() % _Block_size));
        if (--_Mysize() == 0) {
            _Myoff() = 0;
        } else {
            ++_Myoff();
        }
#line 1105 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"
    }

private:
    template <class... _Tys>
    void _Emplace_back_internal(_Tys&&... _Vals) {
        if ((_Myoff() + _Mysize()) % _Block_size == 0 && _Mapsize() <= (_Mysize() + _Block_size) / _Block_size) {
            _Growmap(1);
        }
        _Myoff() &= _Mapsize() * _Block_size - 1;
        size_type _Newoff = _Myoff() + _Mysize();
        size_type _Block  = _Getblock(_Newoff);
        if (_Map()[_Block] == nullptr) {
            _Map()[_Block] = _Getal().allocate(_Block_size);
        }

        _Alty_traits::construct(
            _Getal(), _Unfancy(_Map()[_Block] + _Newoff % _Block_size), ::std:: forward<_Tys>(_Vals)...);

        ++_Mysize();
    }

public:
    void push_back(const _Ty& _Val) {
        _Orphan_all();
        _Emplace_back_internal(_Val);
    }

    void pop_back() noexcept  {


#line 1147 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"
        size_type _Newoff = _Myoff() + _Mysize() - 1;
        size_type _Block  = _Getblock(_Newoff);
        _Alty_traits::destroy(_Getal(), _Unfancy(_Map()[_Block] + _Newoff % _Block_size));
        if (--_Mysize() == 0) {
            _Myoff() = 0;
        }
#line 1154 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"
    }

    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
    void assign(_Iter _First, _Iter _Last) {
        _Orphan_all();
        _Adl_verify_range(_First, _Last);
        auto _UFirst       = _Get_unwrapped(_First);
        const auto _ULast  = _Get_unwrapped(_Last);
        auto _Myfirst      = _Unchecked_begin();
        const auto _Mylast = _Unchecked_end();
        for (; _UFirst != _ULast; ++_UFirst) { 
            if (_Myfirst == _Mylast) { 
                do {
                    emplace_back(*_UFirst);
                    ++_UFirst;
                } while (_UFirst != _ULast);
                return;
            }

            *_Myfirst = *_UFirst;
            ++_Myfirst;
        }

        _Erase_last_n(static_cast<size_type>(_Mylast - _Myfirst));
    }

    void assign( size_type _Count, const _Ty& _Val) { 
        _Orphan_all();
        auto _Myfirst       = _Unchecked_begin();
        const auto _Oldsize = _Mysize();
        auto _Assign_count  = (::std:: min)(_Count, _Oldsize);
        for (; 0 < _Assign_count; --_Assign_count) {
            *_Myfirst = _Val;
            ++_Myfirst;
        }

        const auto _Shrink_by = _Oldsize - _Assign_count;
        auto _Extend_by       = _Count - _Assign_count;
        _Erase_last_n(_Shrink_by);
        for (; 0 < _Extend_by; --_Extend_by) {
            _Emplace_back_internal(_Val);
        }
    }

    iterator insert(const_iterator _Where, const _Ty& _Val) {
        size_type _Off = static_cast<size_type>(_Where - begin());


#line 1204 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"

        if (_Off <= _Mysize() / 2) { 
            push_front(_Val);
            ::std:: rotate(begin(), _Next_iter(begin()), begin() + static_cast<difference_type>(1 + _Off));
        } else { 
            push_back(_Val);
            ::std:: rotate(begin() + static_cast<difference_type>(_Off), _Prev_iter(end()), end());
        }

        return begin() + static_cast<difference_type>(_Off);
    }

    iterator insert(const_iterator _Where,  size_type _Count, const _Ty& _Val) {
        
        size_type _Off = static_cast<size_type>(_Where - begin());
        _Insert_n(_Where, _Count, _Val);
        return begin() + static_cast<difference_type>(_Off);
    }

    template <class _Iter, enable_if_t<_Is_iterator_v<_Iter>, int> = 0>
    iterator insert(const_iterator _Where, _Iter _First, _Iter _Last) {
        
        size_type _Off = static_cast<size_type>(_Where - begin());


#line 1231 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"

        _Adl_verify_range(_First, _Last);
        auto _UFirst      = _Get_unwrapped(_First);
        const auto _ULast = _Get_unwrapped(_Last);

        size_type _Oldsize = _Mysize();

        if (_UFirst != _ULast) {
            if (_Off <= _Mysize() / 2) { 
                try {
                for (; _UFirst != _ULast; ++_UFirst) {
                    emplace_front(*_UFirst); 
                }

                } catch (...) {
                while (_Oldsize < _Mysize()) {
                    pop_front(); 
                }

                throw;
                }

                size_type _Num = _Mysize() - _Oldsize;
                ::std:: reverse(begin(), begin() + static_cast<difference_type>(_Num)); 
                ::std:: rotate(begin(), begin() + static_cast<difference_type>(_Num),
                    begin() + static_cast<difference_type>(_Num + _Off));
            } else { 
                try {
                _Orphan_all();
                for (; _UFirst != _ULast; ++_UFirst) {
                    _Emplace_back_internal(*_UFirst);
                }

                } catch (...) {
                while (_Oldsize < _Mysize()) {
                    pop_back(); 
                }

                throw;
                }

                ::std:: rotate(begin() + static_cast<difference_type>(_Off),
                    begin() + static_cast<difference_type>(_Oldsize), end());
            }
        }

        return begin() + static_cast<difference_type>(_Off);
    }

    iterator erase(const_iterator _Where) noexcept(is_nothrow_move_assignable_v<value_type>)  {
        return erase(_Where, _Next_iter(_Where));
    }

    iterator erase(const_iterator _First_arg, const_iterator _Last_arg) noexcept(
        is_nothrow_move_assignable_v<value_type>)  {
        iterator _First = _Make_iter(_First_arg);
        iterator _Last  = _Make_iter(_Last_arg);


#line 1298 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"
        auto _Off   = static_cast<size_type>(_First - begin());
        auto _Count = static_cast<size_type>(_Last - _First);
#line 1301 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"

        if (_Count == 0) {
            return _First;
        }

        if (_Off < static_cast<size_type>(end() - _Last)) { 
            ::std:: move_backward(begin(), _First, _Last); 
            for (; 0 < _Count; --_Count) {
                pop_front(); 
            }
        } else { 
            ::std:: move(_Last, end(), _First); 
            for (; 0 < _Count; --_Count) {
                pop_back(); 
            }
        }


#line 1323 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"

        return begin() + static_cast<difference_type>(_Off);
    }

private:
    void _Erase_last_n(size_type _Count) noexcept {
        for (; 0 < _Count; --_Count) {
            pop_back();
        }
    }

public:
    void clear() noexcept { 
        _Tidy();
    }

    void swap(deque& _Right) noexcept  {
        if (this != ::std:: addressof(_Right)) {
            _Pocs(_Getal(), _Right._Getal());
            auto& _My_data    = _Get_data();
            auto& _Right_data = _Right._Get_data();
            _My_data._Swap_proxy_and_iterators(_Right_data);
            _Swap_adl(_My_data._Map, _Right_data._Map);
            ::std:: swap(_My_data._Mapsize, _Right_data._Mapsize);
            ::std:: swap(_My_data._Myoff, _Right_data._Myoff);
            ::std:: swap(_My_data._Mysize, _Right_data._Mysize);
        }
    }

private:
    void _Insert_n(const_iterator _Where, size_type _Count, const _Ty& _Val) { 
        iterator _Mid;
        size_type _Num;
        size_type _Off     = static_cast<size_type>(_Where - begin());
        size_type _Oldsize = _Mysize();
        size_type _Rem     = _Oldsize - _Off;


#line 1363 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"

        if (_Off < _Rem) { 
            try {
            if (_Off < _Count) { 
                for (_Num = _Count - _Off; 0 < _Num; --_Num) {
                    push_front(_Val); 
                }
                for (_Num = _Off; 0 < _Num; --_Num) {
                    push_front(begin()[static_cast<difference_type>(_Count - 1)]); 
                }

                _Mid = begin() + static_cast<difference_type>(_Count);
                ::std:: fill(_Mid, _Mid + static_cast<difference_type>(_Off), _Val); 
            } else { 
                for (_Num = _Count; 0 < _Num; --_Num) {
                    push_front(begin()[static_cast<difference_type>(_Count - 1)]); 
                }

                _Mid = begin() + static_cast<difference_type>(_Count);
                _Alloc_temporary2<_Alty> _Tmp(_Getal(), _Val); 
                ::std:: move(_Mid + static_cast<difference_type>(_Count), _Mid + static_cast<difference_type>(_Off),
                    _Mid); 
                ::std:: fill(begin() + static_cast<difference_type>(_Off), _Mid + static_cast<difference_type>(_Off),
                    _Tmp._Get_value()); 
            }
            } catch (...) {
            while (_Oldsize < _Mysize()) {
                pop_front(); 
            }

            throw;
            }
        } else { 
            try {
            if (_Rem < _Count) { 
                _Orphan_all();
                for (_Num = _Count - _Rem; 0 < _Num; --_Num) {
                    _Emplace_back_internal(_Val); 
                }
                for (_Num = 0; _Num < _Rem; ++_Num) {
                    _Emplace_back_internal(begin()[static_cast<difference_type>(_Off + _Num)]); 
                }

                _Mid = begin() + static_cast<difference_type>(_Off);
                ::std:: fill(_Mid, _Mid + static_cast<difference_type>(_Rem), _Val); 
            } else { 
                for (_Num = 0; _Num < _Count; ++_Num) {
                    _Emplace_back_internal(
                        begin()[static_cast<difference_type>(_Off + _Rem - _Count + _Num)]); 
                }

                _Mid = begin() + static_cast<difference_type>(_Off);
                _Alloc_temporary2<_Alty> _Tmp(_Getal(), _Val); 
                ::std:: move_backward(_Mid, _Mid + static_cast<difference_type>(_Rem - _Count),
                    _Mid + static_cast<difference_type>(_Rem)); 
                ::std:: fill(_Mid, _Mid + static_cast<difference_type>(_Count),
                    _Tmp._Get_value()); 
            }
            } catch (...) {
            _Erase_last_n(_Mysize() - _Oldsize);
            throw;
            }
        }
    }

    [[noreturn]] void _Xlen() const {
        _Xlength_error("deque<T> too long");
    }

    [[noreturn]] void _Xran() const {
        _Xout_of_range("invalid deque<T> subscript");
    }

    void _Growmap(size_type _Count) { 
        static_assert(1 < _Minimum_map_size, "The _Xlen() test should always be performed.");

        _Alpty _Almap(_Getal());
        size_type _Newsize = 0 < _Mapsize() ? _Mapsize() : 1;
        while (_Newsize - _Mapsize() < _Count || _Newsize < _Minimum_map_size) {
            
            if (max_size() / _Block_size - _Newsize < _Newsize) {
                _Xlen(); 
            }

            _Newsize *= 2;
        }
        _Count = _Newsize - _Mapsize();

        size_type _Myboff = _Myoff() / _Block_size;
        _Mapptr _Newmap   = _Almap.allocate(_Mapsize() + _Count);
        _Mapptr _Myptr    = _Newmap + _Myboff;

        _Myptr = ::std:: uninitialized_copy(_Map() + _Myboff, _Map() + _Mapsize(), _Myptr); 
        if (_Myboff <= _Count) { 
            _Myptr = ::std:: uninitialized_copy(_Map(), _Map() + _Myboff, _Myptr); 
            _Uninitialized_value_construct_n_unchecked1(_Myptr, _Count - _Myboff); 
            _Uninitialized_value_construct_n_unchecked1(_Newmap, _Myboff); 
        } else { 
            ::std:: uninitialized_copy(_Map(), _Map() + _Count, _Myptr); 
            _Myptr = ::std:: uninitialized_copy(_Map() + _Count, _Map() + _Myboff, _Newmap); 
            _Uninitialized_value_construct_n_unchecked1(_Myptr, _Count); 
        }

        _Destroy_range(_Map() + _Myboff, _Map() + _Mapsize());
        if (_Map() != _Mapptr()) {
            _Almap.deallocate(_Map(), _Mapsize()); 
        }

        _Map() = _Newmap; 
        _Mapsize() += _Count;
    }

    void _Tidy() noexcept { 
        _Orphan_all();

        _Alpty _Almap(_Getal());
        while (!empty()) {
            pop_back();
        }

        for (size_type _Block = _Mapsize(); 0 < _Block;) { 
            if (_Map()[--_Block]) { 
                _Getal().deallocate(_Map()[_Block], _Block_size);
                _Destroy_in_place(_Map()[_Block]);
            }
        }

        if (_Map() != _Mapptr()) {
            _Almap.deallocate(_Map(), _Mapsize()); 
        }

        _Mapsize() = 0;
        _Map()     = _Mapptr();
    }


#line 1518 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"

    size_type _Getblock(size_type _Off) const noexcept {
        return _Get_data()._Getblock(_Off);
    }

    void _Orphan_all() noexcept {
        _Get_data()._Orphan_all();
    }

    _Alty& _Getal() noexcept {
        return _Mypair._Get_first();
    }

    const _Alty& _Getal() const noexcept {
        return _Mypair._Get_first();
    }

    _Scary_val& _Get_data() noexcept {
        return _Mypair._Myval2;
    }

    const _Scary_val& _Get_data() const noexcept {
        return _Mypair._Myval2;
    }

    _Mapptr& _Map() noexcept {
        return _Get_data()._Map;
    }

    const _Mapptr& _Map() const noexcept {
        return _Get_data()._Map;
    }

    size_type& _Mapsize() noexcept {
        return _Get_data()._Mapsize;
    }

    const size_type& _Mapsize() const noexcept {
        return _Get_data()._Mapsize;
    }

    size_type& _Myoff() noexcept {
        return _Get_data()._Myoff;
    }

    const size_type& _Myoff() const noexcept {
        return _Get_data()._Myoff;
    }

    size_type& _Mysize() noexcept {
        return _Get_data()._Mysize;
    }

    const size_type& _Mysize() const noexcept {
        return _Get_data()._Mysize;
    }

    _Compressed_pair<_Alty, _Scary_val> _Mypair;
};


template <class _Iter, class _Alloc = allocator<_Iter_value_t<_Iter>>,
    enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
deque(_Iter, _Iter, _Alloc = _Alloc()) -> deque<_Iter_value_t<_Iter>, _Alloc>;
#line 1583 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"

template <class _Ty, class _Alloc>
void swap(deque<_Ty, _Alloc>& _Left, deque<_Ty, _Alloc>& _Right) noexcept  {
    _Left.swap(_Right);
}

template <class _Ty, class _Alloc>
[[nodiscard]] bool operator==(const deque<_Ty, _Alloc>& _Left, const deque<_Ty, _Alloc>& _Right) {
    return _Left.size() == _Right.size()
        && ::std:: equal(_Left._Unchecked_begin(), _Left._Unchecked_end(), _Right._Unchecked_begin());
}


#line 1601 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"


template <class _Ty, class _Alloc>
[[nodiscard]] _Synth_three_way_result<_Ty> operator<=>(const deque<_Ty, _Alloc>& _Left, const deque<_Ty, _Alloc>& _Right) {
    return ::std:: lexicographical_compare_three_way(_Left._Unchecked_begin(), _Left._Unchecked_end(),
        _Right._Unchecked_begin(), _Right._Unchecked_end(), _Synth_three_way{});
}


#line 1630 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"


template <class _Ty, class _Alloc, class _Uty>
typename deque<_Ty, _Alloc>::size_type erase(deque<_Ty, _Alloc>& _Cont, const _Uty& _Val) {
    return _Erase_remove(_Cont, _Val);
}

template <class _Ty, class _Alloc, class _Pr>
typename deque<_Ty, _Alloc>::size_type erase_if(deque<_Ty, _Alloc>& _Cont, _Pr _Pred) {
    return _Erase_remove_if(_Cont, _Pass_fn(_Pred));
}
#line 1642 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"


namespace pmr {
    template <class _Ty>
    using deque = ::std:: deque<_Ty, polymorphic_allocator<_Ty>>;
} 
#line 1649 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"
}


#pragma warning(pop)
#pragma pack(pop)
#line 1656 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"
#line 1657 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\deque"
#line 58 "all-std.cxx"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\map"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtree"


#pragma once


#line 16 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtree"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
template <class _Mytree, class _Base = _Iterator_base0>
class _Tree_unchecked_const_iterator : public _Base {
public:
    using iterator_category = bidirectional_iterator_tag;

    using _Nodeptr        = typename _Mytree::_Nodeptr;
    using value_type      = typename _Mytree::value_type;
    using difference_type = typename _Mytree::difference_type;
    using pointer         = typename _Mytree::const_pointer;
    using reference       = const value_type&;

    _Tree_unchecked_const_iterator() noexcept : _Ptr() {}

    _Tree_unchecked_const_iterator(_Nodeptr _Pnode, const _Mytree* _Plist) noexcept : _Ptr(_Pnode) {
        this->_Adopt(_Plist);
    }

    [[nodiscard]] reference operator*() const noexcept {
        return _Ptr->_Myval;
    }

    [[nodiscard]] pointer operator->() const noexcept {
        return pointer_traits<pointer>::pointer_to(**this);
    }

    _Tree_unchecked_const_iterator& operator++() noexcept {
        if (_Ptr->_Right->_Isnil) { 
            _Nodeptr _Pnode;
            while (!(_Pnode = _Ptr->_Parent)->_Isnil && _Ptr == _Pnode->_Right) {
                _Ptr = _Pnode; 
            }

            _Ptr = _Pnode; 
        } else {
            _Ptr = _Mytree::_Min(_Ptr->_Right); 
        }

        return *this;
    }

    _Tree_unchecked_const_iterator operator++(int) noexcept {
        _Tree_unchecked_const_iterator _Tmp = *this;
        ++*this;
        return _Tmp;
    }

    _Tree_unchecked_const_iterator& operator--() noexcept {
        if (_Ptr->_Isnil) {
            _Ptr = _Ptr->_Right; 
        } else if (_Ptr->_Left->_Isnil) { 
            _Nodeptr _Pnode;
            while (!(_Pnode = _Ptr->_Parent)->_Isnil && _Ptr == _Pnode->_Left) {
                _Ptr = _Pnode; 
            }

            if (!_Ptr->_Isnil) { 
                _Ptr = _Pnode; 
            }
        } else {
            _Ptr = _Mytree::_Max(_Ptr->_Left); 
        }

        return *this;
    }

    _Tree_unchecked_const_iterator operator--(int) noexcept {
        _Tree_unchecked_const_iterator _Tmp = *this;
        --*this;
        return _Tmp;
    }

    [[nodiscard]] bool operator==(const _Tree_unchecked_const_iterator& _Right) const noexcept {
        return _Ptr == _Right._Ptr;
    }


#line 105 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtree"

    [[nodiscard]] bool operator==(_Default_sentinel) const noexcept {
        return !!_Ptr->_Isnil; 
                               
    }


#line 116 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtree"

    _Nodeptr _Ptr; 
};

template <class _Mytree>
class _Tree_unchecked_iterator : public _Tree_unchecked_const_iterator<_Mytree> {
public:
    using _Mybase           = _Tree_unchecked_const_iterator<_Mytree>;
    using iterator_category = bidirectional_iterator_tag;

    using _Nodeptr        = typename _Mytree::_Nodeptr;
    using value_type      = typename _Mytree::value_type;
    using difference_type = typename _Mytree::difference_type;
    using pointer         = typename _Mytree::pointer;
    using reference       = value_type&;

    using _Mybase::_Mybase;

    [[nodiscard]] reference operator*() const noexcept {
        return const_cast<reference>(_Mybase::operator*());
    }

    [[nodiscard]] pointer operator->() const noexcept {
        return pointer_traits<pointer>::pointer_to(**this);
    }

    _Tree_unchecked_iterator& operator++() noexcept {
        _Mybase::operator++();
        return *this;
    }

    _Tree_unchecked_iterator operator++(int) noexcept {
        _Tree_unchecked_iterator _Tmp = *this;
        _Mybase::operator++();
        return _Tmp;
    }

    _Tree_unchecked_iterator& operator--() noexcept {
        _Mybase::operator--();
        return *this;
    }

    _Tree_unchecked_iterator operator--(int) noexcept {
        _Tree_unchecked_iterator _Tmp = *this;
        _Mybase::operator--();
        return _Tmp;
    }
};

template <class _Mytree>
class _Tree_const_iterator : public _Tree_unchecked_const_iterator<_Mytree, _Iterator_base> {
public:
    using _Mybase           = _Tree_unchecked_const_iterator<_Mytree, _Iterator_base>;
    using iterator_category = bidirectional_iterator_tag;

    using _Nodeptr        = typename _Mytree::_Nodeptr;
    using value_type      = typename _Mytree::value_type;
    using difference_type = typename _Mytree::difference_type;
    using pointer         = typename _Mytree::const_pointer;
    using reference       = const value_type&;

    using _Mybase::_Mybase;

    [[nodiscard]] reference operator*() const noexcept {


#line 185 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtree"

        return this->_Ptr->_Myval;
    }

    [[nodiscard]] pointer operator->() const noexcept {
        return pointer_traits<pointer>::pointer_to(**this);
    }

    _Tree_const_iterator& operator++() noexcept {


#line 198 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtree"

        _Mybase::operator++();
        return *this;
    }

    _Tree_const_iterator operator++(int) noexcept {
        _Tree_const_iterator _Tmp = *this;
        ++*this;
        return _Tmp;
    }

    _Tree_const_iterator& operator--() noexcept {


#line 216 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtree"
        _Mybase::operator--();
#line 218 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtree"

        return *this;
    }

    _Tree_const_iterator operator--(int) noexcept {
        _Tree_const_iterator _Tmp = *this;
        --*this;
        return _Tmp;
    }

    [[nodiscard]] bool operator==(const _Tree_const_iterator& _Right) const noexcept {


#line 232 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtree"

        return this->_Ptr == _Right._Ptr;
    }


#line 241 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtree"


#line 247 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtree"

    using _Prevent_inheriting_unwrap = _Tree_const_iterator;

    [[nodiscard]] _Tree_unchecked_const_iterator<_Mytree> _Unwrapped() const noexcept {
        return _Tree_unchecked_const_iterator<_Mytree>(this->_Ptr, static_cast<const _Mytree*>(this->_Getcont()));
    }

    void _Seek_to(const _Tree_unchecked_const_iterator<_Mytree> _It) noexcept {
        this->_Ptr = _It._Ptr;
    }
};

template <class _Mytree>
class _Tree_iterator : public _Tree_const_iterator<_Mytree> {
public:
    using _Mybase           = _Tree_const_iterator<_Mytree>;
    using iterator_category = bidirectional_iterator_tag;

    using _Nodeptr        = typename _Mytree::_Nodeptr;
    using value_type      = typename _Mytree::value_type;
    using difference_type = typename _Mytree::difference_type;

    using pointer   = typename _Mytree::pointer;
    using reference = value_type&;

    using _Mybase::_Mybase;

    [[nodiscard]] reference operator*() const noexcept {
        return const_cast<reference>(_Mybase::operator*());
    }

    [[nodiscard]] pointer operator->() const noexcept {
        return pointer_traits<pointer>::pointer_to(**this);
    }

    _Tree_iterator& operator++() noexcept {
        _Mybase::operator++();
        return *this;
    }

    _Tree_iterator operator++(int) noexcept {
        _Tree_iterator _Tmp = *this;
        _Mybase::operator++();
        return _Tmp;
    }

    _Tree_iterator& operator--() noexcept {
        _Mybase::operator--();
        return *this;
    }

    _Tree_iterator operator--(int) noexcept {
        _Tree_iterator _Tmp = *this;
        _Mybase::operator--();
        return _Tmp;
    }

    using _Prevent_inheriting_unwrap = _Tree_iterator;

    [[nodiscard]] _Tree_unchecked_iterator<_Mytree> _Unwrapped() const noexcept {
        return _Tree_unchecked_iterator<_Mytree>(this->_Ptr, static_cast<const _Mytree*>(this->_Getcont()));
    }
};

template <class _Value_type, class _Size_type, class _Difference_type, class _Pointer, class _Const_pointer,
    class _Reference, class _Const_reference, class _Nodeptr_type>
struct _Tree_iter_types {
    using value_type      = _Value_type;
    using size_type       = _Size_type;
    using difference_type = _Difference_type;
    using pointer         = _Pointer;
    using const_pointer   = _Const_pointer;
    using _Nodeptr        = _Nodeptr_type;
};

template <class _Value_type, class _Voidptr>
struct _Tree_node {
    using _Nodeptr   = _Rebind_pointer_t<_Voidptr, _Tree_node>;
    using value_type = _Value_type;
    _Nodeptr _Left; 
    _Nodeptr _Parent; 
    _Nodeptr _Right; 
    char _Color; 
    char _Isnil; 
    value_type _Myval; 

    enum _Redbl { 
        _Red,
        _Black
    };

    _Tree_node(const _Tree_node&) = delete;
    _Tree_node& operator=(const _Tree_node&) = delete;

    template <class _Alloc>
    static _Nodeptr _Buyheadnode(_Alloc& _Al) {
        static_assert(is_same_v<typename _Alloc::value_type, _Tree_node>, "Bad _Buyheadnode call");
        const auto _Pnode = _Al.allocate(1);
        _Construct_in_place(_Pnode->_Left, _Pnode);
        _Construct_in_place(_Pnode->_Parent, _Pnode);
        _Construct_in_place(_Pnode->_Right, _Pnode);
        _Pnode->_Color = _Black;
        _Pnode->_Isnil = true;
        return _Pnode;
    }

    template <class _Alloc, class... _Valty>
    static _Nodeptr _Buynode(_Alloc& _Al, _Nodeptr _Myhead, _Valty&&... _Val) {
        
        static_assert(is_same_v<typename _Alloc::value_type, _Tree_node>, "Bad _Buynode call");
        _Alloc_construct_ptr<_Alloc> _Newnode(_Al);
        _Newnode._Allocate();
        allocator_traits<_Alloc>::construct(_Al, ::std:: addressof(_Newnode._Ptr->_Myval), ::std:: forward<_Valty>(_Val)...);
        _Construct_in_place(_Newnode._Ptr->_Left, _Myhead);
        _Construct_in_place(_Newnode._Ptr->_Parent, _Myhead);
        _Construct_in_place(_Newnode._Ptr->_Right, _Myhead);
        _Newnode._Ptr->_Color = _Red;
        _Newnode._Ptr->_Isnil = false;
        return _Newnode._Release();
    }

    template <class _Alloc>
    static void _Freenode0(_Alloc& _Al, _Nodeptr _Ptr) noexcept {
        static_assert(is_same_v<typename _Alloc::value_type, _Tree_node>, "Bad _Freenode0 call");
        _Destroy_in_place(_Ptr->_Left);
        _Destroy_in_place(_Ptr->_Parent);
        _Destroy_in_place(_Ptr->_Right);
        allocator_traits<_Alloc>::deallocate(_Al, _Ptr, 1);
    }

    template <class _Alloc>
    static void _Freenode(_Alloc& _Al, _Nodeptr _Ptr) noexcept {
        static_assert(is_same_v<typename _Alloc::value_type, _Tree_node>, "Bad _Freenode call");
        allocator_traits<_Alloc>::destroy(_Al, ::std:: addressof(_Ptr->_Myval));
        _Freenode0(_Al, _Ptr);
    }
};

template <class _Ty>
struct _Tree_simple_types : _Simple_types<_Ty> {
    using _Node    = _Tree_node<_Ty, void*>;
    using _Nodeptr = _Node*;
};

enum class _Tree_child {
    _Right, 
    _Left,
    _Unused 
};

template <class _Nodeptr>
struct _Tree_id {
    _Nodeptr _Parent; 
    _Tree_child _Child;
};

template <class _Nodeptr>
struct _Tree_find_result {
    _Tree_id<_Nodeptr> _Location;
    _Nodeptr _Bound;
};

template <class _Nodeptr>
struct _Tree_find_hint_result {
    _Tree_id<_Nodeptr> _Location;
    bool _Duplicate;
};

[[noreturn]] inline void _Throw_tree_length_error() {
    _Xlength_error("map/set too long");
}

template <class _Val_types>
class _Tree_val : public _Container_base {
public:
    using _Nodeptr = typename _Val_types::_Nodeptr;

    using value_type      = typename _Val_types::value_type;
    using size_type       = typename _Val_types::size_type;
    using difference_type = typename _Val_types::difference_type;
    using pointer         = typename _Val_types::pointer;
    using const_pointer   = typename _Val_types::const_pointer;
    using reference       = value_type&;
    using const_reference = const value_type&;

    using _Unchecked_const_iterator = _Tree_unchecked_const_iterator<_Tree_val>;
    using const_iterator            = _Tree_const_iterator<_Tree_val>;

    _Tree_val() noexcept : _Myhead(), _Mysize(0) {}

    enum _Redbl { 
        _Red,
        _Black
    };

    static _Nodeptr _Max(_Nodeptr _Pnode) noexcept { 
        while (!_Pnode->_Right->_Isnil) {
            _Pnode = _Pnode->_Right;
        }

        return _Pnode;
    }

    static _Nodeptr _Min(_Nodeptr _Pnode) noexcept { 
        while (!_Pnode->_Left->_Isnil) {
            _Pnode = _Pnode->_Left;
        }

        return _Pnode;
    }

    void _Lrotate(_Nodeptr _Wherenode) noexcept { 
        _Nodeptr _Pnode    = _Wherenode->_Right;
        _Wherenode->_Right = _Pnode->_Left;

        if (!_Pnode->_Left->_Isnil) {
            _Pnode->_Left->_Parent = _Wherenode;
        }

        _Pnode->_Parent = _Wherenode->_Parent;

        if (_Wherenode == _Myhead->_Parent) {
            _Myhead->_Parent = _Pnode;
        } else if (_Wherenode == _Wherenode->_Parent->_Left) {
            _Wherenode->_Parent->_Left = _Pnode;
        } else {
            _Wherenode->_Parent->_Right = _Pnode;
        }

        _Pnode->_Left       = _Wherenode;
        _Wherenode->_Parent = _Pnode;
    }

    void _Rrotate(_Nodeptr _Wherenode) noexcept { 
        _Nodeptr _Pnode   = _Wherenode->_Left;
        _Wherenode->_Left = _Pnode->_Right;

        if (!_Pnode->_Right->_Isnil) {
            _Pnode->_Right->_Parent = _Wherenode;
        }

        _Pnode->_Parent = _Wherenode->_Parent;

        if (_Wherenode == _Myhead->_Parent) {
            _Myhead->_Parent = _Pnode;
        } else if (_Wherenode == _Wherenode->_Parent->_Right) {
            _Wherenode->_Parent->_Right = _Pnode;
        } else {
            _Wherenode->_Parent->_Left = _Pnode;
        }

        _Pnode->_Right      = _Wherenode;
        _Wherenode->_Parent = _Pnode;
    }

    _Nodeptr _Extract(_Unchecked_const_iterator _Where) noexcept {
        _Nodeptr _Erasednode = _Where._Ptr; 
        ++_Where; 

        _Nodeptr _Fixnode; 
        _Nodeptr _Fixnodeparent; 
        _Nodeptr _Pnode = _Erasednode;

        if (_Pnode->_Left->_Isnil) {
            _Fixnode = _Pnode->_Right; 
        } else if (_Pnode->_Right->_Isnil) {
            _Fixnode = _Pnode->_Left; 
        } else { 
            _Pnode   = _Where._Ptr; 
            _Fixnode = _Pnode->_Right; 
        }

        if (_Pnode == _Erasednode) { 
            _Fixnodeparent = _Erasednode->_Parent;
            if (!_Fixnode->_Isnil) {
                _Fixnode->_Parent = _Fixnodeparent; 
            }

            if (_Myhead->_Parent == _Erasednode) {
                _Myhead->_Parent = _Fixnode; 
            } else if (_Fixnodeparent->_Left == _Erasednode) {
                _Fixnodeparent->_Left = _Fixnode; 
            } else {
                _Fixnodeparent->_Right = _Fixnode; 
            }

            if (_Myhead->_Left == _Erasednode) {
                _Myhead->_Left = _Fixnode->_Isnil ? _Fixnodeparent 
                                                  : _Min(_Fixnode); 
            }

            if (_Myhead->_Right == _Erasednode) {
                _Myhead->_Right = _Fixnode->_Isnil ? _Fixnodeparent 
                                                   : _Max(_Fixnode); 
            }
        } else { 
            _Erasednode->_Left->_Parent = _Pnode; 
            _Pnode->_Left               = _Erasednode->_Left; 

            if (_Pnode == _Erasednode->_Right) {
                _Fixnodeparent = _Pnode; 
            } else { 
                _Fixnodeparent = _Pnode->_Parent; 
                if (!_Fixnode->_Isnil) {
                    _Fixnode->_Parent = _Fixnodeparent; 
                }

                _Fixnodeparent->_Left        = _Fixnode; 
                _Pnode->_Right               = _Erasednode->_Right; 
                _Erasednode->_Right->_Parent = _Pnode; 
            }

            if (_Myhead->_Parent == _Erasednode) {
                _Myhead->_Parent = _Pnode; 
            } else if (_Erasednode->_Parent->_Left == _Erasednode) {
                _Erasednode->_Parent->_Left = _Pnode; 
            } else {
                _Erasednode->_Parent->_Right = _Pnode; 
            }

            _Pnode->_Parent = _Erasednode->_Parent; 
            ::std:: swap(_Pnode->_Color, _Erasednode->_Color); 
        }

        if (_Erasednode->_Color == _Black) { 
            for (; _Fixnode != _Myhead->_Parent && _Fixnode->_Color == _Black; _Fixnodeparent = _Fixnode->_Parent) {
                if (_Fixnode == _Fixnodeparent->_Left) { 
                    _Pnode = _Fixnodeparent->_Right;
                    if (_Pnode->_Color == _Red) { 
                        _Pnode->_Color         = _Black;
                        _Fixnodeparent->_Color = _Red;
                        _Lrotate(_Fixnodeparent);
                        _Pnode = _Fixnodeparent->_Right;
                    }

                    if (_Pnode->_Isnil) {
                        _Fixnode = _Fixnodeparent; 
                    } else if (_Pnode->_Left->_Color == _Black
                               && _Pnode->_Right->_Color == _Black) { 
                        _Pnode->_Color = _Red;
                        _Fixnode       = _Fixnodeparent;
                    } else { 
                        if (_Pnode->_Right->_Color == _Black) { 
                            _Pnode->_Left->_Color = _Black;
                            _Pnode->_Color        = _Red;
                            _Rrotate(_Pnode);
                            _Pnode = _Fixnodeparent->_Right;
                        }

                        _Pnode->_Color         = _Fixnodeparent->_Color;
                        _Fixnodeparent->_Color = _Black;
                        _Pnode->_Right->_Color = _Black;
                        _Lrotate(_Fixnodeparent);
                        break; 
                    }
                } else { 
                    _Pnode = _Fixnodeparent->_Left;
                    if (_Pnode->_Color == _Red) { 
                        _Pnode->_Color         = _Black;
                        _Fixnodeparent->_Color = _Red;
                        _Rrotate(_Fixnodeparent);
                        _Pnode = _Fixnodeparent->_Left;
                    }

                    if (_Pnode->_Isnil) {
                        _Fixnode = _Fixnodeparent; 
                    } else if (_Pnode->_Right->_Color == _Black
                               && _Pnode->_Left->_Color == _Black) { 
                        _Pnode->_Color = _Red;
                        _Fixnode       = _Fixnodeparent;
                    } else { 
                        if (_Pnode->_Left->_Color == _Black) { 
                            _Pnode->_Right->_Color = _Black;
                            _Pnode->_Color         = _Red;
                            _Lrotate(_Pnode);
                            _Pnode = _Fixnodeparent->_Left;
                        }

                        _Pnode->_Color         = _Fixnodeparent->_Color;
                        _Fixnodeparent->_Color = _Black;
                        _Pnode->_Left->_Color  = _Black;
                        _Rrotate(_Fixnodeparent);
                        break; 
                    }
                }
            }

            _Fixnode->_Color = _Black; 
        }

        if (0 < _Mysize) {
            --_Mysize;
        }

        return _Erasednode;
    }

    _Nodeptr _Insert_node(const _Tree_id<_Nodeptr> _Loc, const _Nodeptr _Newnode) noexcept {
        ++_Mysize;
        const auto _Head  = _Myhead;
        _Newnode->_Parent = _Loc._Parent;
        if (_Loc._Parent == _Head) { 
            _Head->_Left     = _Newnode;
            _Head->_Parent   = _Newnode;
            _Head->_Right    = _Newnode;
            _Newnode->_Color = _Black; 
            return _Newnode;
        }

        ;
        if (_Loc._Child == _Tree_child::_Right) { 
            ;
            _Loc._Parent->_Right = _Newnode;
            if (_Loc._Parent == _Head->_Right) { 
                _Head->_Right = _Newnode;
            }
        } else { 
            ;
            _Loc._Parent->_Left = _Newnode;
            if (_Loc._Parent == _Head->_Left) { 
                _Head->_Left = _Newnode;
            }
        }

        for (_Nodeptr _Pnode = _Newnode; _Pnode->_Parent->_Color == _Red;) {
            if (_Pnode->_Parent == _Pnode->_Parent->_Parent->_Left) { 
                const auto _Parent_sibling = _Pnode->_Parent->_Parent->_Right;
                if (_Parent_sibling->_Color == _Red) { 
                    _Pnode->_Parent->_Color          = _Black;
                    _Parent_sibling->_Color          = _Black;
                    _Pnode->_Parent->_Parent->_Color = _Red;
                    _Pnode                           = _Pnode->_Parent->_Parent;
                } else { 
                    if (_Pnode == _Pnode->_Parent->_Right) { 
                        _Pnode = _Pnode->_Parent;
                        _Lrotate(_Pnode);
                    }

                    _Pnode->_Parent->_Color          = _Black; 
                    _Pnode->_Parent->_Parent->_Color = _Red;
                    _Rrotate(_Pnode->_Parent->_Parent);
                }
            } else { 
                const auto _Parent_sibling = _Pnode->_Parent->_Parent->_Left;
                if (_Parent_sibling->_Color == _Red) { 
                    _Pnode->_Parent->_Color          = _Black;
                    _Parent_sibling->_Color          = _Black;
                    _Pnode->_Parent->_Parent->_Color = _Red;
                    _Pnode                           = _Pnode->_Parent->_Parent;
                } else { 
                    if (_Pnode == _Pnode->_Parent->_Left) { 
                        _Pnode = _Pnode->_Parent;
                        _Rrotate(_Pnode);
                    }

                    _Pnode->_Parent->_Color          = _Black; 
                    _Pnode->_Parent->_Parent->_Color = _Red;
                    _Lrotate(_Pnode->_Parent->_Parent);
                }
            }
        }

        _Head->_Parent->_Color = _Black; 
        return _Newnode;
    }

    void _Orphan_ptr(const _Nodeptr _Ptr) noexcept {


#line 727 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtree"
        (void) _Ptr;
#line 729 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtree"
    }

    template <class _Alnode>
    void _Erase_tree_and_orphan(_Alnode& _Al, _Nodeptr _Rootnode) noexcept {
        while (!_Rootnode->_Isnil) { 
            _Erase_tree_and_orphan(_Al, _Rootnode->_Right);
            auto _To_delete = ::std:: exchange(_Rootnode, _Rootnode->_Left);
            _Orphan_ptr(_To_delete);
            _Alnode::value_type::_Freenode(_Al, _To_delete);
        }
    }

    template <class _Alnode>
    void _Erase_tree(_Alnode& _Al, _Nodeptr _Rootnode) noexcept {
        while (!_Rootnode->_Isnil) { 
            _Erase_tree(_Al, _Rootnode->_Right);
            _Alnode::value_type::_Freenode(_Al, ::std:: exchange(_Rootnode, _Rootnode->_Left));
        }
    }

    template <class _Alnode>
    void _Erase_head(_Alnode& _Al) noexcept {
        this->_Orphan_all();
        _Erase_tree(_Al, _Myhead->_Parent);
        _Alnode::value_type::_Freenode0(_Al, _Myhead);
    }

    _Nodeptr _Myhead; 
    size_type _Mysize; 
};

template <class _Alnode, class _Scary_val>
struct _Tree_head_scoped_ptr { 
    _Alnode& _Al;
    _Scary_val* _Mycont;

    _Tree_head_scoped_ptr(_Alnode& _Al_, _Scary_val& _Mycont_) : _Al(_Al_), _Mycont(::std:: addressof(_Mycont_)) {
        _Mycont->_Myhead = _Alnode::value_type::_Buyheadnode(_Al);
    }

    void _Release() noexcept {
        _Mycont = nullptr;
    }

    ~_Tree_head_scoped_ptr() {
        if (_Mycont) {
            _Mycont->_Erase_head(_Al);
        }
    }
};

template <class _Alnode>
struct _Tree_temp_node_alloc : _Alloc_construct_ptr<_Alnode> {
    
    explicit _Tree_temp_node_alloc(_Alnode& _Al_) : _Alloc_construct_ptr<_Alnode>(_Al_) {
        _Alloc_construct_ptr<_Alnode>::_Allocate();
    }

    _Tree_temp_node_alloc(const _Tree_temp_node_alloc&) = delete;
    _Tree_temp_node_alloc& operator=(const _Tree_temp_node_alloc&) = delete;
};

template <class _Alnode>
struct _Tree_temp_node : _Tree_temp_node_alloc<_Alnode> {
    
    using _Alnode_traits = allocator_traits<_Alnode>;
    using _Nodeptr       = typename _Alnode_traits::pointer;

    enum _Redbl { 
        _Red,
        _Black
    };

    template <class... _Valtys>
    explicit _Tree_temp_node(_Alnode& _Al_, _Nodeptr _Myhead, _Valtys&&... _Vals)
        : _Tree_temp_node_alloc<_Alnode>(_Al_) {
        _Alnode_traits::construct(this->_Al, ::std:: addressof(this->_Ptr->_Myval), ::std:: forward<_Valtys>(_Vals)...);
        _Construct_in_place(this->_Ptr->_Left, _Myhead);
        _Construct_in_place(this->_Ptr->_Parent, _Myhead);
        _Construct_in_place(this->_Ptr->_Right, _Myhead);
        this->_Ptr->_Color = _Red;
        this->_Ptr->_Isnil = false;
    }

    _Tree_temp_node(const _Tree_temp_node&) = delete;
    _Tree_temp_node& operator=(const _Tree_temp_node&) = delete;

    ~_Tree_temp_node() {
        if (this->_Ptr) {
            _Destroy_in_place(this->_Ptr->_Left);
            _Destroy_in_place(this->_Ptr->_Parent);
            _Destroy_in_place(this->_Ptr->_Right);
            _Alnode_traits::destroy(this->_Al, ::std:: addressof(this->_Ptr->_Myval));
        }
    }
};

template <class _Traits>
class _Tree { 
public:
    using value_type     = typename _Traits::value_type;
    using allocator_type = typename _Traits::allocator_type;

protected:
    using _Alty          = _Rebind_alloc_t<allocator_type, value_type>;
    using _Alty_traits   = allocator_traits<_Alty>;
    using _Node          = _Tree_node<value_type, typename _Alty_traits::void_pointer>;
    using _Alnode        = _Rebind_alloc_t<allocator_type, _Node>;
    using _Alnode_traits = allocator_traits<_Alnode>;
    using _Nodeptr       = typename _Alnode_traits::pointer;

    using _Scary_val = _Tree_val<conditional_t<_Is_simple_alloc_v<_Alnode>, _Tree_simple_types<value_type>,
        _Tree_iter_types<value_type, typename _Alty_traits::size_type, typename _Alty_traits::difference_type,
            typename _Alty_traits::pointer, typename _Alty_traits::const_pointer, value_type&, const value_type&,
            _Nodeptr>>>;

    static constexpr bool _Multi = _Traits::_Multi;

    enum _Redbl { 
        _Red,
        _Black
    };

public:
    using key_type      = typename _Traits::key_type;
    using value_compare = typename _Traits::value_compare;

    using key_compare = typename _Traits::key_compare;

    using size_type       = typename _Alty_traits::size_type;
    using difference_type = typename _Alty_traits::difference_type;
    using pointer         = typename _Alty_traits::pointer;
    using const_pointer   = typename _Alty_traits::const_pointer;
    using reference       = value_type&;
    using const_reference = const value_type&;

    using iterator =
        conditional_t<is_same_v<key_type, value_type>, _Tree_const_iterator<_Scary_val>, _Tree_iterator<_Scary_val>>;
    using const_iterator            = _Tree_const_iterator<_Scary_val>;
    using _Unchecked_iterator       = conditional_t<is_same_v<key_type, value_type>,
        _Tree_unchecked_const_iterator<_Scary_val>, _Tree_unchecked_iterator<_Scary_val>>;
    using _Unchecked_const_iterator = _Tree_unchecked_const_iterator<_Scary_val>;

    using reverse_iterator       = ::std:: reverse_iterator<iterator>;
    using const_reverse_iterator = ::std:: reverse_iterator<const_iterator>;

    struct _Copy_tag {
        explicit _Copy_tag() = default;
    };

    struct _Move_tag {
        explicit _Move_tag() = default;
    };

    _Tree(const key_compare& _Parg) : _Mypair(_One_then_variadic_args_t{}, _Parg, _Zero_then_variadic_args_t{}) {
        _Alloc_sentinel_and_proxy();
    }

    _Tree(const key_compare& _Parg, const allocator_type& _Al)
        : _Mypair(_One_then_variadic_args_t{}, _Parg, _One_then_variadic_args_t{}, _Al) {
        _Alloc_sentinel_and_proxy();
    }

    template <class _Any_alloc>
    _Tree(const _Tree& _Right, _Any_alloc&& _Al)
        : _Mypair(_One_then_variadic_args_t{}, _Right.key_comp(), _One_then_variadic_args_t{},
            ::std:: forward<_Any_alloc>(_Al)) {
        auto&& _Alproxy   = _Fake_alloc;
        const auto _Scary = _Get_scary();
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, *_Scary);
        _Tree_head_scoped_ptr<_Alnode, _Scary_val> _Sentinel(_Getal(), *_Scary);
        _Copy(_Right, _Copy_tag{});
        _Sentinel._Release();
        _Proxy._Release();
    }

    _Tree(_Tree&& _Right)
        : _Mypair(_One_then_variadic_args_t{}, _Right.key_comp(), 
            _One_then_variadic_args_t{}, ::std:: move(_Right._Getal())) {
        _Alloc_sentinel_and_proxy();
        _Swap_val_excluding_comp(_Right);
    }

private:
    void _Different_allocator_move_construct(_Tree&& _Right) {
        
        auto&& _Alproxy   = _Fake_alloc;
        const auto _Scary = _Get_scary();
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, *_Scary);
        _Tree_head_scoped_ptr<_Alnode, _Scary_val> _Sentinel(_Getal(), *_Scary);
        _Copy(_Right, _Move_tag{});
        _Sentinel._Release();
        _Proxy._Release();
    }

public:
    _Tree(_Tree&& _Right, const allocator_type& _Al)
        : _Mypair(_One_then_variadic_args_t{}, _Right.key_comp(), 
            _One_then_variadic_args_t{}, _Al) {
        if constexpr (!_Alnode_traits::is_always_equal::value) {
            if (_Getal() != _Right._Getal()) {
                _Different_allocator_move_construct(::std:: move(_Right));
                return;
            }
        }

        _Alloc_sentinel_and_proxy();
        _Swap_val_excluding_comp(_Right);
    }

public:
    _Tree& operator=(_Tree&& _Right) noexcept(
        _Choose_pocma_v<_Alnode> == _Pocma_values::_Equal_allocators && is_nothrow_move_assignable_v<key_compare>) {
        if (this == ::std:: addressof(_Right)) {
            return *this;
        }

        auto& _Al                 = _Getal();
        auto& _Right_al           = _Right._Getal();
        constexpr auto _Pocma_val = _Choose_pocma_v<_Alnode>;
        if constexpr (_Pocma_val == _Pocma_values::_Propagate_allocators) {
            if (_Al != _Right_al) {
                clear();
                _Getcomp()            = _Right._Getcomp(); 
                auto&& _Alproxy       = _Fake_alloc;
                auto&& _Right_alproxy = _Fake_alloc;
                _Container_proxy_ptr<_Alty> _Proxy(_Right_alproxy, _Leave_proxy_unbound{});
                const auto _Scary       = _Get_scary();
                const auto _Right_scary = _Right._Get_scary();
                const auto _Newhead     = ::std:: exchange(_Right_scary->_Myhead, _Node::_Buyheadnode(_Right_al));
                const auto _Newsize     = ::std:: exchange(_Right_scary->_Mysize, size_type{0});
                _Scary->_Erase_head(_Al);
                _Pocma(_Al, _Right_al);
                _Scary->_Myhead = _Newhead;
                _Scary->_Mysize = _Newsize;
                _Proxy._Bind(_Alproxy, _Scary);
                _Scary->_Swap_proxy_and_iterators(*_Right_scary);
                return *this;
            }
        } else if constexpr (_Pocma_val == _Pocma_values::_No_propagate_allocators) {
            if (_Al != _Right_al) {
                clear();
                _Getcomp() = _Right._Getcomp(); 
                _Copy(_Right, _Move_tag{});
                return *this;
            }
        }

        clear();
        _Getcomp() = _Right._Getcomp(); 
        _Pocma(_Al, _Right_al);
        _Swap_val_excluding_comp(_Right);

        return *this;
    }

private:
    void _Swap_val_excluding_comp(_Tree& _Right) { 
        const auto _Scary       = _Get_scary();
        const auto _Right_scary = _Right._Get_scary();
        _Scary->_Swap_proxy_and_iterators(*_Right_scary);
        _Swap_adl(_Scary->_Myhead, _Right_scary->_Myhead);
        ::std:: swap(_Scary->_Mysize, _Right_scary->_Mysize);
    }

protected:
    template <class... _Valtys>
    pair<_Nodeptr, bool> _Emplace(_Valtys&&... _Vals) {
        using _In_place_key_extractor = typename _Traits::template _In_place_key_extractor<_Remove_cvref_t<_Valtys>...>;
        const auto _Scary             = _Get_scary();
        _Tree_find_result<_Nodeptr> _Loc;
        _Nodeptr _Inserted;
        if constexpr (!_Multi && _In_place_key_extractor::_Extractable) {
            const auto& _Keyval = _In_place_key_extractor::_Extract(_Vals...);
            _Loc                = _Find_lower_bound(_Keyval);
            if (_Lower_bound_duplicate(_Loc._Bound, _Keyval)) {
                return {_Loc._Bound, false};
            }

            _Check_grow_by_1();
            _Inserted = _Tree_temp_node<_Alnode>(_Getal(), _Scary->_Myhead, ::std:: forward<_Valtys>(_Vals)...)._Release();
            
        } else {
            _Tree_temp_node<_Alnode> _Newnode(_Getal(), _Scary->_Myhead, ::std:: forward<_Valtys>(_Vals)...);
            const auto& _Keyval = _Traits::_Kfn(_Newnode._Ptr->_Myval);
            if constexpr (_Multi) { 
                _Loc = _Find_upper_bound(_Keyval);
            } else {
                _Loc = _Find_lower_bound(_Keyval);
                if (_Lower_bound_duplicate(_Loc._Bound, _Keyval)) {
                    return {_Loc._Bound, false};
                }
            }

            _Check_grow_by_1();
            
            _Inserted = _Newnode._Release();
        }

        return {_Scary->_Insert_node(_Loc._Location, _Inserted), true};
    }

public:
    template <class... _Valtys>
    pair<iterator, bool> emplace(_Valtys&&... _Vals) {
        const auto _Result = _Emplace(::std:: forward<_Valtys>(_Vals)...);
        return {iterator(_Result.first, _Get_scary()), _Result.second};
    }

protected:
    template <class... _Valtys>
    _Nodeptr _Emplace_hint(const _Nodeptr _Hint, _Valtys&&... _Vals) {
        using _In_place_key_extractor = typename _Traits::template _In_place_key_extractor<_Remove_cvref_t<_Valtys>...>;
        const auto _Scary             = _Get_scary();
        _Tree_find_hint_result<_Nodeptr> _Loc;
        _Nodeptr _Inserted;
        if constexpr (!_Multi && _In_place_key_extractor::_Extractable) {
            _Loc = _Find_hint(_Hint, _In_place_key_extractor::_Extract(_Vals...));
            if (_Loc._Duplicate) {
                return _Loc._Location._Parent;
            }

            _Check_grow_by_1();
            _Inserted = _Tree_temp_node<_Alnode>(_Getal(), _Scary->_Myhead, ::std:: forward<_Valtys>(_Vals)...)._Release();
            
        } else {
            _Tree_temp_node<_Alnode> _Newnode(_Getal(), _Scary->_Myhead, ::std:: forward<_Valtys>(_Vals)...);
            _Loc = _Find_hint(_Hint, _Traits::_Kfn(_Newnode._Ptr->_Myval));
            if constexpr (!_Multi) {
                if (_Loc._Duplicate) {
                    return _Loc._Location._Parent;
                }
            }

            _Check_grow_by_1();
            
            _Inserted = _Newnode._Release();
        }

        return _Scary->_Insert_node(_Loc._Location, _Inserted);
    }

public:
    template <class... _Valtys>
    iterator emplace_hint(const_iterator _Where, _Valtys&&... _Vals) { 
        const auto _Scary = _Get_scary();


#line 1078 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtree"
        return iterator(_Emplace_hint(_Where._Ptr, ::std:: forward<_Valtys>(_Vals)...), _Scary);
    }

    ~_Tree() noexcept {
        const auto _Scary = _Get_scary();
        _Scary->_Erase_head(_Getal());


#line 1088 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtree"
    }

public:
    _Tree& operator=(const _Tree& _Right) {
        if (this == ::std:: addressof(_Right)) {
            return *this;
        }

        auto& _Al       = _Getal();
        auto& _Right_al = _Right._Getal();
        if constexpr (_Choose_pocca_v<_Alnode>) {
            if (_Al != _Right_al) {
                clear();
                const auto _Scary = _Get_scary();
                _Scary->_Orphan_all();
                auto&& _Alproxy       = _Fake_alloc;
                auto&& _Right_alproxy = _Fake_alloc;
                _Container_proxy_ptr<_Alty> _Proxy(_Right_alproxy, _Leave_proxy_unbound{});
                auto _Right_al_non_const = _Right_al;
                auto _Newhead            = _Node::_Buyheadnode(_Right_al_non_const);
                _Node::_Freenode0(_Al, _Scary->_Myhead);
                _Pocca(_Al, _Right_al);
                _Scary->_Myhead = _Newhead;
                _Proxy._Bind(_Alproxy, _Scary);
                _Getcomp() = _Right._Getcomp();
                _Copy(_Right, _Copy_tag{});
                return *this;
            }
        }

        clear();
        _Getcomp() = _Right._Getcomp();
        _Pocca(_Al, _Right_al);
        _Copy(_Right, _Copy_tag{});

        return *this;
    }

    [[nodiscard]] iterator begin() noexcept {
        const auto _Scary = _Get_scary();
        return iterator(_Scary->_Myhead->_Left, _Scary);
    }

    [[nodiscard]] const_iterator begin() const noexcept {
        const auto _Scary = _Get_scary();
        return const_iterator(_Scary->_Myhead->_Left, _Scary);
    }

    [[nodiscard]] iterator end() noexcept {
        const auto _Scary = _Get_scary();
        return iterator(_Scary->_Myhead, _Scary);
    }

    [[nodiscard]] const_iterator end() const noexcept {
        const auto _Scary = _Get_scary();
        return const_iterator(_Scary->_Myhead, _Scary);
    }

    _Unchecked_iterator _Unchecked_begin() noexcept {
        return _Unchecked_iterator(_Get_scary()->_Myhead->_Left, nullptr);
    }

    _Unchecked_const_iterator _Unchecked_begin() const noexcept {
        return _Unchecked_const_iterator(_Get_scary()->_Myhead->_Left, nullptr);
    }

    _Default_sentinel _Unchecked_end() const noexcept {
        return {};
    }

    _Unchecked_const_iterator _Unchecked_end_iter() const noexcept {
        return _Unchecked_const_iterator(_Get_scary()->_Myhead, nullptr);
    }

    [[nodiscard]] reverse_iterator rbegin() noexcept {
        return reverse_iterator(end());
    }

    [[nodiscard]] const_reverse_iterator rbegin() const noexcept {
        return const_reverse_iterator(end());
    }

    [[nodiscard]] reverse_iterator rend() noexcept {
        return reverse_iterator(begin());
    }

    [[nodiscard]] const_reverse_iterator rend() const noexcept {
        return const_reverse_iterator(begin());
    }

    [[nodiscard]] const_iterator cbegin() const noexcept {
        return begin();
    }

    [[nodiscard]] const_iterator cend() const noexcept {
        return end();
    }

    [[nodiscard]] const_reverse_iterator crbegin() const noexcept {
        return rbegin();
    }

    [[nodiscard]] const_reverse_iterator crend() const noexcept {
        return rend();
    }

    [[nodiscard]] size_type size() const noexcept {
        return _Get_scary()->_Mysize;
    }

    [[nodiscard]] size_type max_size() const noexcept {
        return (::std:: min)(
            static_cast<size_type>((numeric_limits<difference_type>::max)()), _Alnode_traits::max_size(_Getal()));
    }

    [[nodiscard]] bool empty() const noexcept {
        return _Get_scary()->_Mysize == 0;
    }

    [[nodiscard]] allocator_type get_allocator() const noexcept {
        return static_cast<allocator_type>(_Getal());
    }

    [[nodiscard]] key_compare key_comp() const {
        return _Getcomp();
    }

    [[nodiscard]] value_compare value_comp() const {
        return value_compare(key_comp());
    }

    template <bool _Multi2 = _Multi, enable_if_t<!_Multi2, int> = 0>
    pair<iterator, bool> insert(const value_type& _Val) {
        const auto _Result = _Emplace(_Val);
        return {iterator(_Result.first, _Get_scary()), _Result.second};
    }

    template <bool _Multi2 = _Multi, enable_if_t<_Multi2, int> = 0>
    iterator insert(const value_type& _Val) {
        return iterator(_Emplace(_Val).first, _Get_scary());
    }

    template <bool _Multi2 = _Multi, enable_if_t<!_Multi2, int> = 0>
    pair<iterator, bool> insert(value_type&& _Val) {
        const auto _Result = _Emplace(::std:: move(_Val));
        return {iterator(_Result.first, _Get_scary()), _Result.second};
    }

    template <bool _Multi2 = _Multi, enable_if_t<_Multi2, int> = 0>
    iterator insert(value_type&& _Val) {
        return iterator(_Emplace(::std:: move(_Val)).first, _Get_scary());
    }

    iterator insert(const_iterator _Where, const value_type& _Val) {
        const auto _Scary = _Get_scary();


#line 1246 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtree"
        return iterator(_Emplace_hint(_Where._Ptr, _Val), _Scary);
    }

    iterator insert(const_iterator _Where, value_type&& _Val) {
        const auto _Scary = _Get_scary();


#line 1254 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtree"
        return iterator(_Emplace_hint(_Where._Ptr, ::std:: move(_Val)), _Scary);
    }

    template <class _Iter>
    void insert(_Iter _First, _Iter _Last) {
        _Adl_verify_range(_First, _Last);
        auto _UFirst       = _Get_unwrapped(_First);
        const auto _ULast  = _Get_unwrapped(_Last);
        const auto _Myhead = _Get_scary()->_Myhead;
        for (; _UFirst != _ULast; ++_UFirst) {
            _Emplace_hint(_Myhead, *_UFirst);
        }
    }

    void insert(initializer_list<value_type> _Ilist) {
        insert(_Ilist.begin(), _Ilist.end());
    }

private:
    _Nodeptr _Erase_unchecked(_Unchecked_const_iterator _Where) noexcept {
        const auto _Scary                    = _Get_scary();
        _Unchecked_const_iterator _Successor = _Where;
        ++_Successor; 
        _Nodeptr _Erasednode = _Scary->_Extract(_Where); 
        _Scary->_Orphan_ptr(_Erasednode);
        _Node::_Freenode(_Getal(), _Erasednode); 
        return _Successor._Ptr; 
    }

    _Nodeptr _Erase_unchecked(_Unchecked_const_iterator _First, _Unchecked_const_iterator _Last) noexcept {
        const auto _Begin = _Unchecked_begin();
        if (_First == _Begin && _Last._Ptr->_Isnil) {
            
            clear();
            return _Last._Ptr;
        }

        
        while (_First != _Last) {
            _Erase_unchecked(_First++);
        }

        return _Last._Ptr;
    }

    size_type _Erase(const pair<_Nodeptr, _Nodeptr> _Where) noexcept {
        const _Unchecked_const_iterator _First(_Where.first, nullptr);
        const _Unchecked_const_iterator _Last(_Where.second, nullptr);
        const auto _Num = static_cast<size_type>(::std:: distance(_First, _Last));
        _Erase_unchecked(_First, _Last);
        return _Num;
    }

public:
    template <class _Iter = iterator, enable_if_t<!is_same_v<_Iter, const_iterator>, int> = 0>
    iterator erase(iterator _Where) noexcept  {
        const auto _Scary = _Get_scary();


#line 1315 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtree"
        return iterator(_Erase_unchecked(_Where._Unwrapped()), _Scary);
    }

    iterator erase(const_iterator _Where) noexcept  {
        const auto _Scary = _Get_scary();


#line 1324 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtree"
        return iterator(_Erase_unchecked(_Where._Unwrapped()), _Scary);
    }

    iterator erase(const_iterator _First, const_iterator _Last) noexcept  {
        return iterator(_Erase_unchecked(_First._Unwrapped(), _Last._Unwrapped()), _Get_scary());
    }

    size_type erase(const key_type& _Keyval) noexcept(noexcept(_Eqrange(_Keyval)))  {
        return _Erase(_Eqrange(_Keyval));
    }


    template <class _Kx, class _Mycomp = key_compare, class = typename _Mycomp::is_transparent,
        enable_if_t<!disjunction_v<is_convertible<_Kx, const_iterator>, is_convertible<_Kx, iterator>>, int> = 0>
    size_type erase(_Kx&& _Keyval) noexcept(noexcept(_Eqrange(_Keyval)))  {
        return _Erase(_Eqrange(_Keyval));
    }
#line 1342 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtree"

    void clear() noexcept {
        const auto _Scary = _Get_scary();
        _Scary->_Orphan_ptr(nullptr);
        auto _Head = _Scary->_Myhead;
        _Scary->_Erase_tree(_Getal(), _Head->_Parent);
        _Head->_Parent  = _Head;
        _Head->_Left    = _Head;
        _Head->_Right   = _Head;
        _Scary->_Mysize = 0;
    }

private:
    template <class _Other>
    [[nodiscard]] _Nodeptr _Find(const _Other& _Keyval) const {
        const _Tree_find_result<_Nodeptr> _Loc = _Find_lower_bound(_Keyval);
        if (_Lower_bound_duplicate(_Loc._Bound, _Keyval)) {
            return _Loc._Bound;
        }

        return _Get_scary()->_Myhead;
    }

public:
    [[nodiscard]] iterator find(const key_type& _Keyval) {
        return iterator(_Find(_Keyval), _Get_scary());
    }

    [[nodiscard]] const_iterator find(const key_type& _Keyval) const {
        return const_iterator(_Find(_Keyval), _Get_scary());
    }

    template <class _Other, class _Mycomp = key_compare, class = typename _Mycomp::is_transparent>
    [[nodiscard]] iterator find(const _Other& _Keyval) {
        return iterator(_Find(_Keyval), _Get_scary());
    }

    template <class _Other, class _Mycomp = key_compare, class = typename _Mycomp::is_transparent>
    [[nodiscard]] const_iterator find(const _Other& _Keyval) const {
        return const_iterator(_Find(_Keyval), _Get_scary());
    }


    [[nodiscard]] bool contains(const key_type& _Keyval) const {
        return _Lower_bound_duplicate(_Find_lower_bound(_Keyval)._Bound, _Keyval);
    }

    template <class _Other, class _Mycomp = key_compare, class = typename _Mycomp::is_transparent>
    [[nodiscard]] bool contains(const _Other& _Keyval) const {
        return _Lower_bound_duplicate(_Find_lower_bound(_Keyval)._Bound, _Keyval);
    }
#line 1394 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtree"

    [[nodiscard]] size_type count(const key_type& _Keyval) const {
        if constexpr (_Multi) {
            const auto _Ans = _Eqrange(_Keyval);
            return static_cast<size_type>(::std:: distance(
                _Unchecked_const_iterator(_Ans.first, nullptr), _Unchecked_const_iterator(_Ans.second, nullptr)));
        } else {
            return _Lower_bound_duplicate(_Find_lower_bound(_Keyval)._Bound, _Keyval);
        }
    }

    template <class _Other, class _Mycomp = key_compare, class = typename _Mycomp::is_transparent>
    [[nodiscard]] size_type count(const _Other& _Keyval) const {
        const auto _Ans = _Eqrange(_Keyval);
        return static_cast<size_type>(::std:: distance(
            _Unchecked_const_iterator(_Ans.first, nullptr), _Unchecked_const_iterator(_Ans.second, nullptr)));
    }

    [[nodiscard]] iterator lower_bound(const key_type& _Keyval) {
        return iterator(_Find_lower_bound(_Keyval)._Bound, _Get_scary());
    }

    [[nodiscard]] const_iterator lower_bound(const key_type& _Keyval) const {
        return const_iterator(_Find_lower_bound(_Keyval)._Bound, _Get_scary());
    }

    template <class _Other, class _Mycomp = key_compare, class = typename _Mycomp::is_transparent>
    [[nodiscard]] iterator lower_bound(const _Other& _Keyval) {
        return iterator(_Find_lower_bound(_Keyval)._Bound, _Get_scary());
    }

    template <class _Other, class _Mycomp = key_compare, class = typename _Mycomp::is_transparent>
    [[nodiscard]] const_iterator lower_bound(const _Other& _Keyval) const {
        return const_iterator(_Find_lower_bound(_Keyval)._Bound, _Get_scary());
    }

    [[nodiscard]] iterator upper_bound(const key_type& _Keyval) {
        return iterator(_Find_upper_bound(_Keyval)._Bound, _Get_scary());
    }

    [[nodiscard]] const_iterator upper_bound(const key_type& _Keyval) const {
        return const_iterator(_Find_upper_bound(_Keyval)._Bound, _Get_scary());
    }

    template <class _Other, class _Mycomp = key_compare, class = typename _Mycomp::is_transparent>
    [[nodiscard]] iterator upper_bound(const _Other& _Keyval) {
        return iterator(_Find_upper_bound(_Keyval)._Bound, _Get_scary());
    }

    template <class _Other, class _Mycomp = key_compare, class = typename _Mycomp::is_transparent>
    [[nodiscard]] const_iterator upper_bound(const _Other& _Keyval) const {
        return const_iterator(_Find_upper_bound(_Keyval)._Bound, _Get_scary());
    }

    [[nodiscard]] pair<iterator, iterator> equal_range(const key_type& _Keyval) {
        const auto _Result = _Eqrange(_Keyval);
        const auto _Scary  = _Get_scary();
        return {iterator(_Result.first, _Scary), iterator(_Result.second, _Scary)};
    }

    [[nodiscard]] pair<const_iterator, const_iterator> equal_range(const key_type& _Keyval) const {
        const auto _Result = _Eqrange(_Keyval);
        const auto _Scary  = _Get_scary();
        return {const_iterator(_Result.first, _Scary), const_iterator(_Result.second, _Scary)};
    }

    template <class _Other, class _Mycomp = key_compare, class = typename _Mycomp::is_transparent>
    [[nodiscard]] pair<iterator, iterator> equal_range(const _Other& _Keyval) {
        const auto _Result = _Eqrange(_Keyval);
        const auto _Scary  = _Get_scary();
        return {iterator(_Result.first, _Scary), iterator(_Result.second, _Scary)};
    }

    template <class _Other, class _Mycomp = key_compare, class = typename _Mycomp::is_transparent>
    [[nodiscard]] pair<const_iterator, const_iterator> equal_range(const _Other& _Keyval) const {
        const auto _Result = _Eqrange(_Keyval);
        const auto _Scary  = _Get_scary();
        return {const_iterator(_Result.first, _Scary), const_iterator(_Result.second, _Scary)};
    }

    void swap(_Tree& _Right) noexcept(_Is_nothrow_swappable<key_compare>::value)  {
        if (this != ::std:: addressof(_Right)) {
            _Pocs(_Getal(), _Right._Getal());
            _Swap_val_excluding_comp(_Right);
            _Swap_adl(_Getcomp(), _Right._Getcomp());
        }
    }

protected:
    template <class _Keyty>
    _Tree_find_hint_result<_Nodeptr> _Find_hint(const _Nodeptr _Hint, const _Keyty& _Keyval) const {
        const auto& _Comp = _Getcomp();
        const auto _Head  = _Get_scary()->_Myhead;
        if constexpr (_Multi) { 
            if (_Hint->_Isnil) {
                
                if (_Head->_Parent->_Isnil || !static_cast<bool>(_Comp(_Keyval, _Traits::_Kfn(_Head->_Right->_Myval)))) {
                    return {{_Head->_Right, _Tree_child::_Right}, false};
                }

                
                return {_Find_upper_bound(_Keyval)._Location, false};
            }

            if (_Hint == _Head->_Left) {
                
                if (!static_cast<bool>(_Comp(_Traits::_Kfn(_Hint->_Myval), _Keyval))) {
                    return {{_Hint, _Tree_child::_Left}, false};
                }

                
                return {_Find_lower_bound(_Keyval)._Location, false};
            }

            if (!static_cast<bool>(_Comp(_Traits::_Kfn(_Hint->_Myval), _Keyval))) {
                
                const auto _Prev = (--(_Unchecked_const_iterator(_Hint, nullptr)))._Ptr;
                if (!static_cast<bool>(_Comp(_Keyval, _Traits::_Kfn(_Prev->_Myval)))) {
                    
                    if (_Prev->_Right->_Isnil) {
                        return {{_Prev, _Tree_child::_Right}, false};
                    } else {
                        return {{_Hint, _Tree_child::_Left}, false};
                    }
                }

                
                return {_Find_upper_bound(_Keyval)._Location, false};
            }

            
            return {_Find_lower_bound(_Keyval)._Location, false};
        } else { 
            if (_Hint->_Isnil) { 
                
                if (_Head->_Parent->_Isnil || static_cast<bool>(_Comp(_Traits::_Kfn(_Head->_Right->_Myval), _Keyval))) {
                    return {{_Head->_Right, _Tree_child::_Right}, false};
                }
            } else if (_Hint == _Head->_Left) {
                
                if (static_cast<bool>(_Comp(_Keyval, _Traits::_Kfn(_Hint->_Myval)))) {
                    return {{_Hint, _Tree_child::_Left}, false};
                }
            } else if (static_cast<bool>(_Comp(_Keyval, _Traits::_Kfn(_Hint->_Myval)))) {
                
                const auto _Prev = (--(_Unchecked_const_iterator(_Hint, nullptr)))._Ptr;
                if (static_cast<bool>(_Comp(_Traits::_Kfn(_Prev->_Myval), _Keyval))) {
                    
                    if (_Prev->_Right->_Isnil) {
                        return {{_Prev, _Tree_child::_Right}, false};
                    } else {
                        return {{_Hint, _Tree_child::_Left}, false};
                    }
                }
            } else if (static_cast<bool>(_Comp(_Traits::_Kfn(_Hint->_Myval), _Keyval))) {
                
                const auto _Next = (++(_Unchecked_const_iterator(_Hint, nullptr)))._Ptr;
                if (_Next->_Isnil || static_cast<bool>(_Comp(_Keyval, _Traits::_Kfn(_Next->_Myval)))) {
                    
                    if (_Hint->_Right->_Isnil) {
                        return {{_Hint, _Tree_child::_Right}, false};
                    }

                    return {{_Next, _Tree_child::_Left}, false};
                }
            } else {
                
                return {{_Hint, _Tree_child::_Right}, true};
            }

            const auto _Loc = _Find_lower_bound(_Keyval);
            if (_Lower_bound_duplicate(_Loc._Bound, _Keyval)) {
                return {{_Loc._Bound, _Tree_child::_Unused}, true};
            }

            return {_Loc._Location, false};
        }
    }

    template <class _Keyty>
    _Tree_find_result<_Nodeptr> _Find_upper_bound(const _Keyty& _Keyval) const {
        const auto _Scary = _Get_scary();
        _Tree_find_result<_Nodeptr> _Result{{_Scary->_Myhead->_Parent, _Tree_child::_Right}, _Scary->_Myhead};
        _Nodeptr _Trynode = _Result._Location._Parent;
        while (!_Trynode->_Isnil) {
            _Result._Location._Parent = _Trynode;
            if (static_cast<bool>(_Getcomp()(_Keyval, _Traits::_Kfn(_Trynode->_Myval)))) {
                _Result._Location._Child = _Tree_child::_Left;
                _Result._Bound           = _Trynode;
                _Trynode                 = _Trynode->_Left;
            } else {
                _Result._Location._Child = _Tree_child::_Right;
                _Trynode                 = _Trynode->_Right;
            }
        }

        return _Result;
    }

    template <class _Keyty>
    bool _Lower_bound_duplicate(const _Nodeptr _Bound, const _Keyty& _Keyval) const {
        return !_Bound->_Isnil && !static_cast<bool>(_Getcomp()(_Keyval, _Traits::_Kfn(_Bound->_Myval)));
    }

    template <class _Keyty>
    _Tree_find_result<_Nodeptr> _Find_lower_bound(const _Keyty& _Keyval) const {
        const auto _Scary = _Get_scary();
        _Tree_find_result<_Nodeptr> _Result{{_Scary->_Myhead->_Parent, _Tree_child::_Right}, _Scary->_Myhead};
        _Nodeptr _Trynode = _Result._Location._Parent;
        while (!_Trynode->_Isnil) {
            _Result._Location._Parent = _Trynode;
            if (static_cast<bool>(_Getcomp()(_Traits::_Kfn(_Trynode->_Myval), _Keyval))) {
                _Result._Location._Child = _Tree_child::_Right;
                _Trynode                 = _Trynode->_Right;
            } else {
                _Result._Location._Child = _Tree_child::_Left;
                _Result._Bound           = _Trynode;
                _Trynode                 = _Trynode->_Left;
            }
        }

        return _Result;
    }

    void _Check_grow_by_1() {
        if (max_size() == _Get_scary()->_Mysize) {
            _Throw_tree_length_error();
        }
    }

    template <class _Moveit>
    void _Copy(const _Tree& _Right, _Moveit _Movefl) { 
        const auto _Scary        = _Get_scary();
        const auto _Right_scary  = _Right._Get_scary();
        _Scary->_Myhead->_Parent = _Copy_nodes(_Right_scary->_Myhead->_Parent, _Scary->_Myhead, _Movefl);
        _Scary->_Mysize          = _Right_scary->_Mysize;
        if (!_Scary->_Myhead->_Parent->_Isnil) { 
            _Scary->_Myhead->_Left  = _Scary_val::_Min(_Scary->_Myhead->_Parent);
            _Scary->_Myhead->_Right = _Scary_val::_Max(_Scary->_Myhead->_Parent);
        } else { 
            _Scary->_Myhead->_Left  = _Scary->_Myhead;
            _Scary->_Myhead->_Right = _Scary->_Myhead;
        }
    }

    template <class _Ty, class _Is_set>
    _Nodeptr _Copy_or_move(_Ty& _Val, _Copy_tag, _Is_set) { 
        return _Buynode(_Val);
    }

    template <class _Ty>
    _Nodeptr _Copy_or_move(_Ty& _Val, _Move_tag, true_type) { 
        return _Buynode(::std:: move(_Val));
    }

    template <class _Ty>
    _Nodeptr _Copy_or_move(_Ty& _Val, _Move_tag, false_type) { 
        return _Buynode(::std:: move(const_cast<key_type&>(_Val.first)), ::std:: move(_Val.second));
    }

    template <class _Moveit>
    _Nodeptr _Copy_nodes(_Nodeptr _Rootnode, _Nodeptr _Wherenode, _Moveit _Movefl) {
        
        const auto _Scary = _Get_scary();
        _Nodeptr _Newroot = _Scary->_Myhead; 

        if (!_Rootnode->_Isnil) { 
            bool_constant<is_same_v<key_type, value_type>> _Is_set;
            _Nodeptr _Pnode = _Copy_or_move(_Rootnode->_Myval, _Movefl, _Is_set);
            _Pnode->_Parent = _Wherenode;
            _Pnode->_Color  = _Rootnode->_Color;
            if (_Newroot->_Isnil) {
                _Newroot = _Pnode; 
            }

            try {
            _Pnode->_Left  = _Copy_nodes(_Rootnode->_Left, _Pnode, _Movefl);
            _Pnode->_Right = _Copy_nodes(_Rootnode->_Right, _Pnode, _Movefl);
            } catch (...) {
            _Scary->_Erase_tree_and_orphan(_Getal(), _Newroot); 
            throw;
            }
        }

        return _Newroot; 
    }

    template <class _Other>
    pair<_Nodeptr, _Nodeptr> _Eqrange(const _Other& _Keyval) const
        noexcept(_Nothrow_compare<key_compare, key_type, _Other>&& _Nothrow_compare<key_compare, _Other, key_type>) {
        
        const auto _Scary = _Get_scary();
        const auto& _Comp = _Getcomp();
        _Nodeptr _Pnode   = _Scary->_Myhead->_Parent;
        _Nodeptr _Lonode  = _Scary->_Myhead; 
        _Nodeptr _Hinode  = _Scary->_Myhead; 

        while (!_Pnode->_Isnil) {
            const auto& _Nodekey = _Traits::_Kfn(_Pnode->_Myval);
            if (static_cast<bool>(_Comp(_Nodekey, _Keyval))) {
                _Pnode = _Pnode->_Right; 
            } else { 
                if (_Hinode->_Isnil && static_cast<bool>(_Comp(_Keyval, _Nodekey))) {
                    _Hinode = _Pnode; 
                }

                _Lonode = _Pnode;
                _Pnode  = _Pnode->_Left; 
            }
        }

        _Pnode = _Hinode->_Isnil ? _Scary->_Myhead->_Parent : _Hinode->_Left; 
        while (!_Pnode->_Isnil) {
            if (static_cast<bool>(_Getcomp()(_Keyval, _Traits::_Kfn(_Pnode->_Myval)))) {
                
                _Hinode = _Pnode;
                _Pnode  = _Pnode->_Left; 
            } else {
                _Pnode = _Pnode->_Right; 
            }
        }

        return {_Lonode, _Hinode};
    }


public:
    using node_type = typename _Traits::node_type;

    node_type extract(const const_iterator _Where) {
        const auto _Scary = _Get_scary();


#line 1728 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtree"

        const auto _Ptr = _Scary->_Extract(_Where._Unwrapped());
        _Scary->_Orphan_ptr(_Ptr);
        return node_type::_Make(_Ptr, _Getal());
    }

    node_type extract(const key_type& _Keyval) {
        const const_iterator _Where = find(_Keyval);
        if (_Where == end()) {
            return node_type{};
        }

        return extract(_Where);
    }


    template <class _Kx, class _Mycomp = key_compare, class = typename _Mycomp::is_transparent,
        enable_if_t<!disjunction_v<is_convertible<_Kx, const_iterator>, is_convertible<_Kx, iterator>>, int> = 0>
    node_type extract(_Kx&& _Keyval) {
        const const_iterator _Where = find(_Keyval);
        if (_Where == end()) {
            return node_type{};
        }

        return extract(_Where);
    }
#line 1755 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtree"

    auto insert(node_type&& _Handle) {
        if (_Handle.empty()) {
            if constexpr (_Multi) {
                return end();
            } else {
                return _Insert_return_type<iterator, node_type>{end(), false, {}};
            }
        }

        _Check_node_allocator(_Handle);
        const auto _Scary        = _Get_scary();
        const auto _Attempt_node = _Handle._Getptr();
        const auto& _Keyval      = _Traits::_Kfn(_Attempt_node->_Myval);
        _Tree_find_result<_Nodeptr> _Loc;
        if constexpr (_Multi) {
            _Loc = _Find_upper_bound(_Keyval);
        } else {
            _Loc = _Find_lower_bound(_Keyval);
            if (_Lower_bound_duplicate(_Loc._Bound, _Keyval)) {
                return _Insert_return_type<iterator, node_type>{
                    iterator(_Loc._Bound, _Scary), false, ::std:: move(_Handle)};
            }
        }

        _Check_grow_by_1();

        
        _Attempt_node->_Left = _Scary->_Myhead;
        
        _Attempt_node->_Right = _Scary->_Myhead;
        _Attempt_node->_Color = _Red;

        const auto _Inserted = _Scary->_Insert_node(_Loc._Location, _Handle._Release());
        if constexpr (_Multi) {
            return iterator(_Inserted, _Scary);
        } else {
            return _Insert_return_type<iterator, node_type>{iterator(_Inserted, _Scary), true, ::std:: move(_Handle)};
        }
    }

    iterator insert(const const_iterator _Hint, node_type&& _Handle) {
        const auto _Scary = _Get_scary();


#line 1802 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtree"
        if (_Handle.empty()) {
            return end();
        }

        _Check_node_allocator(_Handle);
        const auto _Attempt_node = _Handle._Getptr();
        const auto& _Keyval      = _Traits::_Kfn(_Attempt_node->_Myval);
        const auto _Loc          = _Find_hint(_Hint._Ptr, _Keyval);
        if (_Loc._Duplicate) {
            return iterator(_Loc._Location._Parent, _Scary);
        }

        _Check_grow_by_1();

        _Attempt_node->_Left = _Scary->_Myhead;
        
        _Attempt_node->_Right = _Scary->_Myhead;
        _Attempt_node->_Color = _Red;

        return iterator(_Scary->_Insert_node(_Loc._Location, _Handle._Release()), _Scary);
    }

    template <class>
    friend class _Tree;

    template <class _Other_traits>
    void merge(_Tree<_Other_traits>& _That) {
        static_assert(is_same_v<_Nodeptr, typename _Tree<_Other_traits>::_Nodeptr>,
            "merge() requires an argument with a compatible node type.");

        static_assert(is_same_v<allocator_type, typename _Tree<_Other_traits>::allocator_type>,
            "merge() requires an argument with the same allocator type.");

        if constexpr (is_same_v<_Tree, _Tree<_Other_traits>>) {
            if (this == ::std:: addressof(_That)) {
                return;
            }
        }


#line 1846 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtree"

        const auto _Scary      = _Get_scary();
        const auto _Head       = _Scary->_Myhead;
        const auto _That_scary = _That._Get_scary();
        auto _First            = _That._Unchecked_begin();
        while (!_First._Ptr->_Isnil) {
            const auto _Attempt_node = _First._Ptr;
            ++_First;
            _Tree_find_result<_Nodeptr> _Loc;
            const auto& _Keyval = _Traits::_Kfn(_Attempt_node->_Myval);
            if constexpr (_Multi) {
                _Loc = _Find_upper_bound(_Keyval);
            } else {
                _Loc = _Find_lower_bound(_Keyval);
                if (_Lower_bound_duplicate(_Loc._Bound, _Keyval)) {
                    continue;
                }
            }

            _Check_grow_by_1();

            
            const auto _Extracted = _That_scary->_Extract(_Unchecked_const_iterator(_Attempt_node, nullptr));
            _Extracted->_Left     = _Head;
            
            _Extracted->_Right = _Head;
            _Extracted->_Color = _Red;

            const auto _Inserted = _Scary->_Insert_node(_Loc._Location, _Extracted);
            _Reparent_ptr(_Inserted, _That);
        }
    }

    template <class _Other_traits>
    void merge(_Tree<_Other_traits>&& _That) {
        static_assert(is_same_v<_Nodeptr, typename _Tree<_Other_traits>::_Nodeptr>,
            "merge() requires an argument with a compatible node type.");

        static_assert(is_same_v<allocator_type, typename _Tree<_Other_traits>::allocator_type>,
            "merge() requires an argument with the same allocator type.");

        merge(_That);
    }

protected:
    template <class _Other_traits>
    void _Reparent_ptr(const _Nodeptr _Ptr, _Tree<_Other_traits>& _Old_parent) {
        (void) _Ptr;
        (void) _Old_parent;


#line 1920 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtree"
    }

    void _Check_node_allocator(node_type& _Handle) const {
        (void) _Handle;


#line 1927 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtree"
    }
#line 1929 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtree"

    void _Alloc_sentinel_and_proxy() {
        const auto _Scary = _Get_scary();
        auto&& _Alproxy   = _Fake_alloc;
        _Container_proxy_ptr<_Alnode> _Proxy(_Alproxy, *_Scary);
        _Scary->_Myhead = _Node::_Buyheadnode(_Getal());
        _Proxy._Release();
    }

    template <class... _Valty>
    _Nodeptr _Buynode(_Valty&&... _Val) {
        return _Node::_Buynode(_Getal(), _Get_scary()->_Myhead, ::std:: forward<_Valty>(_Val)...);
    }

    key_compare& _Getcomp() noexcept {
        return _Mypair._Get_first();
    }

    const key_compare& _Getcomp() const noexcept {
        return _Mypair._Get_first();
    }

    _Alnode& _Getal() noexcept {
        return _Mypair._Myval2._Get_first();
    }

    const _Alnode& _Getal() const noexcept {
        return _Mypair._Myval2._Get_first();
    }

    _Scary_val* _Get_scary() noexcept {
        return ::std:: addressof(_Mypair._Myval2._Myval2);
    }

    const _Scary_val* _Get_scary() const noexcept {
        return ::std:: addressof(_Mypair._Myval2._Myval2);
    }

private:
    _Compressed_pair<key_compare, _Compressed_pair<_Alnode, _Scary_val>> _Mypair;
};
}


#pragma warning(pop)
#pragma pack(pop)
#line 1977 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtree"
#line 1978 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xtree"
#line 14 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\map"


#line 18 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\map"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
template <class _Kty, 
    class _Ty, 
    class _Pr, 
    class _Alloc, 
    bool _Mfl> 
class _Tmap_traits { 
public:
    using key_type       = _Kty;
    using value_type     = pair<const _Kty, _Ty>;
    using key_compare    = _Pr;
    using allocator_type = _Alloc;

    using node_type = _Node_handle<_Tree_node<value_type, typename allocator_traits<_Alloc>::void_pointer>, _Alloc,
        _Node_handle_map_base, _Kty, _Ty>;
#line 41 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\map"

    static constexpr bool _Multi = _Mfl;

    template <class... _Args>
    using _In_place_key_extractor = _In_place_key_extract_map<_Kty, _Args...>;

    class value_compare {
    public:
        [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef value_type _Unnameable_first_argument;
        [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef value_type _Unnameable_second_argument;
        [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef bool _Unnameable_result;

        [[nodiscard]] bool operator()(const value_type& _Left, const value_type& _Right) const {
            
            return comp(_Left.first, _Right.first);
        }

    protected:
        friend _Tree<_Tmap_traits>;

        value_compare(key_compare _Pred) : comp(_Pred) {}

        key_compare comp; 
    };

    template <class _Ty1, class _Ty2>
    static const _Kty& _Kfn(const pair<_Ty1, _Ty2>& _Val) { 
        return _Val.first;
    }
};

template <class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty>>>
class map : public _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, false>> {
    
public:
    static_assert(!1 || is_same_v<pair<const _Kty, _Ty>, typename _Alloc::value_type>,
        "map<Key, Value, Compare, Allocator>" " requires that Allocator's value_type match " "pair<const Key, Value>" " (See N4659 26.2.1 [container.requirements.general]/16 allocator_type)" " Either fix the allocator value_type or define _ENFORCE_MATCHING_ALLOCATORS=0" " to suppress this diagnostic.");

    using _Mybase                = _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, false>>;
    using _Nodeptr               = typename _Mybase::_Nodeptr;
    using key_type               = _Kty;
    using mapped_type            = _Ty;
    using key_compare            = _Pr;
    using value_compare          = typename _Mybase::value_compare;
    using value_type             = pair<const _Kty, _Ty>;
    using allocator_type         = typename _Mybase::allocator_type;
    using size_type              = typename _Mybase::size_type;
    using difference_type        = typename _Mybase::difference_type;
    using pointer                = typename _Mybase::pointer;
    using const_pointer          = typename _Mybase::const_pointer;
    using reference              = value_type&;
    using const_reference        = const value_type&;
    using iterator               = typename _Mybase::iterator;
    using const_iterator         = typename _Mybase::const_iterator;
    using reverse_iterator       = typename _Mybase::reverse_iterator;
    using const_reverse_iterator = typename _Mybase::const_reverse_iterator;

    using _Alnode        = typename _Mybase::_Alnode;
    using _Alnode_traits = typename _Mybase::_Alnode_traits;


    using insert_return_type = _Insert_return_type<iterator, typename _Mybase::node_type>;
#line 104 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\map"

    map() : _Mybase(key_compare()) {}

    explicit map(const allocator_type& _Al) : _Mybase(key_compare(), _Al) {}

    map(const map& _Right) : _Mybase(_Right, _Alnode_traits::select_on_container_copy_construction(_Right._Getal())) {}

    map(const map& _Right, const allocator_type& _Al) : _Mybase(_Right, _Al) {}

    explicit map(const key_compare& _Pred) : _Mybase(_Pred) {}

    map(const key_compare& _Pred, const allocator_type& _Al) : _Mybase(_Pred, _Al) {}

    template <class _Iter>
    map(_Iter _First, _Iter _Last) : _Mybase(key_compare()) {
        insert(_First, _Last);
    }

    template <class _Iter>
    map(_Iter _First, _Iter _Last, const key_compare& _Pred) : _Mybase(_Pred) {
        insert(_First, _Last);
    }

    template <class _Iter>
    map(_Iter _First, _Iter _Last, const allocator_type& _Al) : _Mybase(key_compare(), _Al) {
        insert(_First, _Last);
    }

    template <class _Iter>
    map(_Iter _First, _Iter _Last, const key_compare& _Pred, const allocator_type& _Al) : _Mybase(_Pred, _Al) {
        insert(_First, _Last);
    }

    map& operator=(const map& _Right) {
        _Mybase::operator=(_Right);
        return *this;
    }

    map(map&& _Right) : _Mybase(::std:: move(_Right)) {}

    map(map&& _Right, const allocator_type& _Al) : _Mybase(::std:: move(_Right), _Al) {}

    map& operator=(map&& _Right) noexcept(_Alnode_traits::is_always_equal::value&& is_nothrow_move_assignable_v<_Pr>) {
        _Mybase::operator=(::std:: move(_Right));
        return *this;
    }

    mapped_type& operator[](key_type&& _Keyval) { 
        return _Try_emplace(::std:: move(_Keyval)).first->_Myval.second;
    }

    void swap(map& _Right) noexcept(noexcept(_Mybase::swap(_Right))) {
        _Mybase::swap(_Right);
    }

    using _Mybase::insert;

    template <class _Valty, enable_if_t<is_constructible_v<value_type, _Valty>, int> = 0>
    pair<iterator, bool> insert(_Valty&& _Val) {
        return this->emplace(::std:: forward<_Valty>(_Val));
    }

    template <class _Valty, enable_if_t<is_constructible_v<value_type, _Valty>, int> = 0>
    iterator insert(const_iterator _Where, _Valty&& _Val) {
        return this->emplace_hint(_Where, ::std:: forward<_Valty>(_Val));
    }

private:
    template <class _Keyty, class... _Mappedty>
    pair<_Nodeptr, bool> _Try_emplace(_Keyty&& _Keyval, _Mappedty&&... _Mapval) {
        const auto _Loc = _Mybase::_Find_lower_bound(_Keyval);
        if (_Mybase::_Lower_bound_duplicate(_Loc._Bound, _Keyval)) {
            return {_Loc._Bound, false};
        }

        _Mybase::_Check_grow_by_1();

        const auto _Scary    = _Mybase::_Get_scary();
        const auto _Inserted = _Tree_temp_node<_Alnode>(_Mybase::_Getal(), _Scary->_Myhead, piecewise_construct,
            ::std:: forward_as_tuple(::std:: forward<_Keyty>(_Keyval)),
            ::std:: forward_as_tuple(::std:: forward<_Mappedty>(_Mapval)...))
                                   ._Release();

        
        return {_Scary->_Insert_node(_Loc._Location, _Inserted), true};
    }

    template <class _Keyty, class... _Mappedty>
    _Nodeptr _Try_emplace_hint(const _Nodeptr _Hint, _Keyty&& _Keyval, _Mappedty&&... _Mapval) {
        const auto _Loc = _Mybase::_Find_hint(_Hint, _Keyval);
        if (_Loc._Duplicate) {
            return _Loc._Location._Parent;
        }

        _Mybase::_Check_grow_by_1();

        const auto _Scary    = _Mybase::_Get_scary();
        const auto _Inserted = _Tree_temp_node<_Alnode>(_Mybase::_Getal(), _Scary->_Myhead, piecewise_construct,
            ::std:: forward_as_tuple(::std:: forward<_Keyty>(_Keyval)),
            ::std:: forward_as_tuple(::std:: forward<_Mappedty>(_Mapval)...))
                                   ._Release();

        
        return _Scary->_Insert_node(_Loc._Location, _Inserted);
    }

public:
    template <class... _Mappedty>
    pair<iterator, bool> try_emplace(const key_type& _Keyval, _Mappedty&&... _Mapval) {
        const auto _Result = _Try_emplace(_Keyval, ::std:: forward<_Mappedty>(_Mapval)...);
        return {iterator(_Result.first, _Mybase::_Get_scary()), _Result.second};
    }

    template <class... _Mappedty>
    iterator try_emplace(const const_iterator _Hint, const key_type& _Keyval, _Mappedty&&... _Mapval) {
        return iterator(
            _Try_emplace_hint(_Hint._Ptr, _Keyval, ::std:: forward<_Mappedty>(_Mapval)...), _Mybase::_Get_scary());
    }

    template <class... _Mappedty>
    pair<iterator, bool> try_emplace(key_type&& _Keyval, _Mappedty&&... _Mapval) {
        const auto _Result = _Try_emplace(::std:: move(_Keyval), ::std:: forward<_Mappedty>(_Mapval)...);
        return {iterator(_Result.first, _Mybase::_Get_scary()), _Result.second};
    }

    template <class... _Mappedty>
    iterator try_emplace(const const_iterator _Hint, key_type&& _Keyval, _Mappedty&&... _Mapval) {
        return iterator(_Try_emplace_hint(_Hint._Ptr, ::std:: move(_Keyval), ::std:: forward<_Mappedty>(_Mapval)...),
            _Mybase::_Get_scary());
    }

private:
    template <class _Keyty, class _Mappedty>
    pair<_Nodeptr, bool> _Insert_or_assign(_Keyty&& _Keyval, _Mappedty&& _Mapval) {
        const auto _Loc = _Mybase::_Find_lower_bound(_Keyval);
        if (_Mybase::_Lower_bound_duplicate(_Loc._Bound, _Keyval)) {
            _Loc._Bound->_Myval.second = ::std:: forward<_Mappedty>(_Mapval);
            return {_Loc._Bound, false};
        }

        _Mybase::_Check_grow_by_1();

        const auto _Scary    = _Mybase::_Get_scary();
        const auto _Inserted = _Tree_temp_node<_Alnode>(
            _Mybase::_Getal(), _Scary->_Myhead, ::std:: forward<_Keyty>(_Keyval), ::std:: forward<_Mappedty>(_Mapval))
                                   ._Release();

        
        return {_Scary->_Insert_node(_Loc._Location, _Inserted), true};
    }

    template <class _Keyty, class _Mappedty>
    _Nodeptr _Insert_or_assign_hint(const _Nodeptr _Hint, _Keyty&& _Keyval, _Mappedty&& _Mapval) {
        const auto _Loc = _Mybase::_Find_hint(_Hint, _Keyval);
        if (_Loc._Duplicate) {
            _Loc._Location._Parent->_Myval.second = ::std:: forward<_Mappedty>(_Mapval);
            return _Loc._Location._Parent;
        }

        _Mybase::_Check_grow_by_1();

        const auto _Scary    = _Mybase::_Get_scary();
        const auto _Inserted = _Tree_temp_node<_Alnode>(
            _Mybase::_Getal(), _Scary->_Myhead, ::std:: forward<_Keyty>(_Keyval), ::std:: forward<_Mappedty>(_Mapval))
                                   ._Release();

        
        return _Scary->_Insert_node(_Loc._Location, _Inserted);
    }

public:
    template <class _Mappedty>
    pair<iterator, bool> insert_or_assign(const key_type& _Keyval, _Mappedty&& _Mapval) {
        const auto _Result = _Insert_or_assign(_Keyval, ::std:: forward<_Mappedty>(_Mapval));
        return {iterator(_Result.first, _Mybase::_Get_scary()), _Result.second};
    }

    template <class _Mappedty>
    iterator insert_or_assign(const const_iterator _Hint, const key_type& _Keyval, _Mappedty&& _Mapval) {
        return iterator(
            _Insert_or_assign_hint(_Hint._Ptr, _Keyval, ::std:: forward<_Mappedty>(_Mapval)), _Mybase::_Get_scary());
    }

    template <class _Mappedty>
    pair<iterator, bool> insert_or_assign(key_type&& _Keyval, _Mappedty&& _Mapval) {
        const auto _Result = _Insert_or_assign(::std:: move(_Keyval), ::std:: forward<_Mappedty>(_Mapval));
        return {iterator(_Result.first, _Mybase::_Get_scary()), _Result.second};
    }

    template <class _Mappedty>
    iterator insert_or_assign(const const_iterator _Hint, key_type&& _Keyval, _Mappedty&& _Mapval) {
        return iterator(_Insert_or_assign_hint(_Hint._Ptr, ::std:: move(_Keyval), ::std:: forward<_Mappedty>(_Mapval)),
            _Mybase::_Get_scary());
    }

    map(initializer_list<value_type> _Ilist) : _Mybase(key_compare()) {
        insert(_Ilist);
    }

    map(initializer_list<value_type> _Ilist, const key_compare& _Pred) : _Mybase(_Pred) {
        insert(_Ilist);
    }

    map(initializer_list<value_type> _Ilist, const allocator_type& _Al) : _Mybase(key_compare(), _Al) {
        insert(_Ilist);
    }

    map(initializer_list<value_type> _Ilist, const key_compare& _Pred, const allocator_type& _Al)
        : _Mybase(_Pred, _Al) {
        insert(_Ilist);
    }

    map& operator=(initializer_list<value_type> _Ilist) {
        _Mybase::clear();
        insert(_Ilist);
        return *this;
    }

    mapped_type& operator[](const key_type& _Keyval) {
        return _Try_emplace(_Keyval).first->_Myval.second;
    }

    [[nodiscard]] mapped_type& at(const key_type& _Keyval) {
        const auto _Loc = _Mybase::_Find_lower_bound(_Keyval);
        if (!_Mybase::_Lower_bound_duplicate(_Loc._Bound, _Keyval)) {
            _Xout_of_range("invalid map<K, T> key");
        }

        return _Loc._Bound->_Myval.second;
    }

    [[nodiscard]] const mapped_type& at(const key_type& _Keyval) const {
        const auto _Loc = _Mybase::_Find_lower_bound(_Keyval);
        if (!_Mybase::_Lower_bound_duplicate(_Loc._Bound, _Keyval)) {
            _Xout_of_range("invalid map<K, T> key");
        }

        return _Loc._Bound->_Myval.second;
    }

    using _Mybase::_Unchecked_begin;
    using _Mybase::_Unchecked_end;
};


template <class _Iter, class _Pr = less<_Guide_key_t<_Iter>>, class _Alloc = allocator<_Guide_pair_t<_Iter>>,
    enable_if_t<conjunction_v<_Is_iterator<_Iter>, negation<_Is_allocator<_Pr>>, _Is_allocator<_Alloc>>, int> = 0>
map(_Iter, _Iter, _Pr = _Pr(), _Alloc = _Alloc()) -> map<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>, _Pr, _Alloc>;

template <class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty>>,
    enable_if_t<conjunction_v<negation<_Is_allocator<_Pr>>, _Is_allocator<_Alloc>>, int> = 0>
map(initializer_list<pair<_Kty, _Ty>>, _Pr = _Pr(), _Alloc = _Alloc()) -> map<_Kty, _Ty, _Pr, _Alloc>;

template <class _Iter, class _Alloc, enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
map(_Iter, _Iter, _Alloc) -> map<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>, less<_Guide_key_t<_Iter>>, _Alloc>;

template <class _Kty, class _Ty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
map(initializer_list<pair<_Kty, _Ty>>, _Alloc) -> map<_Kty, _Ty, less<_Kty>, _Alloc>;
#line 363 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\map"

template <class _Kty, class _Ty, class _Pr, class _Alloc>
[[nodiscard]] bool operator==(const map<_Kty, _Ty, _Pr, _Alloc>& _Left, const map<_Kty, _Ty, _Pr, _Alloc>& _Right) {
    return _Left.size() == _Right.size()
        && ::std:: equal(_Left._Unchecked_begin(), _Left._Unchecked_end_iter(), _Right._Unchecked_begin());
}


#line 376 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\map"


template <class _Kty, class _Ty, class _Pr, class _Alloc>
[[nodiscard]] _Synth_three_way_result<pair<const _Kty, _Ty>> operator<=>(
    const map<_Kty, _Ty, _Pr, _Alloc>& _Left, const map<_Kty, _Ty, _Pr, _Alloc>& _Right) {
    return ::std:: lexicographical_compare_three_way(_Left._Unchecked_begin(), _Left._Unchecked_end_iter(),
        _Right._Unchecked_begin(), _Right._Unchecked_end_iter(), _Synth_three_way{});
}


#line 406 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\map"

template <class _Kty, class _Ty, class _Pr, class _Alloc>
void swap(map<_Kty, _Ty, _Pr, _Alloc>& _Left, map<_Kty, _Ty, _Pr, _Alloc>& _Right) noexcept(
    noexcept(_Left.swap(_Right))) {
    _Left.swap(_Right);
}


template <class _Kty, class _Ty, class _Keylt, class _Alloc, class _Pr>
typename map<_Kty, _Ty, _Keylt, _Alloc>::size_type erase_if(map<_Kty, _Ty, _Keylt, _Alloc>& _Cont, _Pr _Pred) {
    return _Erase_nodes_if(_Cont, _Pass_fn(_Pred));
}
#line 419 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\map"

template <class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty>>>
class multimap : public _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, true>> {
    
public:
    static_assert(!1 || is_same_v<pair<const _Kty, _Ty>, typename _Alloc::value_type>,
        "multimap<Key, Value, Compare, Allocator>" " requires that Allocator's value_type match " "pair<const Key, Value>" " (See N4659 26.2.1 [container.requirements.general]/16 allocator_type)" " Either fix the allocator value_type or define _ENFORCE_MATCHING_ALLOCATORS=0" " to suppress this diagnostic.");

    using _Mybase                = _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, true>>;
    using key_type               = _Kty;
    using mapped_type            = _Ty;
    using key_compare            = _Pr;
    using value_compare          = typename _Mybase::value_compare;
    using value_type             = pair<const _Kty, _Ty>;
    using allocator_type         = typename _Mybase::allocator_type;
    using size_type              = typename _Mybase::size_type;
    using difference_type        = typename _Mybase::difference_type;
    using pointer                = typename _Mybase::pointer;
    using const_pointer          = typename _Mybase::const_pointer;
    using reference              = value_type&;
    using const_reference        = const value_type&;
    using iterator               = typename _Mybase::iterator;
    using const_iterator         = typename _Mybase::const_iterator;
    using reverse_iterator       = typename _Mybase::reverse_iterator;
    using const_reverse_iterator = typename _Mybase::const_reverse_iterator;

    using _Alnode        = typename _Mybase::_Alnode;
    using _Alnode_traits = typename _Mybase::_Alnode_traits;

    multimap() : _Mybase(key_compare()) {}

    explicit multimap(const allocator_type& _Al) : _Mybase(key_compare(), _Al) {}

    multimap(const multimap& _Right)
        : _Mybase(_Right, _Alnode_traits::select_on_container_copy_construction(_Right._Getal())) {}

    multimap(const multimap& _Right, const allocator_type& _Al) : _Mybase(_Right, _Al) {}

    explicit multimap(const key_compare& _Pred) : _Mybase(_Pred) {}

    multimap(const key_compare& _Pred, const allocator_type& _Al) : _Mybase(_Pred, _Al) {}

    template <class _Iter>
    multimap(_Iter _First, _Iter _Last) : _Mybase(key_compare()) {
        insert(_First, _Last);
    }

    template <class _Iter>
    multimap(_Iter _First, _Iter _Last, const key_compare& _Pred) : _Mybase(_Pred) {
        insert(_First, _Last);
    }

    template <class _Iter>
    multimap(_Iter _First, _Iter _Last, const allocator_type& _Al) : _Mybase(key_compare(), _Al) {
        insert(_First, _Last);
    }

    template <class _Iter>
    multimap(_Iter _First, _Iter _Last, const key_compare& _Pred, const allocator_type& _Al) : _Mybase(_Pred, _Al) {
        insert(_First, _Last);
    }

    multimap& operator=(const multimap& _Right) {
        _Mybase::operator=(_Right);
        return *this;
    }

    multimap(multimap&& _Right) : _Mybase(::std:: move(_Right)) {}

    multimap(multimap&& _Right, const allocator_type& _Al) : _Mybase(::std:: move(_Right), _Al) {}

    multimap& operator=(multimap&& _Right) noexcept(
        _Alnode_traits::is_always_equal::value&& is_nothrow_move_assignable_v<_Pr>) {
        _Mybase::operator=(::std:: move(_Right));
        return *this;
    }

    template <class... _Valty>
    iterator emplace(_Valty&&... _Val) {
        return _Mybase::emplace(::std:: forward<_Valty>(_Val)...).first;
    }

    void swap(multimap& _Right) noexcept(noexcept(_Mybase::swap(_Right))) {
        _Mybase::swap(_Right);
    }

    using _Mybase::insert;

    template <class _Valty, enable_if_t<is_constructible_v<value_type, _Valty>, int> = 0>
    iterator insert(_Valty&& _Val) {
        return this->emplace(::std:: forward<_Valty>(_Val));
    }

    template <class _Valty, enable_if_t<is_constructible_v<value_type, _Valty>, int> = 0>
    iterator insert(const_iterator _Where, _Valty&& _Val) {
        return this->emplace_hint(_Where, ::std:: forward<_Valty>(_Val));
    }

    multimap(initializer_list<value_type> _Ilist) : _Mybase(key_compare()) {
        insert(_Ilist);
    }

    multimap(initializer_list<value_type> _Ilist, const key_compare& _Pred) : _Mybase(_Pred) {
        insert(_Ilist);
    }

    multimap(initializer_list<value_type> _Ilist, const allocator_type& _Al) : _Mybase(key_compare(), _Al) {
        insert(_Ilist);
    }

    multimap(initializer_list<value_type> _Ilist, const key_compare& _Pred, const allocator_type& _Al)
        : _Mybase(_Pred, _Al) {
        insert(_Ilist);
    }

    multimap& operator=(initializer_list<value_type> _Ilist) {
        _Mybase::clear();
        insert(_Ilist);
        return *this;
    }

    using _Mybase::_Unchecked_begin;
    using _Mybase::_Unchecked_end;
};


template <class _Iter, class _Pr = less<_Guide_key_t<_Iter>>, class _Alloc = allocator<_Guide_pair_t<_Iter>>,
    enable_if_t<conjunction_v<_Is_iterator<_Iter>, negation<_Is_allocator<_Pr>>, _Is_allocator<_Alloc>>, int> = 0>
multimap(_Iter, _Iter, _Pr = _Pr(), _Alloc = _Alloc())
    -> multimap<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>, _Pr, _Alloc>;

template <class _Kty, class _Ty, class _Pr = less<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty>>,
    enable_if_t<conjunction_v<negation<_Is_allocator<_Pr>>, _Is_allocator<_Alloc>>, int> = 0>
multimap(initializer_list<pair<_Kty, _Ty>>, _Pr = _Pr(), _Alloc = _Alloc()) -> multimap<_Kty, _Ty, _Pr, _Alloc>;

template <class _Iter, class _Alloc, enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
multimap(_Iter, _Iter, _Alloc) -> multimap<_Guide_key_t<_Iter>, _Guide_val_t<_Iter>, less<_Guide_key_t<_Iter>>, _Alloc>;

template <class _Kty, class _Ty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
multimap(initializer_list<pair<_Kty, _Ty>>, _Alloc) -> multimap<_Kty, _Ty, less<_Kty>, _Alloc>;
#line 560 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\map"

template <class _Kty, class _Ty, class _Pr, class _Alloc>
[[nodiscard]] bool operator==(
    const multimap<_Kty, _Ty, _Pr, _Alloc>& _Left, const multimap<_Kty, _Ty, _Pr, _Alloc>& _Right) {
    return _Left.size() == _Right.size()
        && ::std:: equal(_Left._Unchecked_begin(), _Left._Unchecked_end_iter(), _Right._Unchecked_begin());
}


#line 575 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\map"


template <class _Kty, class _Ty, class _Pr, class _Alloc>
[[nodiscard]] _Synth_three_way_result<pair<const _Kty, _Ty>> operator<=>(
    const multimap<_Kty, _Ty, _Pr, _Alloc>& _Left, const multimap<_Kty, _Ty, _Pr, _Alloc>& _Right) {
    return ::std:: lexicographical_compare_three_way(_Left._Unchecked_begin(), _Left._Unchecked_end_iter(),
        _Right._Unchecked_begin(), _Right._Unchecked_end_iter(), _Synth_three_way{});
}


#line 609 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\map"

template <class _Kty, class _Ty, class _Pr, class _Alloc>
void swap(multimap<_Kty, _Ty, _Pr, _Alloc>& _Left, multimap<_Kty, _Ty, _Pr, _Alloc>& _Right) noexcept(
    noexcept(_Left.swap(_Right))) {
    _Left.swap(_Right);
}


template <class _Kty, class _Ty, class _Keylt, class _Alloc, class _Pr>
typename multimap<_Kty, _Ty, _Keylt, _Alloc>::size_type erase_if(
    multimap<_Kty, _Ty, _Keylt, _Alloc>& _Cont, _Pr _Pred) {
    return _Erase_nodes_if(_Cont, _Pass_fn(_Pred));
}
#line 623 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\map"


namespace pmr {
    template <class _Kty, class _Ty, class _Pr = less<_Kty>>
    using map = ::std:: map<_Kty, _Ty, _Pr, polymorphic_allocator<pair<const _Kty, _Ty>>>;

    template <class _Kty, class _Ty, class _Pr = less<_Kty>>
    using multimap = ::std:: multimap<_Kty, _Ty, _Pr, polymorphic_allocator<pair<const _Kty, _Ty>>>;
} 
#line 633 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\map"
}


#pragma warning(pop)
#pragma pack(pop)
#line 639 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\map"
#line 640 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\map"
#line 61 "all-std.cxx"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\queue"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
template <class _Ty, class _Container = deque<_Ty>>
class queue {
public:
    using value_type      = typename _Container::value_type;
    using reference       = typename _Container::reference;
    using const_reference = typename _Container::const_reference;
    using size_type       = typename _Container::size_type;
    using container_type  = _Container;

    static_assert(is_same_v<_Ty, value_type>, "container adaptors require consistent types");

    queue() = default;

    explicit queue(const _Container& _Cont) : c(_Cont) {}

    explicit queue(_Container&& _Cont) noexcept(is_nothrow_move_constructible_v<_Container>) 
        : c(::std:: move(_Cont)) {}


    template <class _InIt, enable_if_t<_Is_iterator_v<_InIt>, int> = 0>
    queue(_InIt _First, _InIt _Last) noexcept(is_nothrow_constructible_v<_Container, _InIt, _InIt>) 
        : c(::std:: move(_First), ::std:: move(_Last)) {}
#line 46 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\queue"

    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
    explicit queue(const _Alloc& _Al) noexcept(is_nothrow_constructible_v<_Container, const _Alloc&>) 
        : c(_Al) {}

    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
    queue(const _Container& _Cont, const _Alloc& _Al) : c(_Cont, _Al) {}

    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
    queue(_Container&& _Cont, const _Alloc& _Al) noexcept(
        is_nothrow_constructible_v<_Container, _Container, const _Alloc&>) 
        : c(::std:: move(_Cont), _Al) {}

    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
    queue(const queue& _Right, const _Alloc& _Al) : c(_Right.c, _Al) {}

    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
    queue(queue&& _Right, const _Alloc& _Al) noexcept(
        is_nothrow_constructible_v<_Container, _Container, const _Alloc&>) 
        : c(::std:: move(_Right.c), _Al) {}


    template <class _InIt, class _Alloc,
        enable_if_t<conjunction_v<_Is_iterator<_InIt>, uses_allocator<_Container, _Alloc>>, int> = 0>
    queue(_InIt _First, _InIt _Last, const _Alloc& _Al) noexcept(
        is_nothrow_constructible_v<_Container, _InIt, _InIt, const _Alloc&>) 
        : c(::std:: move(_First), ::std:: move(_Last), _Al) {}
#line 74 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\queue"

    [[nodiscard]] bool empty() const noexcept(noexcept(c.empty()))  {
        return c.empty();
    }

    [[nodiscard]] size_type size() const noexcept(noexcept(c.size()))  {
        return c.size();
    }

    [[nodiscard]] reference front() noexcept(noexcept(c.front()))  {
        return c.front();
    }

    [[nodiscard]] const_reference front() const noexcept(noexcept(c.front()))  {
        return c.front();
    }

    [[nodiscard]] reference back() noexcept(noexcept(c.back()))  {
        return c.back();
    }

    [[nodiscard]] const_reference back() const noexcept(noexcept(c.back()))  {
        return c.back();
    }

    void push(const value_type& _Val) {
        c.push_back(_Val);
    }

    void push(value_type&& _Val) {
        c.push_back(::std:: move(_Val));
    }

    template <class... _Valty>
    decltype(auto) emplace(_Valty&&... _Val) {

        return c.emplace_back(::std:: forward<_Valty>(_Val)...);


#line 114 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\queue"
    }

    void pop() noexcept(noexcept(c.pop_front()))  {
        c.pop_front();
    }

    void swap(queue& _Right) noexcept(_Is_nothrow_swappable<_Container>::value) {
        _Swap_adl(c, _Right.c);
    }

    [[nodiscard]] const _Container& _Get_container() const noexcept {
        return c;
    }

protected:
    _Container c{};
};


template <class _Container, enable_if_t<!_Is_allocator<_Container>::value, int> = 0>
queue(_Container) -> queue<typename _Container::value_type, _Container>;

template <class _Container, class _Alloc,
    enable_if_t<conjunction_v<negation<_Is_allocator<_Container>>, uses_allocator<_Container, _Alloc>>, int> = 0>
queue(_Container, _Alloc) -> queue<typename _Container::value_type, _Container>;
#line 140 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\queue"


template <class _InIt, class _Alloc = allocator<_Iter_value_t<_InIt>>,
    enable_if_t<conjunction_v<_Is_iterator<_InIt>, _Is_allocator<_Alloc>>, int> = 0>
queue(_InIt, _InIt, _Alloc = _Alloc()) -> queue<_Iter_value_t<_InIt>, deque<_Iter_value_t<_InIt>, _Alloc>>;
#line 146 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\queue"

template <class _Ty, class _Container>
[[nodiscard]] bool operator==(const queue<_Ty, _Container>& _Left, const queue<_Ty, _Container>& _Right) {
    return _Left._Get_container() == _Right._Get_container();
}

template <class _Ty, class _Container>
[[nodiscard]] bool operator!=(const queue<_Ty, _Container>& _Left, const queue<_Ty, _Container>& _Right) {
    return _Left._Get_container() != _Right._Get_container();
}

template <class _Ty, class _Container>
[[nodiscard]] bool operator<(const queue<_Ty, _Container>& _Left, const queue<_Ty, _Container>& _Right) {
    return _Left._Get_container() < _Right._Get_container();
}

template <class _Ty, class _Container>
[[nodiscard]] bool operator>(const queue<_Ty, _Container>& _Left, const queue<_Ty, _Container>& _Right) {
    return _Left._Get_container() > _Right._Get_container();
}

template <class _Ty, class _Container>
[[nodiscard]] bool operator<=(const queue<_Ty, _Container>& _Left, const queue<_Ty, _Container>& _Right) {
    return _Left._Get_container() <= _Right._Get_container();
}

template <class _Ty, class _Container>
[[nodiscard]] bool operator>=(const queue<_Ty, _Container>& _Left, const queue<_Ty, _Container>& _Right) {
    return _Left._Get_container() >= _Right._Get_container();
}


template <class _Ty, three_way_comparable _Container>
[[nodiscard]] compare_three_way_result_t<_Container> operator<=>(
    const queue<_Ty, _Container>& _Left, const queue<_Ty, _Container>& _Right) {
    return _Left._Get_container() <=> _Right._Get_container();
}
#line 184 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\queue"

template <class _Ty, class _Container, enable_if_t<_Is_swappable<_Container>::value, int> = 0>
void swap(queue<_Ty, _Container>& _Left, queue<_Ty, _Container>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
    _Left.swap(_Right);
}

template <class _Ty, class _Container, class _Alloc>
struct uses_allocator<queue<_Ty, _Container>, _Alloc> : uses_allocator<_Container, _Alloc>::type {};

template <class _Ty, class _Container = vector<_Ty>, class _Pr = less<typename _Container::value_type>>
class priority_queue {
public:
    using value_type      = typename _Container::value_type;
    using reference       = typename _Container::reference;
    using const_reference = typename _Container::const_reference;
    using size_type       = typename _Container::size_type;
    using container_type  = _Container;
    using value_compare   = _Pr;

    static_assert(is_same_v<_Ty, value_type>, "container adaptors require consistent types");

    priority_queue() = default;

    explicit priority_queue(const _Pr& _Pred) noexcept(
        is_nothrow_default_constructible_v<_Container>&& is_nothrow_copy_constructible_v<value_compare>) 
        : c(), comp(_Pred) {}

    priority_queue(const _Pr& _Pred, const _Container& _Cont) : c(_Cont), comp(_Pred) {
        ::std:: make_heap(c.begin(), c.end(), comp);
    }

    priority_queue(const _Pr& _Pred, _Container&& _Cont) : c(::std:: move(_Cont)), comp(_Pred) {
        ::std:: make_heap(c.begin(), c.end(), comp);
    }

    template <class _InIt, enable_if_t<_Is_iterator_v<_InIt>, int> = 0>
    priority_queue(_InIt _First, _InIt _Last, const _Pr& _Pred, const _Container& _Cont) : c(_Cont), comp(_Pred) {
        c.insert(c.end(), _First, _Last);
        ::std:: make_heap(c.begin(), c.end(), comp);
    }

    template <class _InIt, enable_if_t<_Is_iterator_v<_InIt>, int> = 0>
    priority_queue(_InIt _First, _InIt _Last) : c(_First, _Last), comp() {
        ::std:: make_heap(c.begin(), c.end(), comp);
    }

    template <class _InIt, enable_if_t<_Is_iterator_v<_InIt>, int> = 0>
    priority_queue(_InIt _First, _InIt _Last, const _Pr& _Pred) : c(_First, _Last), comp(_Pred) {
        ::std:: make_heap(c.begin(), c.end(), comp);
    }

    template <class _InIt, enable_if_t<_Is_iterator_v<_InIt>, int> = 0>
    priority_queue(_InIt _First, _InIt _Last, const _Pr& _Pred, _Container&& _Cont) : c(::std:: move(_Cont)), comp(_Pred) {
        c.insert(c.end(), _First, _Last);
        ::std:: make_heap(c.begin(), c.end(), comp);
    }

    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
    explicit priority_queue(const _Alloc& _Al) noexcept(is_nothrow_constructible_v<_Container, const _Alloc&>&&
            is_nothrow_default_constructible_v<value_compare>) 
        : c(_Al), comp() {}

    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
    priority_queue(const _Pr& _Pred, const _Alloc& _Al) noexcept(is_nothrow_constructible_v<_Container, const _Alloc&>&&
            is_nothrow_copy_constructible_v<value_compare>) 
        : c(_Al), comp(_Pred) {}

    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
    priority_queue(const _Pr& _Pred, const _Container& _Cont, const _Alloc& _Al) : c(_Cont, _Al), comp(_Pred) {
        ::std:: make_heap(c.begin(), c.end(), comp);
    }

    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
    priority_queue(const _Pr& _Pred, _Container&& _Cont, const _Alloc& _Al) : c(::std:: move(_Cont), _Al), comp(_Pred) {
        ::std:: make_heap(c.begin(), c.end(), comp);
    }

    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
    priority_queue(const priority_queue& _Right, const _Alloc& _Al) : c(_Right.c, _Al), comp(_Right.comp) {}

    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
    priority_queue(priority_queue&& _Right, const _Alloc& _Al) noexcept(
        is_nothrow_constructible_v<_Container, _Container, const _Alloc&>&&
            is_nothrow_move_constructible_v<value_compare>) 
        : c(::std:: move(_Right.c), _Al), comp(::std:: move(_Right.comp)) {}

    template <class _InIt, class _Alloc,
        enable_if_t<_Is_iterator_v<_InIt> && uses_allocator_v<_Container, _Alloc>, int> = 0>
    priority_queue(_InIt _First, _InIt _Last, const _Alloc& _Al) : c(_First, _Last, _Al), comp() {
        ::std:: make_heap(c.begin(), c.end(), comp);
    }

    template <class _InIt, class _Alloc,
        enable_if_t<_Is_iterator_v<_InIt> && uses_allocator_v<_Container, _Alloc>, int> = 0>
    priority_queue(_InIt _First, _InIt _Last, const _Pr& _Pred, const _Alloc& _Al)
        : c(_First, _Last, _Al), comp(_Pred) {
        ::std:: make_heap(c.begin(), c.end(), comp);
    }

    template <class _InIt, class _Alloc,
        enable_if_t<_Is_iterator_v<_InIt> && uses_allocator_v<_Container, _Alloc>, int> = 0>
    priority_queue(_InIt _First, _InIt _Last, const _Pr& _Pred, const _Container& _Cont, const _Alloc& _Al)
        : c(_Cont, _Al), comp(_Pred) {
        c.insert(c.end(), _First, _Last);
        ::std:: make_heap(c.begin(), c.end(), comp);
    }

    template <class _InIt, class _Alloc,
        enable_if_t<_Is_iterator_v<_InIt> && uses_allocator_v<_Container, _Alloc>, int> = 0>
    priority_queue(_InIt _First, _InIt _Last, const _Pr& _Pred, _Container&& _Cont, const _Alloc& _Al)
        : c(::std:: move(_Cont), _Al), comp(_Pred) {
        c.insert(c.end(), _First, _Last);
        ::std:: make_heap(c.begin(), c.end(), comp);
    }

    [[nodiscard]] bool empty() const noexcept(noexcept(c.empty()))  {
        return c.empty();
    }

    [[nodiscard]] size_type size() const noexcept(noexcept(c.size()))  {
        return c.size();
    }

    [[nodiscard]] const_reference top() const noexcept(noexcept(c.front()))  {
        return c.front();
    }

    void push(const value_type& _Val) {
        c.push_back(_Val);
        ::std:: push_heap(c.begin(), c.end(), comp);
    }

    void push(value_type&& _Val) {
        c.push_back(::std:: move(_Val));
        ::std:: push_heap(c.begin(), c.end(), comp);
    }

    template <class... _Valty>
    void emplace(_Valty&&... _Val) {
        c.emplace_back(::std:: forward<_Valty>(_Val)...);
        ::std:: push_heap(c.begin(), c.end(), comp);
    }

    void pop() {
        ::std:: pop_heap(c.begin(), c.end(), comp);
        c.pop_back();
    }

    void swap(priority_queue& _Right) noexcept(
        _Is_nothrow_swappable<_Container>::value&& _Is_nothrow_swappable<_Pr>::value) {
        _Swap_adl(c, _Right.c);
        _Swap_adl(comp, _Right.comp);
    }

protected:
    _Container c{};
    _Pr comp{};
};


template <class _Pr, class _Container,
    enable_if_t<conjunction_v<negation<_Is_allocator<_Pr>>, negation<_Is_allocator<_Container>>>, int> = 0>
priority_queue(_Pr, _Container) -> priority_queue<typename _Container::value_type, _Container, _Pr>;

template <class _Iter, class _Pr = less<_Iter_value_t<_Iter>>, class _Container = vector<_Iter_value_t<_Iter>>,
    enable_if_t<conjunction_v<_Is_iterator<_Iter>, negation<_Is_allocator<_Pr>>, negation<_Is_allocator<_Container>>>,
        int> = 0>
priority_queue(_Iter, _Iter, _Pr = _Pr(), _Container = _Container())
    -> priority_queue<_Iter_value_t<_Iter>, _Container, _Pr>;

template <class _Pr, class _Container, class _Alloc,
    enable_if_t<conjunction_v<negation<_Is_allocator<_Pr>>, negation<_Is_allocator<_Container>>,
                    uses_allocator<_Container, _Alloc>>,
        int> = 0>
priority_queue(_Pr, _Container, _Alloc) -> priority_queue<typename _Container::value_type, _Container, _Pr>;

template <class _Iter, class _Alloc, class _Container = vector<_Iter_value_t<_Iter>, _Alloc>,
    enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>, uses_allocator<_Container, _Alloc>>, int> = 0>
priority_queue(_Iter, _Iter, _Alloc) -> priority_queue<_Iter_value_t<_Iter>, _Container, less<_Iter_value_t<_Iter>>>;

template <class _Iter, class _Compare, class _Alloc, class _Container = vector<_Iter_value_t<_Iter>, _Alloc>,
    enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>, uses_allocator<_Container, _Alloc>>, int> = 0>
priority_queue(_Iter, _Iter, _Compare, _Alloc) -> priority_queue<_Iter_value_t<_Iter>, _Container, _Compare>;

template <class _Iter, class _Compare, class _Container, class _Alloc,
    enable_if_t<conjunction_v<_Is_iterator<_Iter>, uses_allocator<_Container, _Alloc>>, int> = 0>
priority_queue(_Iter, _Iter, _Compare, _Container, _Alloc)
    -> priority_queue<typename _Container::value_type, _Container, _Compare>;
#line 373 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\queue"

template <class _Ty, class _Container, class _Pr,
    enable_if_t<_Is_swappable<_Container>::value && _Is_swappable<_Pr>::value, int> = 0>
void swap(priority_queue<_Ty, _Container, _Pr>& _Left, priority_queue<_Ty, _Container, _Pr>& _Right) noexcept(
    noexcept(_Left.swap(_Right))) {
    _Left.swap(_Right);
}

template <class _Ty, class _Container, class _Pr, class _Alloc>
struct uses_allocator<priority_queue<_Ty, _Container, _Pr>, _Alloc> : uses_allocator<_Container, _Alloc>::type {};

}


#pragma warning(pop)
#pragma pack(pop)
#line 391 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\queue"
#line 392 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\queue"
#line 62 "all-std.cxx"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\set"


#pragma once


#line 16 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\set"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
template <class _Kty, 
    class _Pr, 
    class _Alloc, 
    bool _Mfl> 
class _Tset_traits { 
public:
    using key_type       = _Kty;
    using value_type     = _Kty;
    using key_compare    = _Pr;
    using allocator_type = _Alloc;

    using node_type = _Node_handle<_Tree_node<value_type, typename allocator_traits<_Alloc>::void_pointer>, _Alloc,
        _Node_handle_set_base, _Kty>;
#line 38 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\set"

    static constexpr bool _Multi = _Mfl;

    template <class... _Args>
    using _In_place_key_extractor = _In_place_key_extract_set<_Kty, _Args...>;

    using value_compare = key_compare;

    static const _Kty& _Kfn(const value_type& _Val) { 
        return _Val;
    }
};

template <class _Kty, class _Pr = less<_Kty>, class _Alloc = allocator<_Kty>>
class set : public _Tree<_Tset_traits<_Kty, _Pr, _Alloc, false>> {
    
public:
    static_assert(!1 || is_same_v<_Kty, typename _Alloc::value_type>,
        "set<T, Compare, Allocator>" " requires that Allocator's value_type match " "T" " (See N4659 26.2.1 [container.requirements.general]/16 allocator_type)" " Either fix the allocator value_type or define _ENFORCE_MATCHING_ALLOCATORS=0" " to suppress this diagnostic.");

    using _Mybase                = _Tree<_Tset_traits<_Kty, _Pr, _Alloc, false>>;
    using key_type               = _Kty;
    using key_compare            = _Pr;
    using value_compare          = typename _Mybase::value_compare;
    using value_type             = typename _Mybase::value_type;
    using allocator_type         = typename _Mybase::allocator_type;
    using size_type              = typename _Mybase::size_type;
    using difference_type        = typename _Mybase::difference_type;
    using pointer                = typename _Mybase::pointer;
    using const_pointer          = typename _Mybase::const_pointer;
    using reference              = value_type&;
    using const_reference        = const value_type&;
    using iterator               = typename _Mybase::iterator;
    using const_iterator         = typename _Mybase::const_iterator;
    using reverse_iterator       = typename _Mybase::reverse_iterator;
    using const_reverse_iterator = typename _Mybase::const_reverse_iterator;

    using _Alnode        = typename _Mybase::_Alnode;
    using _Alnode_traits = typename _Mybase::_Alnode_traits;


    using insert_return_type = _Insert_return_type<iterator, typename _Mybase::node_type>;
#line 81 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\set"

    set() : _Mybase(key_compare()) {}

    explicit set(const allocator_type& _Al) : _Mybase(key_compare(), _Al) {}

    set(const set& _Right) : _Mybase(_Right, _Alnode_traits::select_on_container_copy_construction(_Right._Getal())) {}

    set(const set& _Right, const allocator_type& _Al) : _Mybase(_Right, _Al) {}

    explicit set(const key_compare& _Pred) : _Mybase(_Pred) {}

    set(const key_compare& _Pred, const allocator_type& _Al) : _Mybase(_Pred, _Al) {}

    template <class _Iter>
    set(_Iter _First, _Iter _Last) : _Mybase(key_compare()) {
        this->insert(_First, _Last);
    }

    template <class _Iter>
    set(_Iter _First, _Iter _Last, const key_compare& _Pred) : _Mybase(_Pred) {
        this->insert(_First, _Last);
    }

    template <class _Iter>
    set(_Iter _First, _Iter _Last, const allocator_type& _Al) : _Mybase(key_compare(), _Al) {
        this->insert(_First, _Last);
    }

    template <class _Iter>
    set(_Iter _First, _Iter _Last, const key_compare& _Pred, const allocator_type& _Al) : _Mybase(_Pred, _Al) {
        this->insert(_First, _Last);
    }

    set& operator=(const set& _Right) {
        _Mybase::operator=(_Right);
        return *this;
    }

    set(set&& _Right) : _Mybase(::std:: move(_Right)) {}

    set(set&& _Right, const allocator_type& _Al) : _Mybase(::std:: move(_Right), _Al) {}

    set& operator=(set&& _Right) noexcept(_Alnode_traits::is_always_equal::value&& is_nothrow_move_assignable_v<_Pr>) {
        _Mybase::operator=(::std:: move(_Right));
        return *this;
    }

    void swap(set& _Right) noexcept(noexcept(_Mybase::swap(_Right))) {
        _Mybase::swap(_Right);
    }

    set(initializer_list<value_type> _Ilist) : _Mybase(key_compare()) {
        this->insert(_Ilist);
    }

    set(initializer_list<value_type> _Ilist, const key_compare& _Pred) : _Mybase(_Pred) {
        this->insert(_Ilist);
    }

    set(initializer_list<value_type> _Ilist, const allocator_type& _Al) : _Mybase(key_compare(), _Al) {
        this->insert(_Ilist);
    }

    set(initializer_list<value_type> _Ilist, const key_compare& _Pred, const allocator_type& _Al)
        : _Mybase(_Pred, _Al) {
        this->insert(_Ilist);
    }

    set& operator=(initializer_list<value_type> _Ilist) {
        this->clear();
        this->insert(_Ilist);
        return *this;
    }

    using _Mybase::_Unchecked_begin;
    using _Mybase::_Unchecked_end;
};


template <class _Iter, class _Pr = less<_Iter_value_t<_Iter>>, class _Alloc = allocator<_Iter_value_t<_Iter>>,
    enable_if_t<conjunction_v<_Is_iterator<_Iter>, negation<_Is_allocator<_Pr>>, _Is_allocator<_Alloc>>, int> = 0>
set(_Iter, _Iter, _Pr = _Pr(), _Alloc = _Alloc()) -> set<_Iter_value_t<_Iter>, _Pr, _Alloc>;

template <class _Kty, class _Pr = less<_Kty>, class _Alloc = allocator<_Kty>,
    enable_if_t<conjunction_v<negation<_Is_allocator<_Pr>>, _Is_allocator<_Alloc>>, int> = 0>
set(initializer_list<_Kty>, _Pr = _Pr(), _Alloc = _Alloc()) -> set<_Kty, _Pr, _Alloc>;

template <class _Iter, class _Alloc, enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
set(_Iter, _Iter, _Alloc) -> set<_Iter_value_t<_Iter>, less<_Iter_value_t<_Iter>>, _Alloc>;

template <class _Kty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
set(initializer_list<_Kty>, _Alloc) -> set<_Kty, less<_Kty>, _Alloc>;
#line 174 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\set"

template <class _Kty, class _Pr, class _Alloc>
[[nodiscard]] bool operator==(const set<_Kty, _Pr, _Alloc>& _Left, const set<_Kty, _Pr, _Alloc>& _Right) {
    return _Left.size() == _Right.size()
        && ::std:: equal(_Left._Unchecked_begin(), _Left._Unchecked_end_iter(), _Right._Unchecked_begin());
}


#line 187 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\set"


template <class _Kty, class _Pr, class _Alloc>
[[nodiscard]] _Synth_three_way_result<_Kty> operator<=>(
    const set<_Kty, _Pr, _Alloc>& _Left, const set<_Kty, _Pr, _Alloc>& _Right) {
    return ::std:: lexicographical_compare_three_way(_Left._Unchecked_begin(), _Left._Unchecked_end_iter(),
        _Right._Unchecked_begin(), _Right._Unchecked_end_iter(), _Synth_three_way{});
}


#line 217 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\set"

template <class _Kty, class _Pr, class _Alloc>
void swap(set<_Kty, _Pr, _Alloc>& _Left, set<_Kty, _Pr, _Alloc>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
    _Left.swap(_Right);
}


template <class _Kty, class _Keylt, class _Alloc, class _Pr>
typename set<_Kty, _Keylt, _Alloc>::size_type erase_if(set<_Kty, _Keylt, _Alloc>& _Cont, _Pr _Pred) {
    return _Erase_nodes_if(_Cont, _Pass_fn(_Pred));
}
#line 229 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\set"

template <class _Kty, class _Pr = less<_Kty>, class _Alloc = allocator<_Kty>>
class multiset : public _Tree<_Tset_traits<_Kty, _Pr, _Alloc, true>> {
    
public:
    static_assert(!1 || is_same_v<_Kty, typename _Alloc::value_type>,
        "multiset<T, Compare, Allocator>" " requires that Allocator's value_type match " "T" " (See N4659 26.2.1 [container.requirements.general]/16 allocator_type)" " Either fix the allocator value_type or define _ENFORCE_MATCHING_ALLOCATORS=0" " to suppress this diagnostic.");

    using _Mybase                = _Tree<_Tset_traits<_Kty, _Pr, _Alloc, true>>;
    using key_type               = _Kty;
    using key_compare            = _Pr;
    using value_compare          = typename _Mybase::value_compare;
    using value_type             = typename _Mybase::value_type;
    using allocator_type         = typename _Mybase::allocator_type;
    using size_type              = typename _Mybase::size_type;
    using difference_type        = typename _Mybase::difference_type;
    using pointer                = typename _Mybase::pointer;
    using const_pointer          = typename _Mybase::const_pointer;
    using reference              = value_type&;
    using const_reference        = const value_type&;
    using iterator               = typename _Mybase::iterator;
    using const_iterator         = typename _Mybase::const_iterator;
    using reverse_iterator       = typename _Mybase::reverse_iterator;
    using const_reverse_iterator = typename _Mybase::const_reverse_iterator;

    using _Alnode        = typename _Mybase::_Alnode;
    using _Alnode_traits = typename _Mybase::_Alnode_traits;

    multiset() : _Mybase(key_compare()) {}

    explicit multiset(const allocator_type& _Al) : _Mybase(key_compare(), _Al) {}

    multiset(const multiset& _Right)
        : _Mybase(_Right, _Alnode_traits::select_on_container_copy_construction(_Right._Getal())) {}

    multiset(const multiset& _Right, const allocator_type& _Al) : _Mybase(_Right, _Al) {}

    explicit multiset(const key_compare& _Pred) : _Mybase(_Pred) {}

    multiset(const key_compare& _Pred, const allocator_type& _Al) : _Mybase(_Pred, _Al) {}

    template <class _Iter>
    multiset(_Iter _First, _Iter _Last) : _Mybase(key_compare()) {
        this->insert(_First, _Last);
    }

    template <class _Iter>
    multiset(_Iter _First, _Iter _Last, const key_compare& _Pred) : _Mybase(_Pred) {
        this->insert(_First, _Last);
    }

    template <class _Iter>
    multiset(_Iter _First, _Iter _Last, const allocator_type& _Al) : _Mybase(key_compare(), _Al) {
        this->insert(_First, _Last);
    }

    template <class _Iter>
    multiset(_Iter _First, _Iter _Last, const key_compare& _Pred, const allocator_type& _Al) : _Mybase(_Pred, _Al) {
        this->insert(_First, _Last);
    }

    multiset& operator=(const multiset& _Right) {
        _Mybase::operator=(_Right);
        return *this;
    }

    multiset(multiset&& _Right) : _Mybase(::std:: move(_Right)) {}

    multiset(multiset&& _Right, const allocator_type& _Al) : _Mybase(::std:: move(_Right), _Al) {}

    multiset& operator=(multiset&& _Right) noexcept(
        _Alnode_traits::is_always_equal::value&& is_nothrow_move_assignable_v<_Pr>) {
        _Mybase::operator=(::std:: move(_Right));
        return *this;
    }

    template <class... _Valty>
    iterator emplace(_Valty&&... _Val) {
        return _Mybase::emplace(::std:: forward<_Valty>(_Val)...).first;
    }

    void swap(multiset& _Right) noexcept(noexcept(_Mybase::swap(_Right))) {
        _Mybase::swap(_Right);
    }

    multiset(initializer_list<value_type> _Ilist) : _Mybase(key_compare()) {
        this->insert(_Ilist);
    }

    multiset(initializer_list<value_type> _Ilist, const key_compare& _Pred) : _Mybase(_Pred) {
        this->insert(_Ilist);
    }

    multiset(initializer_list<value_type> _Ilist, const allocator_type& _Al) : _Mybase(key_compare(), _Al) {
        this->insert(_Ilist);
    }

    multiset(initializer_list<value_type> _Ilist, const key_compare& _Pred, const allocator_type& _Al)
        : _Mybase(_Pred, _Al) {
        this->insert(_Ilist);
    }

    multiset& operator=(initializer_list<value_type> _Ilist) {
        this->clear();
        this->insert(_Ilist);
        return *this;
    }

    using _Mybase::_Unchecked_begin;
    using _Mybase::_Unchecked_end;
};


template <class _Iter, class _Pr = less<_Iter_value_t<_Iter>>, class _Alloc = allocator<_Iter_value_t<_Iter>>,
    enable_if_t<conjunction_v<_Is_iterator<_Iter>, negation<_Is_allocator<_Pr>>, _Is_allocator<_Alloc>>, int> = 0>
multiset(_Iter, _Iter, _Pr = _Pr(), _Alloc = _Alloc()) -> multiset<_Iter_value_t<_Iter>, _Pr, _Alloc>;

template <class _Kty, class _Pr = less<_Kty>, class _Alloc = allocator<_Kty>,
    enable_if_t<conjunction_v<negation<_Is_allocator<_Pr>>, _Is_allocator<_Alloc>>, int> = 0>
multiset(initializer_list<_Kty>, _Pr = _Pr(), _Alloc = _Alloc()) -> multiset<_Kty, _Pr, _Alloc>;

template <class _Iter, class _Alloc, enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
multiset(_Iter, _Iter, _Alloc) -> multiset<_Iter_value_t<_Iter>, less<_Iter_value_t<_Iter>>, _Alloc>;

template <class _Kty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
multiset(initializer_list<_Kty>, _Alloc) -> multiset<_Kty, less<_Kty>, _Alloc>;
#line 356 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\set"

template <class _Kty, class _Pr, class _Alloc>
[[nodiscard]] bool operator==(const multiset<_Kty, _Pr, _Alloc>& _Left, const multiset<_Kty, _Pr, _Alloc>& _Right) {
    return _Left.size() == _Right.size()
        && ::std:: equal(_Left._Unchecked_begin(), _Left._Unchecked_end_iter(), _Right._Unchecked_begin());
}


#line 369 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\set"


template <class _Kty, class _Pr, class _Alloc>
[[nodiscard]] _Synth_three_way_result<_Kty> operator<=>(
    const multiset<_Kty, _Pr, _Alloc>& _Left, const multiset<_Kty, _Pr, _Alloc>& _Right) {
    return ::std:: lexicographical_compare_three_way(_Left._Unchecked_begin(), _Left._Unchecked_end_iter(),
        _Right._Unchecked_begin(), _Right._Unchecked_end_iter(), _Synth_three_way{});
}


#line 399 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\set"

template <class _Kty, class _Pr, class _Alloc>
void swap(multiset<_Kty, _Pr, _Alloc>& _Left, multiset<_Kty, _Pr, _Alloc>& _Right) noexcept(
    noexcept(_Left.swap(_Right))) {
    _Left.swap(_Right);
}


template <class _Kty, class _Keylt, class _Alloc, class _Pr>
typename multiset<_Kty, _Keylt, _Alloc>::size_type erase_if(multiset<_Kty, _Keylt, _Alloc>& _Cont, _Pr _Pred) {
    return _Erase_nodes_if(_Cont, _Pass_fn(_Pred));
}
#line 412 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\set"


namespace pmr {
    template <class _Kty, class _Pr = less<_Kty>>
    using set = ::std:: set<_Kty, _Pr, polymorphic_allocator<_Kty>>;

    template <class _Kty, class _Pr = less<_Kty>>
    using multiset = ::std:: multiset<_Kty, _Pr, polymorphic_allocator<_Kty>>;
} 
#line 422 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\set"
}


#pragma warning(pop)
#pragma pack(pop)
#line 428 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\set"
#line 429 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\set"
#line 63 "all-std.cxx"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"


#pragma once


#line 15 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {

inline constexpr size_t dynamic_extent = static_cast<size_t>(-1);

template <class _Ty>
struct _Span_iterator {

    using iterator_concept  = contiguous_iterator_tag;
#line 37 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
    using iterator_category = random_access_iterator_tag;
    using value_type        = remove_cv_t<_Ty>;
    using difference_type   = ptrdiff_t;
    using pointer           = _Ty*;
    using reference         = _Ty&;

    [[nodiscard]] constexpr reference operator*() const noexcept {


#line 48 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
        return *_Myptr;
    }

    [[nodiscard]] constexpr pointer operator->() const noexcept {


#line 56 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
        return _Myptr;
    }

    constexpr _Span_iterator& operator++() noexcept {


#line 64 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
        ++_Myptr;
        return *this;
    }

    constexpr _Span_iterator operator++(int) noexcept {
        _Span_iterator _Tmp{*this};
        ++*this;
        return _Tmp;
    }

    constexpr _Span_iterator& operator--() noexcept {


#line 79 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
        --_Myptr;
        return *this;
    }

    constexpr _Span_iterator operator--(int) noexcept {
        _Span_iterator _Tmp{*this};
        --*this;
        return _Tmp;
    }

    constexpr void _Verify_offset([[maybe_unused]] const difference_type _Off) const noexcept {


#line 103 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
    }

    constexpr _Span_iterator& operator+=(const difference_type _Off) noexcept {
        _Verify_offset(_Off);
        _Myptr += _Off;
        return *this;
    }

    [[nodiscard]] constexpr _Span_iterator operator+(const difference_type _Off) const noexcept {
        _Span_iterator _Tmp{*this};
        _Tmp += _Off;
        return _Tmp;
    }

    [[nodiscard]] friend constexpr _Span_iterator operator+(const difference_type _Off, _Span_iterator _Next) noexcept {
        _Next += _Off;
        return _Next;
    }

    constexpr _Span_iterator& operator-=(const difference_type _Off) noexcept {
        _Verify_offset(-_Off);
        _Myptr -= _Off;
        return *this;
    }

    [[nodiscard]] constexpr _Span_iterator operator-(const difference_type _Off) const noexcept {
        _Span_iterator _Tmp{*this};
        _Tmp -= _Off;
        return _Tmp;
    }

    [[nodiscard]] constexpr difference_type operator-(const _Span_iterator& _Right) const noexcept {


#line 139 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
        return _Myptr - _Right._Myptr;
    }

    [[nodiscard]] constexpr reference operator[](const difference_type _Off) const noexcept {
        return *(*this + _Off);
    }

    [[nodiscard]] constexpr bool operator==(const _Span_iterator& _Right) const noexcept {


#line 151 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
        return _Myptr == _Right._Myptr;
    }

    [[nodiscard]] constexpr strong_ordering operator<=>(const _Span_iterator& _Right) const noexcept {


#line 159 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
        return _Myptr <=> _Right._Myptr;
    }


#line 169 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"

    using _Prevent_inheriting_unwrap = _Span_iterator;

    [[nodiscard]] constexpr pointer _Unwrapped() const noexcept {
        return _Myptr;
    }

    static constexpr bool _Unwrap_when_unverified = 0 == 0;

    constexpr void _Seek_to(const pointer _It) noexcept {
        _Myptr = _It;
    }

    pointer _Myptr   = nullptr;


#line 187 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
};

template <class _Ty>
struct pointer_traits<_Span_iterator<_Ty>> {
    using pointer         = _Span_iterator<_Ty>;
    using element_type    = _Ty;
    using difference_type = ptrdiff_t;

    [[nodiscard]] static constexpr element_type* to_address(const pointer _Iter) noexcept {
        return _Iter._Unwrapped();
    }
};

template <class _Ty, size_t _Extent>
struct _Span_extent_type {
    using pointer = _Ty*;

    constexpr _Span_extent_type() noexcept = default;

    constexpr explicit _Span_extent_type(const pointer _Data, size_t) noexcept : _Mydata{_Data} {}

    pointer _Mydata{nullptr};
    static constexpr size_t _Mysize = _Extent;
};

template <class _Ty>
struct _Span_extent_type<_Ty, dynamic_extent> {
    using pointer = _Ty*;

    constexpr _Span_extent_type() noexcept = default;

    constexpr explicit _Span_extent_type(const pointer _Data, const size_t _Size) noexcept
        : _Mydata{_Data}, _Mysize{_Size} {}

    pointer _Mydata{nullptr};
    size_t _Mysize{0};
};

template <class _Ty, size_t _Size>
class array;

template <class _Ty, size_t _Extent>
class span;


namespace ranges {
    template <class _Ty, size_t _Extent>
    inline constexpr bool enable_view<span<_Ty, _Extent>> = true;
    template <class _Ty, size_t _Extent>
    inline constexpr bool enable_borrowed_range<span<_Ty, _Extent>> = true;
} 

template <class>
inline constexpr bool _Is_span_v = false;

template <class _Ty, size_t _Extent>
inline constexpr bool _Is_span_v<span<_Ty, _Extent>> = true;

template <class>
inline constexpr bool _Is_std_array_v = false;

template <class _Ty, size_t _Size>
inline constexpr bool _Is_std_array_v<array<_Ty, _Size>> = true;


template <class _It, class _Ty>
concept _Span_compatible_iterator = contiguous_iterator<_It>
                                 && is_convertible_v<remove_reference_t<iter_reference_t<_It>>(*)[], _Ty(*)[]>;

template <class _Sentinel, class _It>
concept _Span_compatible_sentinel = sized_sentinel_for<_Sentinel, _It>
                                 && !is_convertible_v<_Sentinel, size_t>;

template <class _Rng, class _Ty>
concept _Span_compatible_range =
    !is_array_v<remove_cvref_t<_Rng>>
 && !_Is_span_v<remove_cvref_t<_Rng>>
 && !_Is_std_array_v<remove_cvref_t<_Rng>>
 && ::std::ranges:: contiguous_range<_Rng>
 && ::std::ranges:: sized_range<_Rng>
 && (::std::ranges:: borrowed_range<_Rng> || is_const_v<_Ty>)
 && is_convertible_v<remove_reference_t<::std::ranges:: range_reference_t<_Rng>>(*)[], _Ty(*)[]>;


#line 304 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"


template <class _Ty, size_t _Extent = dynamic_extent>
class span : private _Span_extent_type<_Ty, _Extent> {
private:
    using _Mybase = _Span_extent_type<_Ty, _Extent>;
    using _Mybase::_Mydata;
    using _Mybase::_Mysize;

public:
    using element_type     = _Ty;
    using value_type       = remove_cv_t<_Ty>;
    using size_type        = size_t;
    using difference_type  = ptrdiff_t;
    using pointer          = _Ty*;
    using const_pointer    = const _Ty*;
    using reference        = _Ty&;
    using const_reference  = const _Ty&;
    using iterator         = _Span_iterator<_Ty>;
    using reverse_iterator = ::std:: reverse_iterator<iterator>;

    static constexpr size_type extent = _Extent;

    
    constexpr span() noexcept requires (_Extent == 0 || _Extent == dynamic_extent) = default;

    template <_Span_compatible_iterator<element_type> _It>
    constexpr explicit(_Extent != dynamic_extent) span(_It _First, size_type _Count) noexcept 
        : _Mybase(::std:: to_address(_Get_unwrapped_n(_First, _Count)), _Count) {


#line 342 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
    }

    template <_Span_compatible_iterator<element_type> _It, _Span_compatible_sentinel<_It> _Sentinel>
    constexpr explicit(_Extent != dynamic_extent) span(_It _First, _Sentinel _Last)
        noexcept(noexcept(_Last - _First)) 
        : _Mybase(::std:: to_address(_First), static_cast<size_type>(_Last - _First)) {
        _Adl_verify_range(_First, _Last);


#line 355 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
    }

    template <size_t _Size>
        requires (_Extent == dynamic_extent || _Extent == _Size)
    constexpr span(type_identity_t<element_type> (&_Arr)[_Size]) noexcept : _Mybase(_Arr, _Size) {}

    template <class _OtherTy, size_t _Size>
        requires (_Extent == dynamic_extent || _Extent == _Size)
              && is_convertible_v<_OtherTy (*)[], element_type (*)[]>
    constexpr span(array<_OtherTy, _Size>& _Arr) noexcept : _Mybase(_Arr.data(), _Size) {}

    template <class _OtherTy, size_t _Size>
        requires (_Extent == dynamic_extent || _Extent == _Size)
              && is_convertible_v<const _OtherTy (*)[], element_type (*)[]>
    constexpr span(const array<_OtherTy, _Size>& _Arr) noexcept : _Mybase(_Arr.data(), _Size) {}

    template <_Span_compatible_range<element_type> _Rng>
    constexpr explicit(_Extent != dynamic_extent) span(_Rng&& _Range)
        : _Mybase(::std::ranges:: data(_Range), static_cast<size_type>(::std::ranges:: size(_Range))) {


#line 380 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
        }

    template <class _OtherTy, size_t _OtherExtent>
        requires (_Extent == dynamic_extent || _OtherExtent == dynamic_extent || _Extent == _OtherExtent)
              && is_convertible_v<_OtherTy (*)[], element_type (*)[]>
    constexpr explicit(_Extent != dynamic_extent && _OtherExtent == dynamic_extent)
    span(const span<_OtherTy, _OtherExtent>& _Other) noexcept
        : _Mybase(_Other.data(), _Other.size()) {


#line 394 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
        }
    

#line 477 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"

    
    template <size_t _Count>
    [[nodiscard]] constexpr auto first() const noexcept  {
        if constexpr (_Extent != dynamic_extent) {
            static_assert(_Count <= _Extent, "Count out of range in span::first()");
        }


#line 489 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
        return span<element_type, _Count>{_Mydata, _Count};
    }

    [[nodiscard]] constexpr auto first(const size_type _Count) const noexcept
     {


#line 497 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
        return span<element_type, dynamic_extent>{_Mydata, _Count};
    }

    template <size_t _Count>
    [[nodiscard]] constexpr auto last() const noexcept  {
        if constexpr (_Extent != dynamic_extent) {
            static_assert(_Count <= _Extent, "Count out of range in span::last()");
        }


#line 510 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
        return span<element_type, _Count>{_Mydata + (_Mysize - _Count), _Count};
    }

    [[nodiscard]] constexpr auto last(const size_type _Count) const noexcept  {


#line 517 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
        return span<element_type, dynamic_extent>{_Mydata + (_Mysize - _Count), _Count};
    }

    template <size_t _Offset, size_t _Count = dynamic_extent>
    [[nodiscard]] constexpr auto subspan() const noexcept  {
        if constexpr (_Extent != dynamic_extent) {
            static_assert(_Offset <= _Extent, "Offset out of range in span::subspan()");
            static_assert(
                _Count == dynamic_extent || _Count <= _Extent - _Offset, "Count out of range in span::subspan()");
        }


#line 536 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
        using _ReturnType = span<element_type,
            _Count != dynamic_extent ? _Count : (_Extent != dynamic_extent ? _Extent - _Offset : dynamic_extent)>;
        return _ReturnType{_Mydata + _Offset, _Count == dynamic_extent ? _Mysize - _Offset : _Count};
    }

    [[nodiscard]] constexpr auto subspan(const size_type _Offset, const size_type _Count = dynamic_extent) const noexcept
     {


#line 548 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
        using _ReturnType = span<element_type, dynamic_extent>;
        return _ReturnType{_Mydata + _Offset, _Count == dynamic_extent ? _Mysize - _Offset : _Count};
    }

    
    [[nodiscard]] constexpr size_t size() const noexcept {
        return _Mysize;
    }

    [[nodiscard]] constexpr size_type size_bytes() const noexcept {


#line 563 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
        return _Mysize * sizeof(element_type);
    }

    [[nodiscard]] constexpr bool empty() const noexcept {
        return _Mysize == 0;
    }

    
    [[nodiscard]] constexpr reference operator[](const size_type _Off) const noexcept  {


#line 575 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
        return _Mydata[_Off];
    }

    [[nodiscard]] constexpr reference front() const noexcept  {


#line 583 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
        return _Mydata[0];
    }

    [[nodiscard]] constexpr reference back() const noexcept  {


#line 591 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
        return _Mydata[_Mysize - 1];
    }

    [[nodiscard]] constexpr pointer data() const noexcept {
        return _Mydata;
    }

    
    [[nodiscard]] constexpr iterator begin() const noexcept {


#line 603 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
        return {_Mydata};
#line 605 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
    }

    [[nodiscard]] constexpr iterator end() const noexcept {
        const auto _End = _Mydata + _Mysize;


#line 612 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
        return {_End};
#line 614 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
    }

    [[nodiscard]] constexpr reverse_iterator rbegin() const noexcept {
        return reverse_iterator{end()};
    }

    [[nodiscard]] constexpr reverse_iterator rend() const noexcept {
        return reverse_iterator{begin()};
    }

    [[nodiscard]] constexpr pointer _Unchecked_begin() const noexcept {
        return _Mydata;
    }

    [[nodiscard]] constexpr pointer _Unchecked_end() const noexcept {
        return _Mydata + _Mysize;
    }
};

template <class _Ty, size_t _Extent>
span(_Ty (&)[_Extent]) -> span<_Ty, _Extent>;

template <class _Ty, size_t _Size>
span(array<_Ty, _Size>&) -> span<_Ty, _Size>;

template <class _Ty, size_t _Size>
span(const array<_Ty, _Size>&) -> span<const _Ty, _Size>;


template <contiguous_iterator _It, class _End>
span(_It, _End) -> span<remove_reference_t<iter_reference_t<_It>>>;

template <::std::ranges:: contiguous_range _Rng>
span(_Rng&&) -> span<remove_reference_t<::std::ranges:: range_reference_t<_Rng>>>;


#line 659 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"


template <class _Ty, size_t _Extent>
[[nodiscard]] auto as_bytes(span<_Ty, _Extent> _Sp) noexcept {
    using _ReturnType = span<const byte, _Extent == dynamic_extent ? dynamic_extent : sizeof(_Ty) * _Extent>;
    return _ReturnType{reinterpret_cast<const byte*>(_Sp.data()), _Sp.size_bytes()};
}

template <class _Ty, size_t _Extent, enable_if_t<!is_const_v<_Ty>, int> = 0>
[[nodiscard]] auto as_writable_bytes(span<_Ty, _Extent> _Sp) noexcept {
    using _ReturnType = span<byte, _Extent == dynamic_extent ? dynamic_extent : sizeof(_Ty) * _Extent>;
    return _ReturnType{reinterpret_cast<byte*>(_Sp.data()), _Sp.size_bytes()};
}
#line 674 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"

}


#pragma warning(pop)
#pragma pack(pop)
#line 682 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
#line 683 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
#line 684 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\span"
#line 64 "all-std.cxx"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stack"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
template <class _Ty, class _Container = deque<_Ty>>
class stack {
public:
    using value_type      = typename _Container::value_type;
    using reference       = typename _Container::reference;
    using const_reference = typename _Container::const_reference;
    using size_type       = typename _Container::size_type;
    using container_type  = _Container;

    static_assert(is_same_v<_Ty, value_type>, "container adaptors require consistent types");

    stack() = default;

    explicit stack(const _Container& _Cont) : c(_Cont) {}

    explicit stack(_Container&& _Cont) noexcept(is_nothrow_move_constructible_v<_Container>) 
        : c(::std:: move(_Cont)) {}


    template <class _InIt, enable_if_t<_Is_iterator_v<_InIt>, int> = 0>
    stack(_InIt _First, _InIt _Last) noexcept(is_nothrow_constructible_v<_Container, _InIt, _InIt>) 
        : c(::std:: move(_First), ::std:: move(_Last)) {}
#line 44 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stack"

    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
    explicit stack(const _Alloc& _Al) noexcept(is_nothrow_constructible_v<_Container, const _Alloc&>) 
        : c(_Al) {}

    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
    stack(const _Container& _Cont, const _Alloc& _Al) : c(_Cont, _Al) {}

    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
    stack(_Container&& _Cont, const _Alloc& _Al) noexcept(
        is_nothrow_constructible_v<_Container, _Container, const _Alloc&>) 
        : c(::std:: move(_Cont), _Al) {}

    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
    stack(const stack& _Right, const _Alloc& _Al) : c(_Right.c, _Al) {}

    template <class _Alloc, enable_if_t<uses_allocator_v<_Container, _Alloc>, int> = 0>
    stack(stack&& _Right, const _Alloc& _Al) noexcept(
        is_nothrow_constructible_v<_Container, _Container, const _Alloc&>) 
        : c(::std:: move(_Right.c), _Al) {}


    template <class _InIt, class _Alloc,
        enable_if_t<conjunction_v<_Is_iterator<_InIt>, uses_allocator<_Container, _Alloc>>, int> = 0>
    stack(_InIt _First, _InIt _Last, const _Alloc& _Al) noexcept(
        is_nothrow_constructible_v<_Container, _InIt, _InIt, const _Alloc&>) 
        : c(::std:: move(_First), ::std:: move(_Last), _Al) {}
#line 72 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stack"

    [[nodiscard]] bool empty() const noexcept(noexcept(c.empty()))  {
        return c.empty();
    }

    [[nodiscard]] size_type size() const noexcept(noexcept(c.size()))  {
        return c.size();
    }

    [[nodiscard]] reference top() noexcept(noexcept(c.back()))  {
        return c.back();
    }

    [[nodiscard]] const_reference top() const noexcept(noexcept(c.back()))  {
        return c.back();
    }

    void push(const value_type& _Val) {
        c.push_back(_Val);
    }

    void push(value_type&& _Val) {
        c.push_back(::std:: move(_Val));
    }

    template <class... _Valty>
    decltype(auto) emplace(_Valty&&... _Val) {

        return c.emplace_back(::std:: forward<_Valty>(_Val)...);


#line 104 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stack"
    }

    void pop() noexcept(noexcept(c.pop_back()))  {
        c.pop_back();
    }

    void swap(stack& _Right) noexcept(_Is_nothrow_swappable<_Container>::value) {
        _Swap_adl(c, _Right.c);
    }

    [[nodiscard]] const _Container& _Get_container() const noexcept {
        return c;
    }

protected:
    _Container c{};
};


template <class _Container, enable_if_t<!_Is_allocator<_Container>::value, int> = 0>
stack(_Container) -> stack<typename _Container::value_type, _Container>;

template <class _Container, class _Alloc,
    enable_if_t<conjunction_v<negation<_Is_allocator<_Container>>, uses_allocator<_Container, _Alloc>>, int> = 0>
stack(_Container, _Alloc) -> stack<typename _Container::value_type, _Container>;
#line 130 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stack"


template <class _InIt, class _Alloc = allocator<_Iter_value_t<_InIt>>,
    enable_if_t<conjunction_v<_Is_iterator<_InIt>, _Is_allocator<_Alloc>>, int> = 0>
stack(_InIt, _InIt, _Alloc = _Alloc()) -> stack<_Iter_value_t<_InIt>, deque<_Iter_value_t<_InIt>, _Alloc>>;
#line 136 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stack"

template <class _Ty, class _Container>
[[nodiscard]] bool operator==(const stack<_Ty, _Container>& _Left, const stack<_Ty, _Container>& _Right) {
    return _Left._Get_container() == _Right._Get_container();
}

template <class _Ty, class _Container>
[[nodiscard]] bool operator!=(const stack<_Ty, _Container>& _Left, const stack<_Ty, _Container>& _Right) {
    return _Left._Get_container() != _Right._Get_container();
}

template <class _Ty, class _Container>
[[nodiscard]] bool operator<(const stack<_Ty, _Container>& _Left, const stack<_Ty, _Container>& _Right) {
    return _Left._Get_container() < _Right._Get_container();
}

template <class _Ty, class _Container>
[[nodiscard]] bool operator>(const stack<_Ty, _Container>& _Left, const stack<_Ty, _Container>& _Right) {
    return _Left._Get_container() > _Right._Get_container();
}

template <class _Ty, class _Container>
[[nodiscard]] bool operator<=(const stack<_Ty, _Container>& _Left, const stack<_Ty, _Container>& _Right) {
    return _Left._Get_container() <= _Right._Get_container();
}

template <class _Ty, class _Container>
[[nodiscard]] bool operator>=(const stack<_Ty, _Container>& _Left, const stack<_Ty, _Container>& _Right) {
    return _Left._Get_container() >= _Right._Get_container();
}


template <class _Ty, three_way_comparable _Container>
[[nodiscard]] compare_three_way_result_t<_Container> operator<=>(
    const stack<_Ty, _Container>& _Left, const stack<_Ty, _Container>& _Right) {
    return _Left._Get_container() <=> _Right._Get_container();
}
#line 174 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stack"

template <class _Ty, class _Container, enable_if_t<_Is_swappable<_Container>::value, int> = 0>
void swap(stack<_Ty, _Container>& _Left, stack<_Ty, _Container>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
    _Left.swap(_Right);
}

template <class _Ty, class _Container, class _Alloc>
struct uses_allocator<stack<_Ty, _Container>, _Alloc> : uses_allocator<_Container, _Alloc>::type {};
}


#pragma warning(pop)
#pragma pack(pop)
#line 189 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stack"
#line 190 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stack"
#line 65 "all-std.cxx"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\unordered_set"


#pragma once


#line 16 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\unordered_set"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
template <class _Kty, 
    class _Tr, 
    class _Alloc, 
    bool _Mfl> 
class _Uset_traits : public _Tr { 
public:
    using key_type            = _Kty;
    using value_type          = _Kty;
    using _Mutable_value_type = _Kty;
    using key_compare         = _Tr;
    using allocator_type      = _Alloc;

    using node_type = _Node_handle<_List_node<value_type, typename allocator_traits<_Alloc>::void_pointer>, _Alloc,
        _Node_handle_set_base, _Kty>;
#line 40 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\unordered_set"

    static constexpr bool _Multi    = _Mfl;
    static constexpr bool _Standard = true;

    template <class... _Args>
    using _In_place_key_extractor = _In_place_key_extract_set<_Kty, _Args...>;

    _Uset_traits() = default;

    explicit _Uset_traits(const _Tr& _Traits) noexcept(is_nothrow_copy_constructible_v<_Tr>) : _Tr(_Traits) {}

    using value_compare = void; 

    static const _Kty& _Kfn(const value_type& _Val) noexcept {
        return _Val;
    }

    static int _Nonkfn(const value_type&) noexcept { 
        return 0;
    }
};

template <class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>
class unordered_set : public _Hash<_Uset_traits<_Kty, _Uhash_compare<_Kty, _Hasher, _Keyeq>, _Alloc, false>> {
    
public:
    static_assert(!1 || is_same_v<_Kty, typename _Alloc::value_type>,
        "unordered_set<T, Hasher, Eq, Allocator>" " requires that Allocator's value_type match " "T" " (See N4659 26.2.1 [container.requirements.general]/16 allocator_type)" " Either fix the allocator value_type or define _ENFORCE_MATCHING_ALLOCATORS=0" " to suppress this diagnostic.");

private:
    using _Mytraits      = _Uhash_compare<_Kty, _Hasher, _Keyeq>;
    using _Mybase        = _Hash<_Uset_traits<_Kty, _Mytraits, _Alloc, false>>;
    using _Alnode        = typename _Mybase::_Alnode;
    using _Alnode_traits = typename _Mybase::_Alnode_traits;
    using _Key_compare   = typename _Mybase::_Key_compare;

public:
    using hasher    = _Hasher;
    using key_type  = _Kty;
    using key_equal = _Keyeq;

    using value_type      = typename _Mybase::value_type;
    using allocator_type  = typename _Mybase::allocator_type;
    using size_type       = typename _Mybase::size_type;
    using difference_type = typename _Mybase::difference_type;
    using pointer         = typename _Mybase::pointer;
    using const_pointer   = typename _Mybase::const_pointer;
    using reference       = value_type&;
    using const_reference = const value_type&;
    using iterator        = typename _Mybase::iterator;
    using const_iterator  = typename _Mybase::const_iterator;

    using local_iterator       = typename _Mybase::iterator;
    using const_local_iterator = typename _Mybase::const_iterator;


    using insert_return_type = _Insert_return_type<iterator, typename _Mybase::node_type>;
#line 98 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\unordered_set"

    unordered_set() : _Mybase(_Key_compare(), allocator_type()) {}

    explicit unordered_set(const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {}

    unordered_set(const unordered_set& _Right)
        : _Mybase(_Right, _Alnode_traits::select_on_container_copy_construction(_Right._Getal())) {}

    unordered_set(const unordered_set& _Right, const allocator_type& _Al) : _Mybase(_Right, _Al) {}

    explicit unordered_set(size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
        this->rehash(_Buckets);
    }

    unordered_set(size_type _Buckets, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
        this->rehash(_Buckets);
    }

    unordered_set(size_type _Buckets, const hasher& _Hasharg) : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
        this->rehash(_Buckets);
    }

    unordered_set(size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
        : _Mybase(_Key_compare(_Hasharg), _Al) {
        this->rehash(_Buckets);
    }

    unordered_set(size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
        this->rehash(_Buckets);
    }

    unordered_set(size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg, const allocator_type& _Al)
        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
        this->rehash(_Buckets);
    }

    template <class _Iter>
    unordered_set(_Iter _First, _Iter _Last) : _Mybase(_Key_compare(), allocator_type()) {
        this->insert(_First, _Last);
    }

    template <class _Iter>
    unordered_set(_Iter _First, _Iter _Last, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
        this->insert(_First, _Last);
    }

    template <class _Iter>
    unordered_set(_Iter _First, _Iter _Last, size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
        this->rehash(_Buckets);
        this->insert(_First, _Last);
    }

    template <class _Iter>
    unordered_set(_Iter _First, _Iter _Last, size_type _Buckets, const allocator_type& _Al)
        : _Mybase(_Key_compare(), _Al) {
        this->rehash(_Buckets);
        this->insert(_First, _Last);
    }

    template <class _Iter>
    unordered_set(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg)
        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
        this->rehash(_Buckets);
        this->insert(_First, _Last);
    }

    template <class _Iter>
    unordered_set(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
        : _Mybase(_Key_compare(_Hasharg), _Al) {
        this->rehash(_Buckets);
        this->insert(_First, _Last);
    }

    template <class _Iter>
    unordered_set(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
        this->rehash(_Buckets);
        this->insert(_First, _Last);
    }

    template <class _Iter>
    unordered_set(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg,
        const allocator_type& _Al)
        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
        this->rehash(_Buckets);
        this->insert(_First, _Last);
    }

    unordered_set& operator=(const unordered_set& _Right) {
        _Mybase::operator=(_Right);
        return *this;
    }

    unordered_set(unordered_set&& _Right) : _Mybase(::std:: move(_Right)) {}

    unordered_set(unordered_set&& _Right, const allocator_type& _Al) : _Mybase(::std:: move(_Right), _Al) {}

    unordered_set& operator=(unordered_set&& _Right) noexcept(_Alnode_traits::is_always_equal::value&&
            is_nothrow_move_assignable_v<_Hasher>&& is_nothrow_move_assignable_v<_Keyeq>) {
        _Mybase::operator=(::std:: move(_Right));
        return *this;
    }

    void swap(unordered_set& _Right) noexcept(noexcept(_Mybase::swap(_Right))) {
        _Mybase::swap(_Right);
    }

    unordered_set(initializer_list<value_type> _Ilist) : _Mybase(_Key_compare(), allocator_type()) {
        this->insert(_Ilist);
    }

    unordered_set(initializer_list<value_type> _Ilist, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
        this->insert(_Ilist);
    }

    unordered_set(initializer_list<value_type> _Ilist, size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
        this->rehash(_Buckets);
        this->insert(_Ilist);
    }

    unordered_set(initializer_list<value_type> _Ilist, size_type _Buckets, const allocator_type& _Al)
        : _Mybase(_Key_compare(), _Al) {
        this->rehash(_Buckets);
        this->insert(_Ilist);
    }

    unordered_set(initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg)
        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
        this->rehash(_Buckets);
        this->insert(_Ilist);
    }

    unordered_set(
        initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
        : _Mybase(_Key_compare(_Hasharg), _Al) {
        this->rehash(_Buckets);
        this->insert(_Ilist);
    }

    unordered_set(
        initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
        this->rehash(_Buckets);
        this->insert(_Ilist);
    }

    unordered_set(initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg,
        const _Keyeq& _Keyeqarg, const allocator_type& _Al)
        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
        this->rehash(_Buckets);
        this->insert(_Ilist);
    }

    unordered_set& operator=(initializer_list<value_type> _Ilist) {
        this->clear();
        this->insert(_Ilist);
        return *this;
    }

    [[nodiscard]] hasher hash_function() const {
        return this->_Traitsobj._Mypair._Get_first();
    }

    [[nodiscard]] key_equal key_eq() const {
        return this->_Traitsobj._Mypair._Myval2._Get_first();
    }

    using _Mybase::_Unchecked_begin;
    using _Mybase::_Unchecked_end;
};


template <class _Iter, class _Hasher = hash<_Iter_value_t<_Iter>>, class _Keyeq = equal_to<_Iter_value_t<_Iter>>,
    class _Alloc = allocator<_Iter_value_t<_Iter>>,
    enable_if_t<
        conjunction_v<_Is_iterator<_Iter>, _Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>,
        int> = 0>
unordered_set(_Iter, _Iter, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(), _Alloc = _Alloc())
    -> unordered_set<_Iter_value_t<_Iter>, _Hasher, _Keyeq, _Alloc>;

template <class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>,
    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>, int> = 0>
unordered_set(initializer_list<_Kty>, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
    _Alloc = _Alloc()) -> unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>;

template <class _Iter, class _Alloc, enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
unordered_set(_Iter, _Iter, _Guide_size_type_t<_Alloc>, _Alloc)
    -> unordered_set<_Iter_value_t<_Iter>, hash<_Iter_value_t<_Iter>>, equal_to<_Iter_value_t<_Iter>>, _Alloc>;

template <class _Iter, class _Hasher, class _Alloc,
    enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
unordered_set(_Iter, _Iter, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
    -> unordered_set<_Iter_value_t<_Iter>, _Hasher, equal_to<_Iter_value_t<_Iter>>, _Alloc>;

template <class _Kty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
unordered_set(initializer_list<_Kty>, _Guide_size_type_t<_Alloc>, _Alloc)
    -> unordered_set<_Kty, hash<_Kty>, equal_to<_Kty>, _Alloc>;

template <class _Kty, class _Hasher, class _Alloc,
    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
unordered_set(initializer_list<_Kty>, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
    -> unordered_set<_Kty, _Hasher, equal_to<_Kty>, _Alloc>;
#line 302 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\unordered_set"

template <class _Kty, class _Hasher, class _Keyeq, class _Alloc>
void swap(unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>& _Left,
    unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
    _Left.swap(_Right);
}


template <class _Kty, class _Hasher, class _Keyeq, class _Alloc, class _Pr>
typename unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>::size_type erase_if(
    unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>& _Cont, _Pr _Pred) {
    return _Erase_nodes_if(_Cont, _Pass_fn(_Pred));
}
#line 316 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\unordered_set"

template <class _Kty, class _Hasher, class _Keyeq, class _Alloc>
[[nodiscard]] bool operator==(const unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>& _Left,
    const unordered_set<_Kty, _Hasher, _Keyeq, _Alloc>& _Right) {
    return _Hash_equal(_Left, _Right);
}


#line 330 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\unordered_set"

template <class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>>
class unordered_multiset : public _Hash<_Uset_traits<_Kty, _Uhash_compare<_Kty, _Hasher, _Keyeq>, _Alloc, true>> {
    
public:
    static_assert(!1 || is_same_v<_Kty, typename _Alloc::value_type>,
        "unordered_multiset<T, Hasher, Eq, Allocator>" " requires that Allocator's value_type match " "T" " (See N4659 26.2.1 [container.requirements.general]/16 allocator_type)" " Either fix the allocator value_type or define _ENFORCE_MATCHING_ALLOCATORS=0" " to suppress this diagnostic.");

private:
    using _Mytraits      = _Uhash_compare<_Kty, _Hasher, _Keyeq>;
    using _Mybase        = _Hash<_Uset_traits<_Kty, _Mytraits, _Alloc, true>>;
    using _Alnode        = typename _Mybase::_Alnode;
    using _Alnode_traits = typename _Mybase::_Alnode_traits;
    using _Key_compare   = typename _Mybase::_Key_compare;

public:
    using hasher    = _Hasher;
    using key_type  = _Kty;
    using key_equal = _Keyeq;

    using value_type      = typename _Mybase::value_type;
    using allocator_type  = typename _Mybase::allocator_type;
    using size_type       = typename _Mybase::size_type;
    using difference_type = typename _Mybase::difference_type;
    using pointer         = typename _Mybase::pointer;
    using const_pointer   = typename _Mybase::const_pointer;
    using reference       = value_type&;
    using const_reference = const value_type&;
    using iterator        = typename _Mybase::iterator;
    using const_iterator  = typename _Mybase::const_iterator;

    unordered_multiset() : _Mybase(_Key_compare(), allocator_type()) {}

    explicit unordered_multiset(const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {}

    unordered_multiset(const unordered_multiset& _Right)
        : _Mybase(_Right, _Alnode_traits::select_on_container_copy_construction(_Right._Getal())) {}

    unordered_multiset(const unordered_multiset& _Right, const allocator_type& _Al) : _Mybase(_Right, _Al) {}

    explicit unordered_multiset(size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
        this->rehash(_Buckets);
    }

    unordered_multiset(size_type _Buckets, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
        this->rehash(_Buckets);
    }

    unordered_multiset(size_type _Buckets, const hasher& _Hasharg) : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
        this->rehash(_Buckets);
    }

    unordered_multiset(size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
        : _Mybase(_Key_compare(_Hasharg), _Al) {
        this->rehash(_Buckets);
    }

    unordered_multiset(size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
        this->rehash(_Buckets);
    }

    unordered_multiset(size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg, const allocator_type& _Al)
        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
        this->rehash(_Buckets);
    }

    template <class _Iter>
    unordered_multiset(_Iter _First, _Iter _Last) : _Mybase(_Key_compare(), allocator_type()) {
        this->insert(_First, _Last);
    }

    template <class _Iter>
    unordered_multiset(_Iter _First, _Iter _Last, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
        this->insert(_First, _Last);
    }

    template <class _Iter>
    unordered_multiset(_Iter _First, _Iter _Last, size_type _Buckets) : _Mybase(_Key_compare(), allocator_type()) {
        this->rehash(_Buckets);
        this->insert(_First, _Last);
    }

    template <class _Iter>
    unordered_multiset(_Iter _First, _Iter _Last, size_type _Buckets, const allocator_type& _Al)
        : _Mybase(_Key_compare(), _Al) {
        this->rehash(_Buckets);
        this->insert(_First, _Last);
    }

    template <class _Iter>
    unordered_multiset(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg)
        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
        this->rehash(_Buckets);
        this->insert(_First, _Last);
    }

    template <class _Iter>
    unordered_multiset(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
        : _Mybase(_Key_compare(_Hasharg), _Al) {
        this->rehash(_Buckets);
        this->insert(_First, _Last);
    }

    template <class _Iter>
    unordered_multiset(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
        this->rehash(_Buckets);
        this->insert(_First, _Last);
    }

    template <class _Iter>
    unordered_multiset(_Iter _First, _Iter _Last, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg,
        const allocator_type& _Al)
        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
        this->rehash(_Buckets);
        this->insert(_First, _Last);
    }

    unordered_multiset& operator=(const unordered_multiset& _Right) {
        _Mybase::operator=(_Right);
        return *this;
    }

    unordered_multiset(unordered_multiset&& _Right) : _Mybase(::std:: move(_Right)) {}

    unordered_multiset(unordered_multiset&& _Right, const allocator_type& _Al) : _Mybase(::std:: move(_Right), _Al) {}

    unordered_multiset& operator=(unordered_multiset&& _Right) noexcept(_Alnode_traits::is_always_equal::value&&
            is_nothrow_move_assignable_v<_Hasher>&& is_nothrow_move_assignable_v<_Keyeq>) {
        _Mybase::operator=(::std:: move(_Right));
        return *this;
    }

    void swap(unordered_multiset& _Right) noexcept(noexcept(_Mybase::swap(_Right))) {
        _Mybase::swap(_Right);
    }

    unordered_multiset(initializer_list<value_type> _Ilist) : _Mybase(_Key_compare(), allocator_type()) {
        this->insert(_Ilist);
    }

    unordered_multiset(initializer_list<value_type> _Ilist, const allocator_type& _Al) : _Mybase(_Key_compare(), _Al) {
        this->insert(_Ilist);
    }

    unordered_multiset(initializer_list<value_type> _Ilist, size_type _Buckets)
        : _Mybase(_Key_compare(), allocator_type()) {
        this->rehash(_Buckets);
        this->insert(_Ilist);
    }

    unordered_multiset(initializer_list<value_type> _Ilist, size_type _Buckets, const allocator_type& _Al)
        : _Mybase(_Key_compare(), _Al) {
        this->rehash(_Buckets);
        this->insert(_Ilist);
    }

    unordered_multiset(initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg)
        : _Mybase(_Key_compare(_Hasharg), allocator_type()) {
        this->rehash(_Buckets);
        this->insert(_Ilist);
    }

    unordered_multiset(
        initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg, const allocator_type& _Al)
        : _Mybase(_Key_compare(_Hasharg), _Al) {
        this->rehash(_Buckets);
        this->insert(_Ilist);
    }

    unordered_multiset(
        initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg, const _Keyeq& _Keyeqarg)
        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), allocator_type()) {
        this->rehash(_Buckets);
        this->insert(_Ilist);
    }

    unordered_multiset(initializer_list<value_type> _Ilist, size_type _Buckets, const hasher& _Hasharg,
        const _Keyeq& _Keyeqarg, const allocator_type& _Al)
        : _Mybase(_Key_compare(_Hasharg, _Keyeqarg), _Al) {
        this->rehash(_Buckets);
        this->insert(_Ilist);
    }

    unordered_multiset& operator=(initializer_list<value_type> _Ilist) {
        this->clear();
        this->insert(_Ilist);
        return *this;
    }

    [[nodiscard]] hasher hash_function() const {
        return this->_Traitsobj._Mypair._Get_first();
    }

    [[nodiscard]] key_equal key_eq() const {
        return this->_Traitsobj._Mypair._Myval2._Get_first();
    }

    using _Mybase::_Unchecked_begin;
    using _Mybase::_Unchecked_end;
};


template <class _Iter, class _Hasher = hash<_Iter_value_t<_Iter>>, class _Keyeq = equal_to<_Iter_value_t<_Iter>>,
    class _Alloc = allocator<_Iter_value_t<_Iter>>,
    enable_if_t<
        conjunction_v<_Is_iterator<_Iter>, _Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>,
        int> = 0>
unordered_multiset(_Iter, _Iter, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
    _Alloc = _Alloc()) -> unordered_multiset<_Iter_value_t<_Iter>, _Hasher, _Keyeq, _Alloc>;

template <class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<_Kty>,
    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, negation<_Is_allocator<_Keyeq>>, _Is_allocator<_Alloc>>, int> = 0>
unordered_multiset(initializer_list<_Kty>, _Guide_size_type_t<_Alloc> = 0, _Hasher = _Hasher(), _Keyeq = _Keyeq(),
    _Alloc = _Alloc()) -> unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>;

template <class _Iter, class _Alloc, enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_allocator<_Alloc>>, int> = 0>
unordered_multiset(_Iter, _Iter, _Guide_size_type_t<_Alloc>, _Alloc)
    -> unordered_multiset<_Iter_value_t<_Iter>, hash<_Iter_value_t<_Iter>>, equal_to<_Iter_value_t<_Iter>>, _Alloc>;

template <class _Iter, class _Hasher, class _Alloc,
    enable_if_t<conjunction_v<_Is_iterator<_Iter>, _Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
unordered_multiset(_Iter, _Iter, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
    -> unordered_multiset<_Iter_value_t<_Iter>, _Hasher, equal_to<_Iter_value_t<_Iter>>, _Alloc>;

template <class _Kty, class _Alloc, enable_if_t<_Is_allocator<_Alloc>::value, int> = 0>
unordered_multiset(initializer_list<_Kty>, _Guide_size_type_t<_Alloc>, _Alloc)
    -> unordered_multiset<_Kty, hash<_Kty>, equal_to<_Kty>, _Alloc>;

template <class _Kty, class _Hasher, class _Alloc,
    enable_if_t<conjunction_v<_Is_hasher<_Hasher>, _Is_allocator<_Alloc>>, int> = 0>
unordered_multiset(initializer_list<_Kty>, _Guide_size_type_t<_Alloc>, _Hasher, _Alloc)
    -> unordered_multiset<_Kty, _Hasher, equal_to<_Kty>, _Alloc>;
#line 565 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\unordered_set"

template <class _Kty, class _Hasher, class _Keyeq, class _Alloc>
void swap(unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>& _Left,
    unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>& _Right) noexcept(noexcept(_Left.swap(_Right))) {
    _Left.swap(_Right);
}


template <class _Kty, class _Hasher, class _Keyeq, class _Alloc, class _Pr>
typename unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>::size_type erase_if(
    unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>& _Cont, _Pr _Pred) {
    return _Erase_nodes_if(_Cont, _Pass_fn(_Pred));
}
#line 579 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\unordered_set"

template <class _Kty, class _Hasher, class _Keyeq, class _Alloc>
[[nodiscard]] bool operator==(const unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>& _Left,
    const unordered_multiset<_Kty, _Hasher, _Keyeq, _Alloc>& _Right) {
    return _Hash_equal(_Left, _Right);
}


#line 593 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\unordered_set"


#line 600 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\unordered_set"


namespace pmr {
    template <class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>>
    using unordered_set = ::std:: unordered_set<_Kty, _Hasher, _Keyeq, polymorphic_allocator<_Kty>>;

    template <class _Kty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>>
    using unordered_multiset = ::std:: unordered_multiset<_Kty, _Hasher, _Keyeq, polymorphic_allocator<_Kty>>;
} 
#line 610 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\unordered_set"
}


#pragma warning(pop)
#pragma pack(pop)
#line 616 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\unordered_set"
#line 617 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\unordered_set"
#line 67 "all-std.cxx"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_int128.hpp"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin.h"


#pragma once


#pragma warning(push)
#pragma warning(disable:   4514 4820 )


#line 31 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin.h"


        #line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"


#pragma once


#line 17 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"


#line 25 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\wmmintrin.h"


#pragma once


#line 18 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\wmmintrin.h"


#line 26 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\wmmintrin.h"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\nmmintrin.h"


#pragma once


#line 19 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\nmmintrin.h"


#line 27 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\nmmintrin.h"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\smmintrin.h"


#pragma once


#line 19 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\smmintrin.h"


#line 27 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\smmintrin.h"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tmmintrin.h"


#pragma once


#line 12 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tmmintrin.h"


#line 20 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tmmintrin.h"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\pmmintrin.h"


#pragma once


#line 18 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\pmmintrin.h"


#line 26 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\pmmintrin.h"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\emmintrin.h"


#pragma once


#line 22 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\emmintrin.h"


#line 30 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\emmintrin.h"


#line 34 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\emmintrin.h"


#line 38 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\emmintrin.h"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmmintrin.h"


#pragma once


#line 29 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmmintrin.h"


#line 33 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmmintrin.h"


#line 41 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmmintrin.h"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mmintrin.h"


#pragma once


#line 19 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mmintrin.h"


#line 23 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mmintrin.h"


extern "C" { 


#line 29 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mmintrin.h"

typedef union __declspec(intrin_type) __declspec(align(8)) __m64
{
    unsigned __int64    m64_u64;
    float               m64_f32[2];
    __int8              m64_i8[8];
    __int16             m64_i16[4];
    __int32             m64_i32[2];
    __int64             m64_i64;
    unsigned __int8     m64_u8[8];
    unsigned __int16    m64_u16[4];
    unsigned __int32    m64_u32[2];
} __m64;


void  _m_empty(void);
__m64 _m_from_int(int _I);
int   _m_to_int(__m64 _M);
__m64 _m_packsswb(__m64 _MM1, __m64 _MM2);
__m64 _m_packssdw(__m64 _MM1, __m64 _MM2);
__m64 _m_packuswb(__m64 _MM1, __m64 _MM2);
__m64 _m_punpckhbw(__m64 _MM1, __m64 _MM2);
__m64 _m_punpckhwd(__m64 _MM1, __m64 _MM2);
__m64 _m_punpckhdq(__m64 _MM1, __m64 _MM2);
__m64 _m_punpcklbw(__m64 _MM1, __m64 _MM2);
__m64 _m_punpcklwd(__m64 _MM1, __m64 _MM2);
__m64 _m_punpckldq(__m64 _MM1, __m64 _MM2);


__m64 _m_paddb(__m64 _MM1, __m64 _MM2);
__m64 _m_paddw(__m64 _MM1, __m64 _MM2);
__m64 _m_paddd(__m64 _MM1, __m64 _MM2);
__m64 _m_paddsb(__m64 _MM1, __m64 _MM2);
__m64 _m_paddsw(__m64 _MM1, __m64 _MM2);
__m64 _m_paddusb(__m64 _MM1, __m64 _MM2);
__m64 _m_paddusw(__m64 _MM1, __m64 _MM2);
__m64 _m_psubb(__m64 _MM1, __m64 _MM2);
__m64 _m_psubw(__m64 _MM1, __m64 _MM2);
__m64 _m_psubd(__m64 _MM1, __m64 _MM2);
__m64 _m_psubsb(__m64 _MM1, __m64 _MM2);
__m64 _m_psubsw(__m64 _MM1, __m64 _MM2);
__m64 _m_psubusb(__m64 _MM1, __m64 _MM2);
__m64 _m_psubusw(__m64 _MM1, __m64 _MM2);
__m64 _m_pmaddwd(__m64 _MM1, __m64 _MM2);
__m64 _m_pmulhw(__m64 _MM1, __m64 _MM2);
__m64 _m_pmullw(__m64 _MM1, __m64 _MM2);


__m64 _m_psllw(__m64 _M, __m64 _Count);
__m64 _m_psllwi(__m64 _M, int _Count);
__m64 _m_pslld(__m64 _M, __m64 _Count);
__m64 _m_pslldi(__m64 _M, int _Count);
__m64 _m_psllq(__m64 _M, __m64 _Count);
__m64 _m_psllqi(__m64 _M, int _Count);
__m64 _m_psraw(__m64 _M, __m64 _Count);
__m64 _m_psrawi(__m64 _M, int _Count);
__m64 _m_psrad(__m64 _M, __m64 _Count);
__m64 _m_psradi(__m64 _M, int _Count);
__m64 _m_psrlw(__m64 _M, __m64 _Count);
__m64 _m_psrlwi(__m64 _M, int _Count);
__m64 _m_psrld(__m64 _M, __m64 _Count);
__m64 _m_psrldi(__m64 _M, int _Count);
__m64 _m_psrlq(__m64 _M, __m64 _Count);
__m64 _m_psrlqi(__m64 _M, int _Count);


__m64 _m_pand(__m64 _MM1, __m64 _MM2);
__m64 _m_pandn(__m64 _MM1, __m64 _MM2);
__m64 _m_por(__m64 _MM1, __m64 _MM2);
__m64 _m_pxor(__m64 _MM1, __m64 _MM2);


__m64 _m_pcmpeqb(__m64 _MM1, __m64 _MM2);
__m64 _m_pcmpeqw(__m64 _MM1, __m64 _MM2);
__m64 _m_pcmpeqd(__m64 _MM1, __m64 _MM2);
__m64 _m_pcmpgtb(__m64 _MM1, __m64 _MM2);
__m64 _m_pcmpgtw(__m64 _MM1, __m64 _MM2);
__m64 _m_pcmpgtd(__m64 _MM1, __m64 _MM2);


__m64 _mm_setzero_si64(void);
__m64 _mm_set_pi32(int _I1, int _I0);
__m64 _mm_set_pi16(short _S3, short _S2, short _S1, short _S0);
__m64 _mm_set_pi8(char _B7, char _B6, char _B5, char _B4,
                  char _B3, char _B2, char _B1, char _B0);
__m64 _mm_set1_pi32(int _I);
__m64 _mm_set1_pi16(short _S);
__m64 _mm_set1_pi8(char _B);
__m64 _mm_setr_pi32(int _I1, int _I0);
__m64 _mm_setr_pi16(short _S3, short _S2, short _S1, short _S0);
__m64 _mm_setr_pi8(char _B7, char _B6, char _B5, char _B4,
                   char _B3, char _B2, char _B1, char _B0);


#line 180 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mmintrin.h"


}; 
#line 184 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mmintrin.h"

#line 186 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mmintrin.h"
#line 187 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mmintrin.h"
#line 188 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mmintrin.h"
#line 47 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmmintrin.h"
#line 48 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmmintrin.h"


typedef union __declspec(intrin_type) __declspec(align(16)) __m128 {
     float               m128_f32[4];
     unsigned __int64    m128_u64[2];
     __int8              m128_i8[16];
     __int16             m128_i16[8];
     __int32             m128_i32[4];
     __int64             m128_i64[2];
     unsigned __int8     m128_u8[16];
     unsigned __int16    m128_u16[8];
     unsigned __int32    m128_u32[4];
 } __m128;


#line 81 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmmintrin.h"
#line 82 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmmintrin.h"

 
extern "C" { 
  
#line 191 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmmintrin.h"


extern __m128 _mm_add_ss(__m128 _A, __m128 _B);
extern __m128 _mm_add_ps(__m128 _A, __m128 _B);
extern __m128 _mm_sub_ss(__m128 _A, __m128 _B);
extern __m128 _mm_sub_ps(__m128 _A, __m128 _B);
extern __m128 _mm_mul_ss(__m128 _A, __m128 _B);
extern __m128 _mm_mul_ps(__m128 _A, __m128 _B);
extern __m128 _mm_div_ss(__m128 _A, __m128 _B);
extern __m128 _mm_div_ps(__m128 _A, __m128 _B);
extern __m128 _mm_sqrt_ss(__m128 _A);
extern __m128 _mm_sqrt_ps(__m128 _A);
extern __m128 _mm_rcp_ss(__m128 _A);
extern __m128 _mm_rcp_ps(__m128 _A);
extern __m128 _mm_rsqrt_ss(__m128 _A);
extern __m128 _mm_rsqrt_ps(__m128 _A);
extern __m128 _mm_min_ss(__m128 _A, __m128 _B);
extern __m128 _mm_min_ps(__m128 _A, __m128 _B);
extern __m128 _mm_max_ss(__m128 _A, __m128 _B);
extern __m128 _mm_max_ps(__m128 _A, __m128 _B);


extern __m128 _mm_and_ps(__m128 _A, __m128 _B);
extern __m128 _mm_andnot_ps(__m128 _A, __m128 _B);
extern __m128 _mm_or_ps(__m128 _A, __m128 _B);
extern __m128 _mm_xor_ps(__m128 _A, __m128 _B);


extern __m128 _mm_cmpeq_ss(__m128 _A, __m128 _B);
extern __m128 _mm_cmpeq_ps(__m128 _A, __m128 _B);
extern __m128 _mm_cmplt_ss(__m128 _A, __m128 _B);
extern __m128 _mm_cmplt_ps(__m128 _A, __m128 _B);
extern __m128 _mm_cmple_ss(__m128 _A, __m128 _B);
extern __m128 _mm_cmple_ps(__m128 _A, __m128 _B);
extern __m128 _mm_cmpgt_ss(__m128 _A, __m128 _B);
extern __m128 _mm_cmpgt_ps(__m128 _A, __m128 _B);
extern __m128 _mm_cmpge_ss(__m128 _A, __m128 _B);
extern __m128 _mm_cmpge_ps(__m128 _A, __m128 _B);
extern __m128 _mm_cmpneq_ss(__m128 _A, __m128 _B);
extern __m128 _mm_cmpneq_ps(__m128 _A, __m128 _B);
extern __m128 _mm_cmpnlt_ss(__m128 _A, __m128 _B);
extern __m128 _mm_cmpnlt_ps(__m128 _A, __m128 _B);
extern __m128 _mm_cmpnle_ss(__m128 _A, __m128 _B);
extern __m128 _mm_cmpnle_ps(__m128 _A, __m128 _B);
extern __m128 _mm_cmpngt_ss(__m128 _A, __m128 _B);
extern __m128 _mm_cmpngt_ps(__m128 _A, __m128 _B);
extern __m128 _mm_cmpnge_ss(__m128 _A, __m128 _B);
extern __m128 _mm_cmpnge_ps(__m128 _A, __m128 _B);
extern __m128 _mm_cmpord_ss(__m128 _A, __m128 _B);
extern __m128 _mm_cmpord_ps(__m128 _A, __m128 _B);
extern __m128 _mm_cmpunord_ss(__m128 _A, __m128 _B);
extern __m128 _mm_cmpunord_ps(__m128 _A, __m128 _B);
extern int _mm_comieq_ss(__m128 _A, __m128 _B);
extern int _mm_comilt_ss(__m128 _A, __m128 _B);
extern int _mm_comile_ss(__m128 _A, __m128 _B);
extern int _mm_comigt_ss(__m128 _A, __m128 _B);
extern int _mm_comige_ss(__m128 _A, __m128 _B);
extern int _mm_comineq_ss(__m128 _A, __m128 _B);
extern int _mm_ucomieq_ss(__m128 _A, __m128 _B);
extern int _mm_ucomilt_ss(__m128 _A, __m128 _B);
extern int _mm_ucomile_ss(__m128 _A, __m128 _B);
extern int _mm_ucomigt_ss(__m128 _A, __m128 _B);
extern int _mm_ucomige_ss(__m128 _A, __m128 _B);
extern int _mm_ucomineq_ss(__m128 _A, __m128 _B);


extern int _mm_cvt_ss2si(__m128 _A);
extern int _mm_cvtt_ss2si(__m128 _A);
extern __m128 _mm_cvt_si2ss(__m128, int);
extern float _mm_cvtss_f32(__m128 _A);


extern __m64 _mm_cvt_ps2pi(__m128 _A);
extern __m64 _mm_cvtt_ps2pi(__m128 _A);
extern __m128 _mm_cvt_pi2ps(__m128, __m64);
#line 282 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmmintrin.h"


#line 291 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmmintrin.h"


extern __m128 _mm_shuffle_ps(__m128 _A, __m128 _B, unsigned int _Imm8);
extern __m128 _mm_unpackhi_ps(__m128 _A, __m128 _B);
extern __m128 _mm_unpacklo_ps(__m128 _A, __m128 _B);
extern __m128 _mm_loadh_pi(__m128, __m64 const*);
extern __m128 _mm_movehl_ps(__m128, __m128);
extern __m128 _mm_movelh_ps(__m128, __m128);
extern void _mm_storeh_pi(__m64 *, __m128);
extern __m128 _mm_loadl_pi(__m128, __m64 const*);
extern void _mm_storel_pi(__m64 *, __m128);
extern int _mm_movemask_ps(__m128 _A);


extern int _m_pextrw(__m64, int);
extern __m64 _m_pinsrw(__m64, int, int);
extern __m64 _m_pmaxsw(__m64, __m64);
extern __m64 _m_pmaxub(__m64, __m64);
extern __m64 _m_pminsw(__m64, __m64);
extern __m64 _m_pminub(__m64, __m64);
extern int _m_pmovmskb(__m64);
extern __m64 _m_pmulhuw(__m64, __m64);
extern __m64 _m_pshufw(__m64, int);
extern void _m_maskmovq(__m64, __m64, char *);
extern __m64 _m_pavgb(__m64, __m64);
extern __m64 _m_pavgw(__m64, __m64);
extern __m64 _m_psadbw(__m64, __m64);
#line 326 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmmintrin.h"


extern __m128 _mm_set_ss(float _A);
extern __m128 _mm_set_ps1(float _A);
extern __m128 _mm_set_ps(float _A, float _B, float _C, float _D);
extern __m128 _mm_setr_ps(float _A, float _B, float _C, float _D);
extern __m128 _mm_setzero_ps(void);
extern __m128 _mm_load_ss(float const*_A);
extern __m128 _mm_load_ps1(float const*_A);
extern __m128 _mm_load_ps(float const*_A);
extern __m128 _mm_loadr_ps(float const*_A);
extern __m128 _mm_loadu_ps(float const*_A);
extern void _mm_store_ss(float *_V, __m128 _A);
extern void _mm_store_ps1(float *_V, __m128 _A);
extern void _mm_store_ps(float *_V, __m128 _A);
extern void _mm_storer_ps(float *_V, __m128 _A);
extern void _mm_storeu_ps(float *_V, __m128 _A);
extern void _mm_prefetch(char const*_A, int _Sel);

extern void _mm_stream_pi(__m64 *, __m64);
#line 350 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmmintrin.h"
extern void _mm_stream_ps(float *, __m128);
extern __m128 _mm_move_ss(__m128 _A, __m128 _B);

extern void _mm_sfence(void);
extern unsigned int _mm_getcsr(void);
extern void _mm_setcsr(unsigned int);


#line 381 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmmintrin.h"


#pragma warning(push)
#pragma warning(disable: 4514) 
 
 
__inline __m128 _mm_cvtpi16_ps(__m64 _A)
{
  __m128 _Tmp;
  __m64  _Ext_val = _m_pcmpgtw(_mm_setzero_si64(), _A);

  _Tmp = _mm_cvt_pi2ps(_mm_setzero_ps(), _m_punpckhwd(_A, _Ext_val));
  return(_mm_cvt_pi2ps(_mm_movelh_ps(_Tmp, _Tmp),
                        _m_punpcklwd(_A, _Ext_val)));
}


__inline __m128 _mm_cvtpu16_ps(__m64 _A)
{
  __m128 _Tmp;
  __m64  _Ext_val = _mm_setzero_si64();

  _Tmp = _mm_cvt_pi2ps(_mm_setzero_ps(), _m_punpckhwd(_A, _Ext_val));
  return(_mm_cvt_pi2ps(_mm_movelh_ps(_Tmp, _Tmp),
                        _m_punpcklwd(_A, _Ext_val)));
}


__inline __m64 _mm_cvtps_pi16(__m128 _A)
{
  return _m_packssdw(_mm_cvt_ps2pi(_A),
                        _mm_cvt_ps2pi(_mm_movehl_ps(_A, _A)));
}


__inline __m128 _mm_cvtpi8_ps(__m64 _A)
{
  __m64  _Ext_val = _m_pcmpgtb(_mm_setzero_si64(), _A);

  return _mm_cvtpi16_ps(_m_punpcklbw(_A, _Ext_val));
}


__inline __m128 _mm_cvtpu8_ps(__m64 _A)
{
  return _mm_cvtpu16_ps(_m_punpcklbw(_A, _mm_setzero_si64()));
}


__inline __m64 _mm_cvtps_pi8(__m128 _A)
{
  return _m_packsswb(_mm_cvtps_pi16(_A), _mm_setzero_si64());
}


__inline __m128 _mm_cvtpi32x2_ps(__m64 _A, __m64 _B)
{
  return _mm_movelh_ps(_mm_cvt_pi2ps(_mm_setzero_ps(), _A),
                       _mm_cvt_pi2ps(_mm_setzero_ps(), _B));
}
#pragma warning(pop)
#line 509 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmmintrin.h"


}; 
#line 514 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmmintrin.h"

#line 516 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmmintrin.h"
#line 517 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmmintrin.h"
#line 518 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\xmmintrin.h"
#line 43 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\emmintrin.h"

typedef union __declspec(intrin_type) __declspec(align(16)) __m128i {
    __int8              m128i_i8[16];
    __int16             m128i_i16[8];
    __int32             m128i_i32[4];
    __int64             m128i_i64[2];
    unsigned __int8     m128i_u8[16];
    unsigned __int16    m128i_u16[8];
    unsigned __int32    m128i_u32[4];
    unsigned __int64    m128i_u64[2];
} __m128i;

typedef struct __declspec(intrin_type) __declspec(align(16)) __m128d {
    double              m128d_f64[2];
} __m128d;


extern "C" { 
  
#line 72 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\emmintrin.h"


extern __m128d _mm_add_sd(__m128d _A, __m128d _B);
extern __m128d _mm_add_pd(__m128d _A, __m128d _B);
extern __m128d _mm_sub_sd(__m128d _A, __m128d _B);
extern __m128d _mm_sub_pd(__m128d _A, __m128d _B);
extern __m128d _mm_mul_sd(__m128d _A, __m128d _B);
extern __m128d _mm_mul_pd(__m128d _A, __m128d _B);
extern __m128d _mm_sqrt_sd(__m128d _A, __m128d _B);
extern __m128d _mm_sqrt_pd(__m128d _A);
extern __m128d _mm_div_sd(__m128d _A, __m128d _B);
extern __m128d _mm_div_pd(__m128d _A, __m128d _B);
extern __m128d _mm_min_sd(__m128d _A, __m128d _B);
extern __m128d _mm_min_pd(__m128d _A, __m128d _B);
extern __m128d _mm_max_sd(__m128d _A, __m128d _B);
extern __m128d _mm_max_pd(__m128d _A, __m128d _B);


extern __m128d _mm_and_pd(__m128d _A, __m128d _B);
extern __m128d _mm_andnot_pd(__m128d _A, __m128d _B);
extern __m128d _mm_or_pd(__m128d _A, __m128d _B);
extern __m128d _mm_xor_pd(__m128d _A, __m128d _B);


extern __m128d _mm_cmpeq_sd(__m128d _A, __m128d _B);
extern __m128d _mm_cmpeq_pd(__m128d _A, __m128d _B);
extern __m128d _mm_cmplt_sd(__m128d _A, __m128d _B);
extern __m128d _mm_cmplt_pd(__m128d _A, __m128d _B);
extern __m128d _mm_cmple_sd(__m128d _A, __m128d _B);
extern __m128d _mm_cmple_pd(__m128d _A, __m128d _B);
extern __m128d _mm_cmpgt_sd(__m128d _A, __m128d _B);
extern __m128d _mm_cmpgt_pd(__m128d _A, __m128d _B);
extern __m128d _mm_cmpge_sd(__m128d _A, __m128d _B);
extern __m128d _mm_cmpge_pd(__m128d _A, __m128d _B);
extern __m128d _mm_cmpneq_sd(__m128d _A, __m128d _B);
extern __m128d _mm_cmpneq_pd(__m128d _A, __m128d _B);
extern __m128d _mm_cmpnlt_sd(__m128d _A, __m128d _B);
extern __m128d _mm_cmpnlt_pd(__m128d _A, __m128d _B);
extern __m128d _mm_cmpnle_sd(__m128d _A, __m128d _B);
extern __m128d _mm_cmpnle_pd(__m128d _A, __m128d _B);
extern __m128d _mm_cmpngt_sd(__m128d _A, __m128d _B);
extern __m128d _mm_cmpngt_pd(__m128d _A, __m128d _B);
extern __m128d _mm_cmpnge_sd(__m128d _A, __m128d _B);
extern __m128d _mm_cmpnge_pd(__m128d _A, __m128d _B);
extern __m128d _mm_cmpord_pd(__m128d _A, __m128d _B);
extern __m128d _mm_cmpord_sd(__m128d _A, __m128d _B);
extern __m128d _mm_cmpunord_pd(__m128d _A, __m128d _B);
extern __m128d _mm_cmpunord_sd(__m128d _A, __m128d _B);
extern int _mm_comieq_sd(__m128d _A, __m128d _B);
extern int _mm_comilt_sd(__m128d _A, __m128d _B);
extern int _mm_comile_sd(__m128d _A, __m128d _B);
extern int _mm_comigt_sd(__m128d _A, __m128d _B);
extern int _mm_comige_sd(__m128d _A, __m128d _B);
extern int _mm_comineq_sd(__m128d _A, __m128d _B);
extern int _mm_ucomieq_sd(__m128d _A, __m128d _B);
extern int _mm_ucomilt_sd(__m128d _A, __m128d _B);
extern int _mm_ucomile_sd(__m128d _A, __m128d _B);
extern int _mm_ucomigt_sd(__m128d _A, __m128d _B);
extern int _mm_ucomige_sd(__m128d _A, __m128d _B);
extern int _mm_ucomineq_sd(__m128d _A, __m128d _B);


extern __m128d _mm_cvtepi32_pd(__m128i _A);
extern __m128i _mm_cvtpd_epi32(__m128d _A);
extern __m128i _mm_cvttpd_epi32(__m128d _A);
extern __m128 _mm_cvtepi32_ps(__m128i _A);
extern __m128i _mm_cvtps_epi32(__m128 _A);
extern __m128i _mm_cvttps_epi32(__m128 _A);
extern __m128 _mm_cvtpd_ps(__m128d _A);
extern __m128d _mm_cvtps_pd(__m128 _A);
extern __m128 _mm_cvtsd_ss(__m128 _A, __m128d _B);
extern __m128d _mm_cvtss_sd(__m128d _A, __m128 _B);

extern int _mm_cvtsd_si32(__m128d _A);
extern int _mm_cvttsd_si32(__m128d _A);
extern __m128d _mm_cvtsi32_sd(__m128d _A, int _B);


extern __m64 _mm_cvtpd_pi32(__m128d _A);
extern __m64 _mm_cvttpd_pi32(__m128d _A);
extern __m128d _mm_cvtpi32_pd(__m64 _A);
#line 166 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\emmintrin.h"


extern __m128d _mm_unpackhi_pd(__m128d _A, __m128d _B);
extern __m128d _mm_unpacklo_pd(__m128d _A, __m128d _B);
extern int _mm_movemask_pd(__m128d _A);
extern __m128d _mm_shuffle_pd(__m128d _A, __m128d _B, int _I);


extern __m128d _mm_load_pd(double const*_Dp);
extern __m128d _mm_load1_pd(double const*_Dp);
extern __m128d _mm_loadr_pd(double const*_Dp);
extern __m128d _mm_loadu_pd(double const*_Dp);
extern __m128d _mm_load_sd(double const*_Dp);
extern __m128d _mm_loadh_pd(__m128d _A, double const*_Dp);
extern __m128d _mm_loadl_pd(__m128d _A, double const*_Dp);


extern __m128d _mm_set_sd(double _W);
extern __m128d _mm_set1_pd(double _A);
extern __m128d _mm_set_pd(double _Z, double _Y);
extern __m128d _mm_setr_pd(double _Y, double _Z);
extern __m128d _mm_setzero_pd(void);
extern __m128d _mm_move_sd(__m128d _A, __m128d _B);


extern void _mm_store_sd(double *_Dp, __m128d _A);
extern void _mm_store1_pd(double *_Dp, __m128d _A);
extern void _mm_store_pd(double *_Dp, __m128d _A);
extern void _mm_storeu_pd(double *_Dp, __m128d _A);
extern void _mm_storer_pd(double *_Dp, __m128d _A);
extern void _mm_storeh_pd(double *_Dp, __m128d _A);
extern void _mm_storel_pd(double *_Dp, __m128d _A);


extern __m128i _mm_add_epi8(__m128i _A, __m128i _B);
extern __m128i _mm_add_epi16(__m128i _A, __m128i _B);
extern __m128i _mm_add_epi32(__m128i _A, __m128i _B);

extern __m64 _mm_add_si64(__m64 _A, __m64 _B);
#line 226 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\emmintrin.h"
extern __m128i _mm_add_epi64(__m128i _A, __m128i _B);
extern __m128i _mm_adds_epi8(__m128i _A, __m128i _B);
extern __m128i _mm_adds_epi16(__m128i _A, __m128i _B);
extern __m128i _mm_adds_epu8(__m128i _A, __m128i _B);
extern __m128i _mm_adds_epu16(__m128i _A, __m128i _B);
extern __m128i _mm_avg_epu8(__m128i _A, __m128i _B);
extern __m128i _mm_avg_epu16(__m128i _A, __m128i _B);
extern __m128i _mm_madd_epi16(__m128i _A, __m128i _B);
extern __m128i _mm_max_epi16(__m128i _A, __m128i _B);
extern __m128i _mm_max_epu8(__m128i _A, __m128i _B);
extern __m128i _mm_min_epi16(__m128i _A, __m128i _B);
extern __m128i _mm_min_epu8(__m128i _A, __m128i _B);
extern __m128i _mm_mulhi_epi16(__m128i _A, __m128i _B);
extern __m128i _mm_mulhi_epu16(__m128i _A, __m128i _B);
extern __m128i _mm_mullo_epi16(__m128i _A, __m128i _B);

extern __m64 _mm_mul_su32(__m64 _A, __m64 _B);
#line 244 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\emmintrin.h"
extern __m128i _mm_mul_epu32(__m128i _A, __m128i _B);
extern __m128i _mm_sad_epu8(__m128i _A, __m128i _B);
extern __m128i _mm_sub_epi8(__m128i _A, __m128i _B);
extern __m128i _mm_sub_epi16(__m128i _A, __m128i _B);
extern __m128i _mm_sub_epi32(__m128i _A, __m128i _B);

extern __m64 _mm_sub_si64(__m64 _A, __m64 _B);
#line 252 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\emmintrin.h"
extern __m128i _mm_sub_epi64(__m128i _A, __m128i _B);
extern __m128i _mm_subs_epi8(__m128i _A, __m128i _B);
extern __m128i _mm_subs_epi16(__m128i _A, __m128i _B);
extern __m128i _mm_subs_epu8(__m128i _A, __m128i _B);
extern __m128i _mm_subs_epu16(__m128i _A, __m128i _B);


extern __m128i _mm_and_si128(__m128i _A, __m128i _B);
extern __m128i _mm_andnot_si128(__m128i _A, __m128i _B);
extern __m128i _mm_or_si128(__m128i _A, __m128i _B);
extern __m128i _mm_xor_si128(__m128i _A, __m128i _B);


extern __m128i _mm_slli_si128(__m128i _A, int _Imm);

extern __m128i _mm_slli_epi16(__m128i _A, int _Count);
extern __m128i _mm_sll_epi16(__m128i _A, __m128i _Count);
extern __m128i _mm_slli_epi32(__m128i _A, int _Count);
extern __m128i _mm_sll_epi32(__m128i _A, __m128i _Count);
extern __m128i _mm_slli_epi64(__m128i _A, int _Count);
extern __m128i _mm_sll_epi64(__m128i _A, __m128i _Count);
extern __m128i _mm_srai_epi16(__m128i _A, int _Count);
extern __m128i _mm_sra_epi16(__m128i _A, __m128i _Count);
extern __m128i _mm_srai_epi32(__m128i _A, int _Count);
extern __m128i _mm_sra_epi32(__m128i _A, __m128i _Count);
extern __m128i _mm_srli_si128(__m128i _A, int _Imm);

extern __m128i _mm_srli_epi16(__m128i _A, int _Count);
extern __m128i _mm_srl_epi16(__m128i _A, __m128i _Count);
extern __m128i _mm_srli_epi32(__m128i _A, int _Count);
extern __m128i _mm_srl_epi32(__m128i _A, __m128i _Count);
extern __m128i _mm_srli_epi64(__m128i _A, int _Count);
extern __m128i _mm_srl_epi64(__m128i _A, __m128i _Count);


extern __m128i _mm_cmpeq_epi8(__m128i _A, __m128i _B);
extern __m128i _mm_cmpeq_epi16(__m128i _A, __m128i _B);
extern __m128i _mm_cmpeq_epi32(__m128i _A, __m128i _B);
extern __m128i _mm_cmpgt_epi8(__m128i _A, __m128i _B);
extern __m128i _mm_cmpgt_epi16(__m128i _A, __m128i _B);
extern __m128i _mm_cmpgt_epi32(__m128i _A, __m128i _B);
extern __m128i _mm_cmplt_epi8(__m128i _A, __m128i _B);
extern __m128i _mm_cmplt_epi16(__m128i _A, __m128i _B);
extern __m128i _mm_cmplt_epi32(__m128i _A, __m128i _B);


extern __m128i _mm_cvtsi32_si128(int _A);
extern int _mm_cvtsi128_si32(__m128i _A);


extern __m128i _mm_packs_epi16(__m128i _A, __m128i _B);
extern __m128i _mm_packs_epi32(__m128i _A, __m128i _B);
extern __m128i _mm_packus_epi16(__m128i _A, __m128i _B);
extern int _mm_extract_epi16(__m128i _A, int _Imm);
extern __m128i _mm_insert_epi16(__m128i _A, int _B, int _Imm);
extern int _mm_movemask_epi8(__m128i _A);
extern __m128i _mm_shuffle_epi32(__m128i _A, int _Imm);
extern __m128i _mm_shufflehi_epi16(__m128i _A, int _Imm);
extern __m128i _mm_shufflelo_epi16(__m128i _A, int _Imm);
extern __m128i _mm_unpackhi_epi8(__m128i _A, __m128i _B);
extern __m128i _mm_unpackhi_epi16(__m128i _A, __m128i _B);
extern __m128i _mm_unpackhi_epi32(__m128i _A, __m128i _B);
extern __m128i _mm_unpackhi_epi64(__m128i _A, __m128i _B);
extern __m128i _mm_unpacklo_epi8(__m128i _A, __m128i _B);
extern __m128i _mm_unpacklo_epi16(__m128i _A, __m128i _B);
extern __m128i _mm_unpacklo_epi32(__m128i _A, __m128i _B);
extern __m128i _mm_unpacklo_epi64(__m128i _A, __m128i _B);


extern __m128i _mm_load_si128(__m128i const*_P);
extern __m128i _mm_loadu_si128(__m128i const*_P);
extern __m128i _mm_loadl_epi64(__m128i const*_P);


extern __m128i _mm_set_epi64(__m64 _Q1, __m64 _Q0);
#line 350 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\emmintrin.h"
extern __m128i _mm_set_epi64x(__int64 _I1,__int64 _I0);
extern __m128i _mm_set_epi32(int _I3, int _I2, int _I1, int _I0);
extern __m128i _mm_set_epi16(short _W7, short _W6, short _W5, short _W4,
                             short _W3, short _W2, short _W1, short _W0);
extern __m128i _mm_set_epi8(char _B15, char _B14, char _B13, char _B12,
                            char _B11, char _B10, char _B9, char _B8,
                            char _B7, char _B6, char _B5, char _B4,
                            char _B3, char _B2, char _B1, char _B0);

extern __m128i _mm_set1_epi64(__m64 _Q);
#line 361 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\emmintrin.h"
extern __m128i _mm_set1_epi64x(__int64 i);
extern __m128i _mm_set1_epi32(int _I);
extern __m128i _mm_set1_epi16(short _W);
extern __m128i _mm_set1_epi8(char _B);
extern __m128i _mm_setl_epi64(__m128i _Q);

extern __m128i _mm_setr_epi64(__m64 _Q0, __m64 _Q1);
#line 369 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\emmintrin.h"
extern __m128i _mm_setr_epi32(int _I0, int _I1, int _I2, int _I3);
extern __m128i _mm_setr_epi16(short _W0, short _W1, short _W2, short _W3,
                              short _W4, short _W5, short _W6, short _W7);
extern __m128i _mm_setr_epi8(char _B15, char _B14, char _B13, char _B12,
                             char _B11, char _B10, char _B9, char _B8,
                             char _B7, char _B6, char _B5, char _B4,
                             char _B3, char _B2, char _B1, char _B0);
extern __m128i _mm_setzero_si128(void);


extern void _mm_store_si128(__m128i *_P, __m128i _B);
extern void _mm_storeu_si128(__m128i *_P, __m128i _B);
extern void _mm_storel_epi64(__m128i *_P, __m128i _Q);
extern void _mm_maskmoveu_si128(__m128i _D, __m128i _N, char *_P);


extern __m128i _mm_move_epi64(__m128i _Q);

extern __m128i _mm_movpi64_epi64(__m64 _Q);
extern __m64 _mm_movepi64_pi64(__m128i _Q);
#line 396 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\emmintrin.h"


extern void _mm_stream_pd(double *_Dp, __m128d _A);
extern void _mm_stream_si128(__m128i *_P, __m128i _A);
extern void _mm_clflush(void const*_P);
extern void _mm_lfence(void);
extern void _mm_mfence(void);
extern void _mm_stream_si32(int *_P, int _I);
extern void _mm_pause(void);


extern double _mm_cvtsd_f64(__m128d _A);


extern __m128  _mm_castpd_ps(__m128d);
extern __m128i _mm_castpd_si128(__m128d);
extern __m128d _mm_castps_pd(__m128);
extern __m128i _mm_castps_si128(__m128);
extern __m128  _mm_castsi128_ps(__m128i);
extern __m128d _mm_castsi128_pd(__m128i);


#line 441 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\emmintrin.h"


}; 
#line 445 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\emmintrin.h"

#line 447 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\emmintrin.h"
#line 448 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\emmintrin.h"
#line 449 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\emmintrin.h"
#line 31 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\pmmintrin.h"

 
extern "C" { 
  
#line 57 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\pmmintrin.h"


extern __m128 _mm_addsub_ps(__m128 , __m128 );
extern __m128 _mm_hadd_ps(__m128 , __m128 );
extern __m128 _mm_hsub_ps(__m128 , __m128 );
extern __m128 _mm_movehdup_ps(__m128 );
extern __m128 _mm_moveldup_ps(__m128 );


extern __m128d _mm_addsub_pd(__m128d , __m128d );
extern __m128d _mm_hadd_pd(__m128d , __m128d );
extern __m128d _mm_hsub_pd(__m128d , __m128d );
extern __m128d _mm_loaddup_pd(double const * );
extern __m128d _mm_movedup_pd(__m128d );


extern __m128i _mm_lddqu_si128(__m128i const * );


extern void _mm_monitor(void const * , unsigned , unsigned );


extern void _mm_mwait(unsigned , unsigned );


}; 
#line 99 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\pmmintrin.h"

#line 101 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\pmmintrin.h"
#line 102 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\pmmintrin.h"
#line 103 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\pmmintrin.h"
#line 22 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tmmintrin.h"


extern "C" {
#line 33 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tmmintrin.h"

    
    extern __m128i _mm_hadd_epi16 (__m128i, __m128i);
    extern __m128i _mm_hadd_epi32 (__m128i, __m128i);
    extern __m128i _mm_hadds_epi16 (__m128i, __m128i);


    extern __m64 _mm_hadd_pi16 (__m64, __m64);
    extern __m64 _mm_hadd_pi32 (__m64, __m64);
    extern __m64 _mm_hadds_pi16 (__m64, __m64);
#line 50 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tmmintrin.h"

    
    extern __m128i _mm_hsub_epi16 (__m128i, __m128i);
    extern __m128i _mm_hsub_epi32 (__m128i, __m128i);
    extern __m128i _mm_hsubs_epi16 (__m128i, __m128i);


    extern __m64 _mm_hsub_pi16 (__m64, __m64);
    extern __m64 _mm_hsub_pi32 (__m64, __m64);
    extern __m64 _mm_hsubs_pi16 (__m64, __m64);
#line 68 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tmmintrin.h"

    
    extern __m128i _mm_maddubs_epi16 (__m128i, __m128i);


    extern __m64 _mm_maddubs_pi16 (__m64, __m64);
#line 83 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tmmintrin.h"

    
    extern __m128i _mm_mulhrs_epi16 (__m128i, __m128i);


    extern __m64 _mm_mulhrs_pi16 (__m64, __m64);
#line 92 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tmmintrin.h"

    
    extern __m128i _mm_shuffle_epi8 (__m128i, __m128i);


    extern __m64 _mm_shuffle_pi8 (__m64, __m64);
#line 101 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tmmintrin.h"

    
    extern __m128i _mm_sign_epi8 (__m128i, __m128i);
    extern __m128i _mm_sign_epi16 (__m128i, __m128i);
    extern __m128i _mm_sign_epi32 (__m128i, __m128i);


    extern __m64 _mm_sign_pi8 (__m64, __m64);
    extern __m64 _mm_sign_pi16 (__m64, __m64);
    extern __m64 _mm_sign_pi32 (__m64, __m64);
#line 114 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tmmintrin.h"

    
    extern __m128i _mm_alignr_epi8 (__m128i, __m128i, int);


    extern __m64 _mm_alignr_pi8 (__m64, __m64, int);
#line 123 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tmmintrin.h"

    
    extern __m128i _mm_abs_epi8 (__m128i);
    extern __m128i _mm_abs_epi16 (__m128i);
    extern __m128i _mm_abs_epi32 (__m128i);


    extern __m64 _mm_abs_pi8 (__m64);
    extern __m64 _mm_abs_pi16 (__m64);
    extern __m64 _mm_abs_pi32 (__m64);
#line 136 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tmmintrin.h"


};
#line 140 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tmmintrin.h"

#line 142 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tmmintrin.h"
#line 143 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tmmintrin.h"
#line 144 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\tmmintrin.h"
#line 29 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\smmintrin.h"


extern "C" {
#line 81 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\smmintrin.h"

        
        extern __m128i _mm_blend_epi16 (__m128i, __m128i, const int );
        extern __m128i _mm_blendv_epi8 (__m128i, __m128i, __m128i mask);

        
        extern __m128  _mm_blend_ps (__m128, __m128, const int );
        extern __m128  _mm_blendv_ps(__m128, __m128, __m128 );

        
        extern __m128d _mm_blend_pd (__m128d, __m128d, const int );
        extern __m128d _mm_blendv_pd(__m128d, __m128d, __m128d );

        
        extern __m128  _mm_dp_ps(__m128, __m128, const int );
        extern __m128d _mm_dp_pd(__m128d, __m128d, const int );

        
        extern __m128i _mm_cmpeq_epi64(__m128i, __m128i);

        
        extern __m128i _mm_min_epi8 (__m128i, __m128i);
        extern __m128i _mm_max_epi8 (__m128i, __m128i);

        extern __m128i _mm_min_epu16(__m128i, __m128i);
        extern __m128i _mm_max_epu16(__m128i, __m128i);

        extern __m128i _mm_min_epi32(__m128i, __m128i);
        extern __m128i _mm_max_epi32(__m128i, __m128i);
        extern __m128i _mm_min_epu32(__m128i, __m128i);
        extern __m128i _mm_max_epu32(__m128i, __m128i);

        
        extern __m128i _mm_mullo_epi32(__m128i, __m128i);

        
        extern __m128i _mm_mul_epi32(__m128i, __m128i);

        
        extern int _mm_testz_si128(__m128i , __m128i );

        
        extern int _mm_testc_si128(__m128i , __m128i );

        
        extern int _mm_testnzc_si128(__m128i , __m128i );

        
        extern __m128 _mm_insert_ps(__m128 , __m128 , const int );

        
        extern int _mm_extract_ps(__m128 , const int );

        
        extern __m128i _mm_insert_epi8 (__m128i , int , const int );
        extern __m128i _mm_insert_epi32(__m128i , int , const int );


#line 190 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\smmintrin.h"
        
        
        extern int   _mm_extract_epi8 (__m128i , const int );
        extern int   _mm_extract_epi32(__m128i , const int );


#line 199 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\smmintrin.h"

        
        extern __m128i _mm_minpos_epu16(__m128i);

        
        extern __m128d _mm_round_pd(__m128d , int );
        extern __m128d _mm_round_sd(__m128d , __m128d , int );

        
        extern __m128  _mm_round_ps(__m128  , int );
        extern __m128  _mm_round_ss(__m128 , __m128  , int );

        
        extern __m128i _mm_cvtepi8_epi32 (__m128i);
        extern __m128i _mm_cvtepi16_epi32(__m128i);
        extern __m128i _mm_cvtepi8_epi64 (__m128i);
        extern __m128i _mm_cvtepi32_epi64(__m128i);
        extern __m128i _mm_cvtepi16_epi64(__m128i);
        extern __m128i _mm_cvtepi8_epi16 (__m128i);

        
        extern __m128i _mm_cvtepu8_epi32 (__m128i);
        extern __m128i _mm_cvtepu16_epi32(__m128i);
        extern __m128i _mm_cvtepu8_epi64 (__m128i);
        extern __m128i _mm_cvtepu32_epi64(__m128i);
        extern __m128i _mm_cvtepu16_epi64(__m128i);
        extern __m128i _mm_cvtepu8_epi16 (__m128i);


        extern __m128i _mm_packus_epi32(__m128i, __m128i);

        
        extern __m128i _mm_mpsadbw_epu8(__m128i , __m128i , const int );

        
#line 252 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\smmintrin.h"
        extern __m128i _mm_stream_load_si128(const __m128i*);
#line 254 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\smmintrin.h"


}; 
#line 258 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\smmintrin.h"

#line 260 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\smmintrin.h"
#line 261 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\smmintrin.h"
#line 262 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\smmintrin.h"
#line 29 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\nmmintrin.h"


extern "C" {
#line 34 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\nmmintrin.h"


    extern __m128i _mm_cmpistrm (__m128i , __m128i , const int );
    extern int     _mm_cmpistri (__m128i , __m128i , const int );

    extern __m128i _mm_cmpestrm (__m128i , int , __m128i , int , const int );
    extern int     _mm_cmpestri (__m128i , int , __m128i , int , const int );


    extern int     _mm_cmpistrz (__m128i , __m128i , const int );
    extern int     _mm_cmpistrc (__m128i , __m128i , const int );
    extern int     _mm_cmpistrs (__m128i , __m128i , const int );
    extern int     _mm_cmpistro (__m128i , __m128i , const int );
    extern int     _mm_cmpistra (__m128i , __m128i , const int );

    extern int     _mm_cmpestrz (__m128i , int , __m128i , int , const int );
    extern int     _mm_cmpestrc (__m128i , int , __m128i , int , const int );
    extern int     _mm_cmpestrs (__m128i , int , __m128i , int , const int );
    extern int     _mm_cmpestro (__m128i , int , __m128i , int , const int );
    extern int     _mm_cmpestra (__m128i , int , __m128i , int , const int );


    extern __m128i _mm_cmpgt_epi64(__m128i , __m128i );


    extern int _mm_popcnt_u32(unsigned int );


#line 117 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\nmmintrin.h"


    extern unsigned int _mm_crc32_u8 (unsigned int , unsigned char );
    extern unsigned int _mm_crc32_u16(unsigned int , unsigned short );
    extern unsigned int _mm_crc32_u32(unsigned int , unsigned int );


#line 129 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\nmmintrin.h"


}; 
#line 133 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\nmmintrin.h"

#line 135 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\nmmintrin.h"
#line 136 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\nmmintrin.h"
#line 137 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\nmmintrin.h"
#line 28 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\wmmintrin.h"


extern "C" {
#line 33 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\wmmintrin.h"


extern __m128i _mm_aesdec_si128(__m128i , __m128i );


extern __m128i _mm_aesdeclast_si128(__m128i , __m128i );


extern __m128i _mm_aesenc_si128(__m128i , __m128i );


extern __m128i _mm_aesenclast_si128(__m128i , __m128i );


extern __m128i _mm_aesimc_si128(__m128i );


extern __m128i _mm_aeskeygenassist_si128(__m128i , const int );


extern __m128i _mm_clmulepi64_si128(__m128i , __m128i ,
                                            const int );


}; 
#line 84 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\wmmintrin.h"

#line 86 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\wmmintrin.h"
#line 87 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\wmmintrin.h"
#line 88 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\wmmintrin.h"
#line 27 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"


extern "C" {
#line 31 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"


typedef union __declspec(intrin_type) __declspec(align(32)) __m256 {
    float m256_f32[8];
} __m256;

typedef struct __declspec(intrin_type) __declspec(align(32)) __m256d {
    double m256d_f64[4];
} __m256d;

typedef union  __declspec(intrin_type) __declspec(align(32)) __m256i {
    __int8              m256i_i8[32];
    __int16             m256i_i16[16];
    __int32             m256i_i32[8];
    __int64             m256i_i64[4];
    unsigned __int8     m256i_u8[32];
    unsigned __int16    m256i_u16[16];
    unsigned __int32    m256i_u32[8];
    unsigned __int64    m256i_u64[4];
} __m256i;


extern __m256d __cdecl _mm256_add_pd(__m256d, __m256d);


extern __m256 __cdecl _mm256_add_ps(__m256, __m256);


extern __m256d __cdecl _mm256_addsub_pd(__m256d, __m256d);


extern __m256 __cdecl _mm256_addsub_ps(__m256, __m256);


extern __m256d __cdecl _mm256_and_pd(__m256d, __m256d);


extern __m256 __cdecl _mm256_and_ps(__m256, __m256);


extern __m256d __cdecl _mm256_andnot_pd(__m256d, __m256d);


extern __m256 __cdecl _mm256_andnot_ps(__m256, __m256);


extern __m256d __cdecl _mm256_blend_pd(__m256d, __m256d, const int);


extern __m256 __cdecl _mm256_blend_ps(__m256, __m256, const int);


extern __m256d __cdecl _mm256_blendv_pd(__m256d, __m256d, __m256d);


extern __m256 __cdecl _mm256_blendv_ps(__m256, __m256, __m256);


extern __m256d __cdecl _mm256_div_pd(__m256d, __m256d);


extern __m256 __cdecl _mm256_div_ps(__m256, __m256);


extern __m256 __cdecl _mm256_dp_ps(__m256, __m256, const int);


extern __m256d __cdecl _mm256_hadd_pd(__m256d, __m256d);


extern __m256 __cdecl _mm256_hadd_ps(__m256, __m256);


extern __m256d __cdecl _mm256_hsub_pd(__m256d, __m256d);


extern __m256 __cdecl _mm256_hsub_ps(__m256, __m256);


extern __m256d __cdecl _mm256_max_pd(__m256d, __m256d);


extern __m256 __cdecl _mm256_max_ps(__m256, __m256);


extern __m256d __cdecl _mm256_min_pd(__m256d, __m256d);


extern __m256 __cdecl _mm256_min_ps(__m256, __m256);


extern __m256d __cdecl _mm256_mul_pd(__m256d, __m256d);


extern __m256 __cdecl _mm256_mul_ps(__m256, __m256);


extern __m256d __cdecl _mm256_or_pd(__m256d, __m256d);


extern __m256 __cdecl _mm256_or_ps(__m256, __m256);


extern __m256d __cdecl _mm256_shuffle_pd(__m256d, __m256d, const int);


extern __m256 __cdecl _mm256_shuffle_ps(__m256, __m256, const int);


extern __m256d __cdecl _mm256_sub_pd(__m256d, __m256d);


extern __m256 __cdecl _mm256_sub_ps(__m256, __m256);


extern __m256d __cdecl _mm256_xor_pd(__m256d, __m256d);


extern __m256 __cdecl _mm256_xor_ps(__m256, __m256);


extern __m128d __cdecl _mm_cmp_pd(__m128d, __m128d, const int);
extern __m256d __cdecl _mm256_cmp_pd(__m256d, __m256d, const int);


extern __m128 __cdecl _mm_cmp_ps(__m128, __m128, const int);
extern __m256 __cdecl _mm256_cmp_ps(__m256, __m256, const int);


extern __m128d __cdecl _mm_cmp_sd(__m128d, __m128d, const int);


extern int __cdecl _mm_comi_sd(__m128d, __m128d, const int);


extern __m128 __cdecl _mm_cmp_ss(__m128, __m128, const int);


extern int __cdecl _mm_comi_ss(__m128, __m128, const int);


extern __m256d __cdecl _mm256_cvtepi32_pd(__m128i);


extern __m256  __cdecl _mm256_cvtepi32_ps(__m256i);


extern __m128  __cdecl _mm256_cvtpd_ps(__m256d);


extern __m256i __cdecl _mm256_cvtps_epi32(__m256);


extern __m256d __cdecl _mm256_cvtps_pd(__m128);


extern __m128i __cdecl _mm256_cvttpd_epi32(__m256d);


extern __m128i __cdecl _mm256_cvtpd_epi32(__m256d);


extern __m256i __cdecl _mm256_cvttps_epi32(__m256);


#line 612 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"


extern __m128  __cdecl _mm256_extractf128_ps(__m256, const int);
extern __m128d __cdecl _mm256_extractf128_pd(__m256d, const int);
extern __m128i __cdecl _mm256_extractf128_si256(__m256i, const int);


extern void __cdecl _mm256_zeroall(void);


extern void __cdecl _mm256_zeroupper(void);


extern __m256  __cdecl _mm256_permutevar_ps(__m256, __m256i);
extern __m128  __cdecl _mm_permutevar_ps(__m128, __m128i);


extern __m256  __cdecl _mm256_permute_ps(__m256, int);
extern __m128  __cdecl _mm_permute_ps(__m128, int);


extern __m256d __cdecl _mm256_permutevar_pd(__m256d, __m256i);
extern __m128d __cdecl _mm_permutevar_pd(__m128d, __m128i);


extern __m256d __cdecl _mm256_permute_pd(__m256d, int);
extern __m128d __cdecl _mm_permute_pd(__m128d, int);


extern __m256  __cdecl _mm256_permute2f128_ps(__m256, __m256, int);
extern __m256d __cdecl _mm256_permute2f128_pd(__m256d, __m256d, int);
extern __m256i __cdecl _mm256_permute2f128_si256(__m256i, __m256i, int);


extern __m256  __cdecl _mm256_broadcast_ss(float const *);
extern __m128  __cdecl _mm_broadcast_ss(float const *);


extern __m256d __cdecl _mm256_broadcast_sd(double const *);


extern __m256  __cdecl _mm256_broadcast_ps(__m128 const *);
extern __m256d __cdecl _mm256_broadcast_pd(__m128d const *);


extern __m256  __cdecl _mm256_insertf128_ps(__m256, __m128, int);
extern __m256d __cdecl _mm256_insertf128_pd(__m256d, __m128d, int);
extern __m256i __cdecl _mm256_insertf128_si256(__m256i, __m128i, int);


extern __m256d __cdecl _mm256_load_pd(double const *);
extern void    __cdecl _mm256_store_pd(double *, __m256d);


extern __m256  __cdecl _mm256_load_ps(float const *);
extern void    __cdecl _mm256_store_ps(float *, __m256);


extern __m256d __cdecl _mm256_loadu_pd(double const *);
extern void    __cdecl _mm256_storeu_pd(double *, __m256d);


extern __m256  __cdecl _mm256_loadu_ps(float const *);
extern void    __cdecl _mm256_storeu_ps(float *, __m256);


extern __m256i __cdecl _mm256_load_si256(__m256i const *);
extern void    __cdecl _mm256_store_si256(__m256i *, __m256i);


extern __m256i __cdecl _mm256_loadu_si256(__m256i const *);
extern void    __cdecl _mm256_storeu_si256(__m256i *, __m256i);


extern __m256d __cdecl _mm256_maskload_pd(double const *, __m256i);
extern void    __cdecl _mm256_maskstore_pd(double *, __m256i, __m256d);
extern __m128d __cdecl _mm_maskload_pd(double const *, __m128i);
extern void    __cdecl _mm_maskstore_pd(double *, __m128i, __m128d);


extern __m256  __cdecl _mm256_maskload_ps(float const *, __m256i);
extern void    __cdecl _mm256_maskstore_ps(float *, __m256i, __m256);
extern __m128  __cdecl _mm_maskload_ps(float const *, __m128i);
extern void    __cdecl _mm_maskstore_ps(float *, __m128i, __m128);


extern __m256  __cdecl _mm256_movehdup_ps(__m256);


extern __m256  __cdecl _mm256_moveldup_ps(__m256);


extern __m256d __cdecl _mm256_movedup_pd(__m256d);


extern __m256i __cdecl _mm256_lddqu_si256(__m256i const *);


extern void    __cdecl _mm256_stream_si256(__m256i *, __m256i);


extern void    __cdecl _mm256_stream_pd(double *, __m256d);


extern void    __cdecl _mm256_stream_ps(float *, __m256);


extern __m256  __cdecl _mm256_rcp_ps(__m256);


extern __m256  __cdecl _mm256_rsqrt_ps(__m256);


extern __m256d __cdecl _mm256_sqrt_pd(__m256d);


extern __m256  __cdecl _mm256_sqrt_ps(__m256);


extern __m256d __cdecl _mm256_round_pd(__m256d, int);


extern __m256  __cdecl _mm256_round_ps(__m256, int);


extern __m256d __cdecl _mm256_unpackhi_pd(__m256d, __m256d);


extern __m256  __cdecl _mm256_unpackhi_ps(__m256, __m256);


extern __m256d __cdecl _mm256_unpacklo_pd(__m256d, __m256d);


extern __m256  __cdecl _mm256_unpacklo_ps(__m256, __m256);


extern int     __cdecl _mm256_testz_si256(__m256i, __m256i);


extern int     __cdecl _mm256_testc_si256(__m256i, __m256i);


extern int     __cdecl _mm256_testnzc_si256(__m256i, __m256i);


extern int     __cdecl _mm256_testz_pd(__m256d, __m256d);
extern int     __cdecl _mm256_testc_pd(__m256d, __m256d);
extern int     __cdecl _mm256_testnzc_pd(__m256d, __m256d);
extern int     __cdecl _mm_testz_pd(__m128d, __m128d);
extern int     __cdecl _mm_testc_pd(__m128d, __m128d);
extern int     __cdecl _mm_testnzc_pd(__m128d, __m128d);


extern int     __cdecl _mm256_testz_ps(__m256, __m256);
extern int     __cdecl _mm256_testc_ps(__m256, __m256);
extern int     __cdecl _mm256_testnzc_ps(__m256, __m256);
extern int     __cdecl _mm_testz_ps(__m128, __m128);
extern int     __cdecl _mm_testc_ps(__m128, __m128);
extern int     __cdecl _mm_testnzc_ps(__m128, __m128);


extern int     __cdecl _mm256_movemask_pd(__m256d);


extern int     __cdecl _mm256_movemask_ps(__m256);


extern __m256d __cdecl _mm256_setzero_pd(void);
extern __m256  __cdecl _mm256_setzero_ps(void);
extern __m256i __cdecl _mm256_setzero_si256(void);


extern __m256d __cdecl _mm256_set_pd(double, double, double, double);
extern __m256  __cdecl _mm256_set_ps(float, float, float, float,
                                            float, float, float, float);
extern __m256i __cdecl _mm256_set_epi8(char, char, char, char,
                                              char, char, char, char,
                                              char, char, char, char,
                                              char, char, char, char,
                                              char, char, char, char,
                                              char, char, char, char,
                                              char, char, char, char,
                                              char, char, char, char);
extern __m256i __cdecl _mm256_set_epi16(short, short, short, short,
                                               short, short, short, short,
                                               short, short, short, short,
                                               short, short, short, short);
extern __m256i __cdecl _mm256_set_epi32(int, int, int, int,
                                               int, int, int, int);
extern __m256i __cdecl _mm256_set_epi64x(__int64, __int64,
                                                __int64, __int64);


extern __m256d __cdecl _mm256_setr_pd(double, double, double, double);
extern __m256  __cdecl _mm256_setr_ps(float, float, float, float,
                                             float, float, float, float);
extern __m256i __cdecl _mm256_setr_epi8(char, char, char, char,
                                               char, char, char, char,
                                               char, char, char, char,
                                               char, char, char, char,
                                               char, char, char, char,
                                               char, char, char, char,
                                               char, char, char, char,
                                               char, char, char, char);
extern __m256i __cdecl _mm256_setr_epi16(short, short, short, short,
                                                short, short, short, short,
                                                short, short, short, short,
                                                short, short, short, short);
extern __m256i __cdecl _mm256_setr_epi32(int, int, int, int,
                                                int, int, int, int);
extern __m256i __cdecl _mm256_setr_epi64x(__int64, __int64,
                                                 __int64, __int64);


extern __m256d __cdecl _mm256_set1_pd(double);
extern __m256  __cdecl _mm256_set1_ps(float);
extern __m256i __cdecl _mm256_set1_epi8(char);
extern __m256i __cdecl _mm256_set1_epi16(short);
extern __m256i __cdecl _mm256_set1_epi32(int);
extern __m256i __cdecl _mm256_set1_epi64x(long long);


extern __m256  __cdecl _mm256_castpd_ps(__m256d);
extern __m256d __cdecl _mm256_castps_pd(__m256);
extern __m256i __cdecl _mm256_castps_si256(__m256);
extern __m256i __cdecl _mm256_castpd_si256(__m256d);
extern __m256  __cdecl _mm256_castsi256_ps(__m256i);
extern __m256d __cdecl _mm256_castsi256_pd(__m256i);
extern __m128  __cdecl _mm256_castps256_ps128(__m256);
extern __m128d __cdecl _mm256_castpd256_pd128(__m256d);
extern __m128i __cdecl _mm256_castsi256_si128(__m256i);
extern __m256  __cdecl _mm256_castps128_ps256(__m128);
extern __m256d __cdecl _mm256_castpd128_pd256(__m128d);
extern __m256i __cdecl _mm256_castsi128_si256(__m128i);


extern __m128  __cdecl _mm_cvtph_ps(__m128i);
extern __m256  __cdecl _mm256_cvtph_ps(__m128i);
extern __m128i __cdecl _mm_cvtps_ph(__m128 , const int );
extern __m128i __cdecl _mm256_cvtps_ph(__m256, int);


extern unsigned __int64 __cdecl _xgetbv(unsigned int);


extern void __cdecl _xsetbv(unsigned int, unsigned __int64);


extern void __cdecl _xsave(void *, unsigned __int64);


#line 1260 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"


extern void __cdecl _xsaveopt(void *, unsigned __int64);


#line 1270 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"


extern void __cdecl _xsavec(void *, unsigned __int64);


#line 1279 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"


extern void __cdecl _xrstor(void const *, unsigned __int64);


#line 1289 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"


extern void __cdecl _xsaves(void *, unsigned __int64);


#line 1299 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"


extern void __cdecl _xrstors(void const *, unsigned __int64);


#line 1309 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"


extern void __cdecl _fxsave(void *);


#line 1318 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"


extern void __cdecl _fxrstor(void const *);


#line 1327 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"


extern int __cdecl _rdrand16_step(unsigned short *);
extern int __cdecl _rdrand32_step(unsigned int *);


#line 1339 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"


#line 1357 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"


extern __m128  __cdecl _mm_fmadd_ps(__m128, __m128, __m128);
extern __m128d __cdecl _mm_fmadd_pd(__m128d, __m128d, __m128d);
extern __m128  __cdecl _mm_fmadd_ss(__m128, __m128, __m128);
extern __m128d __cdecl _mm_fmadd_sd(__m128d, __m128d, __m128d);
extern __m128  __cdecl _mm_fmsub_ps(__m128, __m128, __m128);
extern __m128d __cdecl _mm_fmsub_pd(__m128d, __m128d, __m128d);
extern __m128  __cdecl _mm_fmsub_ss(__m128, __m128, __m128);
extern __m128d __cdecl _mm_fmsub_sd(__m128d, __m128d, __m128d);
extern __m128  __cdecl _mm_fnmadd_ps(__m128, __m128, __m128);
extern __m128d __cdecl _mm_fnmadd_pd(__m128d, __m128d, __m128d);
extern __m128  __cdecl _mm_fnmadd_ss(__m128, __m128, __m128);
extern __m128d __cdecl _mm_fnmadd_sd(__m128d, __m128d, __m128d);
extern __m128  __cdecl _mm_fnmsub_ps(__m128, __m128, __m128);
extern __m128d __cdecl _mm_fnmsub_pd(__m128d, __m128d, __m128d);
extern __m128  __cdecl _mm_fnmsub_ss(__m128, __m128, __m128);
extern __m128d __cdecl _mm_fnmsub_sd(__m128d, __m128d, __m128d);

extern __m256  __cdecl _mm256_fmadd_ps(__m256, __m256, __m256);
extern __m256d __cdecl _mm256_fmadd_pd(__m256d, __m256d, __m256d);
extern __m256  __cdecl _mm256_fmsub_ps(__m256, __m256, __m256);
extern __m256d __cdecl _mm256_fmsub_pd(__m256d, __m256d, __m256d);
extern __m256  __cdecl _mm256_fnmadd_ps(__m256, __m256, __m256);
extern __m256d __cdecl _mm256_fnmadd_pd(__m256d, __m256d, __m256d);
extern __m256  __cdecl _mm256_fnmsub_ps(__m256, __m256, __m256);
extern __m256d __cdecl _mm256_fnmsub_pd(__m256d, __m256d, __m256d);


extern __m128  __cdecl _mm_fmaddsub_ps(__m128, __m128, __m128);
extern __m128d __cdecl _mm_fmaddsub_pd(__m128d, __m128d, __m128d);
extern __m128  __cdecl _mm_fmsubadd_ps(__m128, __m128, __m128);
extern __m128d __cdecl _mm_fmsubadd_pd(__m128d, __m128d, __m128d);

extern __m256  __cdecl _mm256_fmaddsub_ps(__m256, __m256, __m256);
extern __m256d __cdecl _mm256_fmaddsub_pd(__m256d, __m256d, __m256d);
extern __m256  __cdecl _mm256_fmsubadd_ps(__m256, __m256, __m256);
extern __m256d __cdecl _mm256_fmsubadd_pd(__m256d, __m256d, __m256d);


extern __m256i __cdecl _mm256_cmpeq_epi8(__m256i, __m256i);
extern __m256i __cdecl _mm256_cmpeq_epi16(__m256i, __m256i);
extern __m256i __cdecl _mm256_cmpeq_epi32(__m256i, __m256i);
extern __m256i __cdecl _mm256_cmpeq_epi64(__m256i, __m256i);

extern __m256i __cdecl _mm256_cmpgt_epi8(__m256i, __m256i);
extern __m256i __cdecl _mm256_cmpgt_epi16(__m256i, __m256i);
extern __m256i __cdecl _mm256_cmpgt_epi32(__m256i, __m256i);
extern __m256i __cdecl _mm256_cmpgt_epi64(__m256i, __m256i);


extern __m256i __cdecl _mm256_max_epi8(__m256i, __m256i);
extern __m256i __cdecl _mm256_max_epi16(__m256i, __m256i);
extern __m256i __cdecl _mm256_max_epi32(__m256i, __m256i);
extern __m256i __cdecl _mm256_max_epu8(__m256i, __m256i);
extern __m256i __cdecl _mm256_max_epu16(__m256i, __m256i);
extern __m256i __cdecl _mm256_max_epu32(__m256i, __m256i);

extern __m256i __cdecl _mm256_min_epi8(__m256i, __m256i);
extern __m256i __cdecl _mm256_min_epi16(__m256i, __m256i);
extern __m256i __cdecl _mm256_min_epi32(__m256i, __m256i);
extern __m256i __cdecl _mm256_min_epu8(__m256i, __m256i);
extern __m256i __cdecl _mm256_min_epu16(__m256i, __m256i);
extern __m256i __cdecl _mm256_min_epu32(__m256i, __m256i);


extern __m256i __cdecl _mm256_and_si256(__m256i, __m256i);
extern __m256i __cdecl _mm256_andnot_si256(__m256i, __m256i);
extern __m256i __cdecl _mm256_or_si256(__m256i, __m256i);
extern __m256i __cdecl _mm256_xor_si256(__m256i, __m256i);


extern __m256i __cdecl _mm256_abs_epi8(__m256i);
extern __m256i __cdecl _mm256_abs_epi16(__m256i);
extern __m256i __cdecl _mm256_abs_epi32(__m256i);

extern __m256i __cdecl _mm256_add_epi8(__m256i, __m256i);
extern __m256i __cdecl _mm256_add_epi16(__m256i, __m256i);
extern __m256i __cdecl _mm256_add_epi32(__m256i, __m256i);
extern __m256i __cdecl _mm256_add_epi64(__m256i, __m256i);

extern __m256i __cdecl _mm256_adds_epi8(__m256i, __m256i);
extern __m256i __cdecl _mm256_adds_epi16(__m256i, __m256i);
extern __m256i __cdecl _mm256_adds_epu8(__m256i, __m256i);
extern __m256i __cdecl _mm256_adds_epu16(__m256i, __m256i);

extern __m256i __cdecl _mm256_sub_epi8(__m256i, __m256i);
extern __m256i __cdecl _mm256_sub_epi16(__m256i, __m256i);
extern __m256i __cdecl _mm256_sub_epi32(__m256i, __m256i);
extern __m256i __cdecl _mm256_sub_epi64(__m256i, __m256i);

extern __m256i __cdecl _mm256_subs_epi8(__m256i, __m256i);
extern __m256i __cdecl _mm256_subs_epi16(__m256i, __m256i);
extern __m256i __cdecl _mm256_subs_epu8(__m256i, __m256i);
extern __m256i __cdecl _mm256_subs_epu16(__m256i, __m256i);

extern __m256i __cdecl _mm256_avg_epu8(__m256i, __m256i);
extern __m256i __cdecl _mm256_avg_epu16(__m256i, __m256i);

extern __m256i __cdecl _mm256_hadd_epi16(__m256i, __m256i);
extern __m256i __cdecl _mm256_hadd_epi32(__m256i, __m256i);
extern __m256i __cdecl _mm256_hadds_epi16(__m256i, __m256i);

extern __m256i __cdecl _mm256_hsub_epi16(__m256i, __m256i);
extern __m256i __cdecl _mm256_hsub_epi32(__m256i, __m256i);
extern __m256i __cdecl _mm256_hsubs_epi16(__m256i, __m256i);

extern __m256i __cdecl _mm256_madd_epi16(__m256i, __m256i);
extern __m256i __cdecl _mm256_maddubs_epi16(__m256i, __m256i);

extern __m256i __cdecl _mm256_mulhi_epi16(__m256i, __m256i);
extern __m256i __cdecl _mm256_mulhi_epu16(__m256i, __m256i);

extern __m256i __cdecl _mm256_mullo_epi16(__m256i, __m256i);
extern __m256i __cdecl _mm256_mullo_epi32(__m256i, __m256i);

extern __m256i __cdecl _mm256_mul_epu32(__m256i, __m256i);
extern __m256i __cdecl _mm256_mul_epi32(__m256i, __m256i);

extern __m256i __cdecl _mm256_sign_epi8(__m256i, __m256i);
extern __m256i __cdecl _mm256_sign_epi16(__m256i, __m256i);
extern __m256i __cdecl _mm256_sign_epi32(__m256i, __m256i);

extern __m256i __cdecl _mm256_mulhrs_epi16(__m256i, __m256i);

extern __m256i __cdecl _mm256_sad_epu8(__m256i, __m256i);
extern __m256i __cdecl _mm256_mpsadbw_epu8(__m256i, __m256i, const int);


extern __m256i __cdecl _mm256_slli_si256(__m256i, const int);

extern __m256i __cdecl _mm256_srli_si256(__m256i, const int);


extern __m256i __cdecl _mm256_sll_epi16(__m256i, __m128i);
extern __m256i __cdecl _mm256_sll_epi32(__m256i, __m128i);
extern __m256i __cdecl _mm256_sll_epi64(__m256i, __m128i);

extern __m256i __cdecl _mm256_slli_epi16(__m256i, int);
extern __m256i __cdecl _mm256_slli_epi32(__m256i, int);
extern __m256i __cdecl _mm256_slli_epi64(__m256i, int);

extern __m256i __cdecl _mm256_sllv_epi32(__m256i, __m256i);
extern __m256i __cdecl _mm256_sllv_epi64(__m256i, __m256i);

extern __m128i __cdecl _mm_sllv_epi32(__m128i, __m128i);
extern __m128i __cdecl _mm_sllv_epi64(__m128i, __m128i);

extern __m256i __cdecl _mm256_sra_epi16(__m256i, __m128i);
extern __m256i __cdecl _mm256_sra_epi32(__m256i, __m128i);

extern __m256i __cdecl _mm256_srai_epi16(__m256i, int);
extern __m256i __cdecl _mm256_srai_epi32(__m256i, int);

extern __m256i __cdecl _mm256_srav_epi32(__m256i, __m256i);

extern __m128i __cdecl _mm_srav_epi32(__m128i, __m128i);

extern __m256i __cdecl _mm256_srl_epi16(__m256i, __m128i);
extern __m256i __cdecl _mm256_srl_epi32(__m256i, __m128i);
extern __m256i __cdecl _mm256_srl_epi64(__m256i, __m128i);

extern __m256i __cdecl _mm256_srli_epi16(__m256i, int);
extern __m256i __cdecl _mm256_srli_epi32(__m256i, int);
extern __m256i __cdecl _mm256_srli_epi64(__m256i, int);

extern __m256i __cdecl _mm256_srlv_epi32(__m256i, __m256i);
extern __m256i __cdecl _mm256_srlv_epi64(__m256i, __m256i);

extern __m128i __cdecl _mm_srlv_epi32(__m128i, __m128i);
extern __m128i __cdecl _mm_srlv_epi64(__m128i, __m128i);


extern __m128i __cdecl _mm_blend_epi32(__m128i, __m128i, const int);

extern __m256i __cdecl _mm256_blend_epi32(__m256i,__m256i, const int);

extern __m256i __cdecl _mm256_alignr_epi8(__m256i, __m256i, const int);

extern __m256i __cdecl _mm256_blendv_epi8(__m256i, __m256i, __m256i);
extern __m256i __cdecl _mm256_blend_epi16(__m256i, __m256i, const int);

extern __m256i __cdecl _mm256_packs_epi16(__m256i, __m256i);
extern __m256i __cdecl _mm256_packs_epi32(__m256i, __m256i);
extern __m256i __cdecl _mm256_packus_epi16(__m256i, __m256i);
extern __m256i __cdecl _mm256_packus_epi32(__m256i, __m256i);

extern __m256i __cdecl _mm256_unpackhi_epi8(__m256i, __m256i);
extern __m256i __cdecl _mm256_unpackhi_epi16(__m256i, __m256i);
extern __m256i __cdecl _mm256_unpackhi_epi32(__m256i, __m256i);
extern __m256i __cdecl _mm256_unpackhi_epi64(__m256i, __m256i);

extern __m256i __cdecl _mm256_unpacklo_epi8(__m256i, __m256i);
extern __m256i __cdecl _mm256_unpacklo_epi16(__m256i, __m256i);
extern __m256i __cdecl _mm256_unpacklo_epi32(__m256i, __m256i);
extern __m256i __cdecl _mm256_unpacklo_epi64(__m256i, __m256i);

extern __m256i __cdecl _mm256_shuffle_epi8(__m256i, __m256i);
extern __m256i __cdecl _mm256_shuffle_epi32(__m256i, const int);

extern __m256i __cdecl _mm256_shufflehi_epi16(__m256i, const int);
extern __m256i __cdecl _mm256_shufflelo_epi16(__m256i, const int);

extern __m128i __cdecl _mm256_extracti128_si256(__m256i, const int);
extern __m256i __cdecl _mm256_inserti128_si256(__m256i, __m128i, const int);


extern __m128  __cdecl _mm_broadcastss_ps(__m128);
extern __m128d __cdecl _mm_broadcastsd_pd(__m128d);

extern __m128i __cdecl _mm_broadcastb_epi8(__m128i);
extern __m128i __cdecl _mm_broadcastw_epi16(__m128i);
extern __m128i __cdecl _mm_broadcastd_epi32(__m128i);
extern __m128i __cdecl _mm_broadcastq_epi64(__m128i);

extern __m256  __cdecl _mm256_broadcastss_ps(__m128);
extern __m256d __cdecl _mm256_broadcastsd_pd(__m128d);

extern __m256i __cdecl _mm256_broadcastb_epi8(__m128i);
extern __m256i __cdecl _mm256_broadcastw_epi16(__m128i);
extern __m256i __cdecl _mm256_broadcastd_epi32(__m128i);
extern __m256i __cdecl _mm256_broadcastq_epi64(__m128i);

extern __m256i __cdecl _mm256_broadcastsi128_si256(__m128i);


extern __m256i __cdecl _mm256_cvtepi8_epi16(__m128i);
extern __m256i __cdecl _mm256_cvtepi8_epi32(__m128i);
extern __m256i __cdecl _mm256_cvtepi8_epi64(__m128i);
extern __m256i __cdecl _mm256_cvtepi16_epi32(__m128i);
extern __m256i __cdecl _mm256_cvtepi16_epi64(__m128i);
extern __m256i __cdecl _mm256_cvtepi32_epi64(__m128i);

extern __m256i __cdecl _mm256_cvtepu8_epi16(__m128i);
extern __m256i __cdecl _mm256_cvtepu8_epi32(__m128i);
extern __m256i __cdecl _mm256_cvtepu8_epi64(__m128i);
extern __m256i __cdecl _mm256_cvtepu16_epi32(__m128i);
extern __m256i __cdecl _mm256_cvtepu16_epi64(__m128i);
extern __m256i __cdecl _mm256_cvtepu32_epi64(__m128i);


extern int __cdecl _mm256_movemask_epi8(__m256i);


extern __m128i __cdecl _mm_maskload_epi32(int const * ,
                                          __m128i     );
extern __m128i __cdecl _mm_maskload_epi64(__int64 const * ,
                                          __m128i         );

extern void __cdecl _mm_maskstore_epi32(int *   ,
                                        __m128i ,
                                        __m128i );
extern void __cdecl _mm_maskstore_epi64(__int64 * ,
                                        __m128i   ,
                                        __m128i   );

extern __m256i __cdecl _mm256_maskload_epi32(int const * ,
                                             __m256i     );
extern __m256i __cdecl _mm256_maskload_epi64(__int64 const * ,
                                             __m256i         );

extern void __cdecl _mm256_maskstore_epi32(int *   ,
                                           __m256i ,
                                           __m256i );
extern void __cdecl _mm256_maskstore_epi64(__int64 * ,
                                           __m256i   ,
                                           __m256i   );


extern __m256i __cdecl _mm256_permutevar8x32_epi32(__m256i, __m256i);
extern __m256  __cdecl _mm256_permutevar8x32_ps(__m256, __m256i);

extern __m256i __cdecl _mm256_permute4x64_epi64(__m256i, const int);
extern __m256d __cdecl _mm256_permute4x64_pd(__m256d, const int);

extern __m256i __cdecl _mm256_permute2x128_si256(__m256i, __m256i, const int);


extern __m256i  __cdecl _mm256_stream_load_si256(__m256i const *);


extern __m256d __cdecl _mm256_mask_i32gather_pd(__m256d        ,
                                                double const * ,
                                                __m128i        ,
                                                __m256d        ,
                                                const int      );
extern __m256  __cdecl _mm256_mask_i32gather_ps(__m256         ,
                                                float const *  ,
                                                __m256i        ,
                                                __m256         ,
                                                const int      );
extern __m256d __cdecl _mm256_mask_i64gather_pd(__m256d        ,
                                                double const * ,
                                                __m256i        ,
                                                __m256d        ,
                                                const int      );
extern __m128  __cdecl _mm256_mask_i64gather_ps(__m128         ,
                                                float const *  ,
                                                __m256i        ,
                                                __m128         ,
                                                const int      );

extern __m128d __cdecl _mm_mask_i32gather_pd(__m128d        ,
                                             double const * ,
                                             __m128i        ,
                                             __m128d        ,
                                             const int      );
extern __m128  __cdecl _mm_mask_i32gather_ps(__m128         ,
                                             float const *  ,
                                             __m128i        ,
                                             __m128         ,
                                             const int      );
extern __m128d __cdecl _mm_mask_i64gather_pd(__m128d        ,
                                             double const * ,
                                             __m128i        ,
                                             __m128d        ,
                                             const int      );
extern __m128  __cdecl _mm_mask_i64gather_ps(__m128         ,
                                             float const *  ,
                                             __m128i        ,
                                             __m128         ,
                                             const int      );


extern __m256i __cdecl _mm256_mask_i32gather_epi32(__m256i     ,
                                                   int const * ,
                                                   __m256i     ,
                                                   __m256i     ,
                                                   const int   );
extern __m256i __cdecl _mm256_mask_i32gather_epi64(__m256i     ,
                                                   __int64 const * ,
                                                   __m128i     ,
                                                   __m256i     ,
                                                   const int   );
extern __m128i __cdecl _mm256_mask_i64gather_epi32(__m128i     ,
                                                   int     const * ,
                                                   __m256i     ,
                                                   __m128i     ,
                                                   const int   );
extern __m256i __cdecl _mm256_mask_i64gather_epi64(__m256i     ,
                                                   __int64 const * ,
                                                   __m256i     ,
                                                   __m256i     ,
                                                   const int   );

extern __m128i __cdecl _mm_mask_i32gather_epi32(__m128i         ,
                                                int const *     ,
                                                __m128i         ,
                                                __m128i         ,
                                                const int       );
extern __m128i __cdecl _mm_mask_i32gather_epi64(__m128i         ,
                                                __int64 const * ,
                                                __m128i         ,
                                                __m128i         ,
                                                const int       );
extern __m128i __cdecl _mm_mask_i64gather_epi32(__m128i         ,
                                                int     const * ,
                                                __m128i         ,
                                                __m128i         ,
                                                const int       );
extern __m128i __cdecl _mm_mask_i64gather_epi64(__m128i         ,
                                                __int64 const * ,
                                                __m128i         ,
                                                __m128i         ,
                                                const int       );


extern __m256d __cdecl _mm256_i32gather_pd(double const * ,
                                           __m128i        ,
                                           const int      );
extern __m256  __cdecl _mm256_i32gather_ps(float  const * ,
                                           __m256i        ,
                                           const int      );
extern __m256d __cdecl _mm256_i64gather_pd(double const * ,
                                           __m256i        ,
                                           const int      );
extern __m128  __cdecl _mm256_i64gather_ps(float  const * ,
                                           __m256i        ,
                                           const int      );

extern __m128d __cdecl _mm_i32gather_pd(double const * ,
                                        __m128i        ,
                                        const int      );
extern __m128  __cdecl _mm_i32gather_ps(float  const * ,
                                        __m128i        ,
                                        const int      );
extern __m128d __cdecl _mm_i64gather_pd(double const * ,
                                        __m128i        ,
                                        const int      );
extern __m128  __cdecl _mm_i64gather_ps(float  const * ,
                                        __m128i        ,
                                        const int      );

extern __m256i __cdecl _mm256_i32gather_epi32(int const *     ,
                                              __m256i         ,
                                              const int       );
extern __m256i __cdecl _mm256_i32gather_epi64(__int64 const * ,
                                              __m128i         ,
                                              const int       );
extern __m128i __cdecl _mm256_i64gather_epi32(int const *     ,
                                              __m256i         ,
                                              const int       );
extern __m256i __cdecl _mm256_i64gather_epi64(__int64 const * ,
                                              __m256i         ,
                                              const int       );

extern __m128i __cdecl _mm_i32gather_epi32(int const *     ,
                                           __m128i         ,
                                           const int       );
extern __m128i __cdecl _mm_i32gather_epi64(__int64 const * ,
                                           __m128i         ,
                                           const int       );
extern __m128i __cdecl _mm_i64gather_epi32(int     const * ,
                                           __m128i         ,
                                           const int       );
extern __m128i __cdecl _mm_i64gather_epi64(__int64 const * ,
                                           __m128i         ,
                                           const int       );


extern unsigned int     _bextr_u32(unsigned int ,
                                   unsigned int ,
                                   unsigned int );
extern unsigned int     _bextr2_u32(unsigned int ,
                                    unsigned int );
extern unsigned int     _blsi_u32(unsigned int);
extern unsigned int     _blsmsk_u32(unsigned int);
extern unsigned int     _blsr_u32(unsigned int);
extern unsigned int     _bzhi_u32(unsigned int ,
                                  unsigned int );
extern unsigned int     _mulx_u32(unsigned int ,
                                  unsigned int ,
                                  unsigned int * );
extern unsigned int     _pdep_u32(unsigned int ,
                                  unsigned int );
extern unsigned int     _pext_u32(unsigned int ,
                                  unsigned int );
extern unsigned int     _rorx_u32(unsigned int ,
                                  const unsigned int );
extern int              _sarx_i32(int ,
                                  unsigned int );
extern unsigned int     _shlx_u32(unsigned int ,
                                  unsigned int );
extern unsigned int     _shrx_u32(unsigned int ,
                                          unsigned int );


#line 1894 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"


extern unsigned int     _lzcnt_u32(unsigned int);


#line 1906 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"


extern unsigned int     _tzcnt_u32(unsigned int);


#line 1918 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"


extern void __cdecl _invpcid(unsigned int , void * );


extern void _Store_HLERelease(long volatile *,long);
extern void _StorePointer_HLERelease(void * volatile *,void *);

extern long _InterlockedExchange_HLEAcquire(long volatile *,long);
extern long _InterlockedExchange_HLERelease(long volatile *,long);
extern void * _InterlockedExchangePointer_HLEAcquire(void *volatile *,void *);
extern void * _InterlockedExchangePointer_HLERelease(void *volatile *,void *);

extern long _InterlockedCompareExchange_HLEAcquire(long volatile *,long,long);
extern long _InterlockedCompareExchange_HLERelease(long volatile *,long,long);
extern __int64 _InterlockedCompareExchange64_HLEAcquire(__int64 volatile *,__int64,__int64);
extern __int64 _InterlockedCompareExchange64_HLERelease(__int64 volatile *,__int64,__int64);
extern void * _InterlockedCompareExchangePointer_HLEAcquire(void *volatile *,void *,void *);
extern void * _InterlockedCompareExchangePointer_HLERelease(void *volatile *,void *,void *);

extern long _InterlockedExchangeAdd_HLEAcquire(long volatile *,long);
extern long _InterlockedExchangeAdd_HLERelease(long volatile *,long);

extern long _InterlockedAnd_HLEAcquire(long volatile *,long);
extern long _InterlockedAnd_HLERelease(long volatile *,long);
extern long _InterlockedOr_HLEAcquire(long volatile *,long);
extern long _InterlockedOr_HLERelease(long volatile *,long);
extern long _InterlockedXor_HLEAcquire(long volatile *,long);
extern long _InterlockedXor_HLERelease(long volatile *,long);

extern unsigned char _interlockedbittestandset_HLEAcquire(long *,long);
extern unsigned char _interlockedbittestandset_HLERelease(long *,long);
extern unsigned char _interlockedbittestandreset_HLEAcquire(long *,long);
extern unsigned char _interlockedbittestandreset_HLERelease(long *,long);


#line 1977 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"


extern unsigned int     __cdecl _xbegin(void);
extern void             __cdecl _xend(void);
extern void             __cdecl _xabort(const unsigned int);
extern unsigned char    __cdecl _xtest(void);


extern int __cdecl _rdseed16_step(unsigned short *);
extern int __cdecl _rdseed32_step(unsigned int *);


#line 2005 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"


extern unsigned char __cdecl _addcarryx_u32(unsigned char ,
                                                   unsigned int ,
                                                   unsigned int ,
                                                   unsigned int * );


#line 2027 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"


extern unsigned short   __cdecl _load_be_u16(void const*);
extern unsigned int     __cdecl _load_be_u32(void const*);
extern unsigned __int64 __cdecl _load_be_u64(void const*);


extern void __cdecl _store_be_u16(void *, unsigned short);
extern void __cdecl _store_be_u32(void *, unsigned int);
extern void __cdecl _store_be_u64(void *, unsigned __int64);


extern __m128i __cdecl _mm_sha1msg1_epu32(__m128i, __m128i);
extern __m128i __cdecl _mm_sha1msg2_epu32(__m128i, __m128i);
extern __m128i __cdecl _mm_sha1nexte_epu32(__m128i, __m128i);
extern __m128i __cdecl _mm_sha1rnds4_epu32(__m128i, __m128i, const int);

extern __m128i __cdecl _mm_sha256msg1_epu32(__m128i, __m128i);
extern __m128i __cdecl _mm_sha256msg2_epu32(__m128i, __m128i);
extern __m128i __cdecl _mm_sha256rnds2_epu32(__m128i, __m128i, __m128i);


extern void * __cdecl _bnd_set_ptr_bounds(const void *, size_t);
extern void * __cdecl _bnd_narrow_ptr_bounds(const void *, const void *, size_t);
extern void * __cdecl _bnd_copy_ptr_bounds(const void *, const void *);
extern void * __cdecl _bnd_init_ptr_bounds(const void *);
extern void __cdecl _bnd_store_ptr_bounds(const void **, const void *);
extern void __cdecl _bnd_chk_ptr_lbounds(const void *);
extern void __cdecl _bnd_chk_ptr_ubounds(const void *);
extern void __cdecl _bnd_chk_ptr_bounds(const void *, size_t);
extern void * __cdecl _bnd_load_ptr_bounds(const void **, const void *);
extern const void * __cdecl _bnd_get_ptr_lbound(const void *);
extern const void * __cdecl _bnd_get_ptr_ubound(const void *);


extern __m256i __cdecl _mm256_insert_epi8 (__m256i , int , const int );
extern __m256i __cdecl _mm256_insert_epi16(__m256i , int , const int );
extern __m256i __cdecl _mm256_insert_epi32(__m256i , int , const int );


#line 2083 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"


extern int __cdecl _mm256_extract_epi8 (__m256i , const int );
extern int __cdecl _mm256_extract_epi16(__m256i , const int );
extern int __cdecl _mm256_extract_epi32(__m256i , const int );


#line 2091 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"


extern __m256d __cdecl _mm256_zextpd128_pd256(__m128d);
extern __m256  __cdecl _mm256_zextps128_ps256(__m128);
extern __m256i __cdecl _mm256_zextsi128_si256(__m128i);


extern unsigned int __cdecl _rdpid_u32(void);

extern void         __cdecl _ptwrite32(unsigned int);


#line 2104 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"


extern __m128i __cdecl _mm_dpbusd_avx_epi32(__m128i, __m128i, __m128i);
extern __m256i __cdecl _mm256_dpbusd_avx_epi32(__m256i, __m256i, __m256i);
extern __m128i __cdecl _mm_dpbusds_avx_epi32(__m128i, __m128i, __m128i);
extern __m256i __cdecl _mm256_dpbusds_avx_epi32(__m256i, __m256i, __m256i);
extern __m128i __cdecl _mm_dpwssd_avx_epi32(__m128i, __m128i, __m128i);
extern __m256i __cdecl _mm256_dpwssd_avx_epi32(__m256i, __m256i, __m256i);
extern __m128i __cdecl _mm_dpwssds_avx_epi32(__m128i, __m128i, __m128i);
extern __m256i __cdecl _mm256_dpwssds_avx_epi32(__m256i, __m256i, __m256i);


extern unsigned int __cdecl _pconfig_u32(const int, size_t __data[]);
extern void __cdecl _wbnoinvd(void);


extern unsigned int __cdecl _encls_u32(const int, size_t __data[]);
extern unsigned int __cdecl _enclu_u32(const int, size_t __data[]);
extern unsigned int __cdecl _enclv_u32(const int, size_t __data[]);


#line 2130 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"
extern unsigned         __cdecl _udiv64(unsigned __int64 , unsigned , unsigned* );
extern int              __cdecl _div64(__int64 , int , int* );


extern unsigned char _mm_aesdec128kl_u8(__m128i* , __m128i , const void* );
extern unsigned char _mm_aesdec256kl_u8(__m128i* , __m128i , const void* );
extern unsigned char _mm_aesdecwide128kl_u8(__m128i* , const __m128i* , const void* );
extern unsigned char _mm_aesdecwide256kl_u8(__m128i* , const __m128i* , const void* );
extern unsigned char _mm_aesenc128kl_u8(__m128i* , __m128i , const void* );
extern unsigned char _mm_aesenc256kl_u8(__m128i* , __m128i , const void* );
extern unsigned char _mm_aesencwide128kl_u8(__m128i* , const __m128i* , const void* );
extern unsigned char _mm_aesencwide256kl_u8(__m128i* , const __m128i* , const void* );
extern unsigned int  _mm_encodekey128_u32(unsigned int , __m128i , void* );
extern unsigned int  _mm_encodekey256_u32(unsigned int , __m128i , __m128i , void* );
extern void          _mm_loadiwkey(unsigned int , __m128i , __m128i , __m128i );


extern unsigned int     __cdecl _rdpkru_u32(void);
extern void             __cdecl _wrpkru(unsigned int);


extern int              __cdecl _enqcmd(void * , const void * );
extern int              __cdecl _enqcmds(void * , const void * );


extern void             __cdecl _incsspd (unsigned int);
extern unsigned int     __cdecl _rdsspd (void);
extern void             __cdecl _saveprevssp (void);
extern void             __cdecl _rstorssp (void *);
extern void             __cdecl _wrssd (unsigned int, void *);
extern void             __cdecl _wrussd (unsigned int, void *);
extern void             __cdecl _setssbsy (void);
extern void             __cdecl _clrssbsy (void *);
extern void *           __cdecl _switchssp(void *);


#line 2172 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"


extern __m128i _mm_div_epi8(__m128i, __m128i);
extern __m128i _mm_div_epi16(__m128i, __m128i);
extern __m128i _mm_div_epi32(__m128i, __m128i);
extern __m128i _mm_div_epi64(__m128i, __m128i);
extern __m128i _mm_div_epu8(__m128i, __m128i);
extern __m128i _mm_div_epu16(__m128i, __m128i);
extern __m128i _mm_div_epu32(__m128i, __m128i);
extern __m128i _mm_div_epu64(__m128i, __m128i);
extern __m128i _mm_rem_epi8(__m128i, __m128i);
extern __m128i _mm_rem_epi16(__m128i, __m128i);
extern __m128i _mm_rem_epi32(__m128i, __m128i);
extern __m128i _mm_rem_epi64(__m128i, __m128i);
extern __m128i _mm_rem_epu8(__m128i, __m128i);
extern __m128i _mm_rem_epu16(__m128i, __m128i);
extern __m128i _mm_rem_epu32(__m128i, __m128i);
extern __m128i _mm_rem_epu64(__m128i, __m128i);
extern __m256i _mm256_div_epi8(__m256i, __m256i);
extern __m256i _mm256_div_epi16(__m256i, __m256i);
extern __m256i _mm256_div_epi32(__m256i, __m256i);
extern __m256i _mm256_div_epi64(__m256i, __m256i);
extern __m256i _mm256_div_epu8(__m256i, __m256i);
extern __m256i _mm256_div_epu16(__m256i, __m256i);
extern __m256i _mm256_div_epu32(__m256i, __m256i);
extern __m256i _mm256_div_epu64(__m256i, __m256i);
extern __m256i _mm256_rem_epi8(__m256i, __m256i);
extern __m256i _mm256_rem_epi16(__m256i, __m256i);
extern __m256i _mm256_rem_epi32(__m256i, __m256i);
extern __m256i _mm256_rem_epi64(__m256i, __m256i);
extern __m256i _mm256_rem_epu8(__m256i, __m256i);
extern __m256i _mm256_rem_epu16(__m256i, __m256i);
extern __m256i _mm256_rem_epu32(__m256i, __m256i);
extern __m256i _mm256_rem_epu64(__m256i, __m256i);


extern __m128i _mm_divrem_epi32(__m128i * , __m128i, __m128i);
extern __m128i _mm_divrem_epu32(__m128i * , __m128i, __m128i);
extern __m256i _mm256_divrem_epi32(__m256i * , __m256i, __m256i);
extern __m256i _mm256_divrem_epu32(__m256i * , __m256i, __m256i);


extern __m128  _mm_sin_ps(__m128);
extern __m128d _mm_sin_pd(__m128d);
extern __m256  _mm256_sin_ps(__m256);
extern __m256d _mm256_sin_pd(__m256d);
extern __m128  _mm_cos_ps(__m128);
extern __m128d _mm_cos_pd(__m128d);
extern __m256  _mm256_cos_ps(__m256);
extern __m256d _mm256_cos_pd(__m256d);
extern __m128  _mm_sincos_ps(__m128  * , __m128);
extern __m128d _mm_sincos_pd(__m128d * , __m128d);
extern __m256  _mm256_sincos_ps(__m256  * , __m256);
extern __m256d _mm256_sincos_pd(__m256d * , __m256d);
extern __m128  _mm_tan_ps(__m128);
extern __m128d _mm_tan_pd(__m128d);
extern __m256  _mm256_tan_ps(__m256);
extern __m256d _mm256_tan_pd(__m256d);
extern __m128  _mm_asin_ps(__m128);
extern __m128d _mm_asin_pd(__m128d);
extern __m256  _mm256_asin_ps(__m256);
extern __m256d _mm256_asin_pd(__m256d);
extern __m128  _mm_acos_ps(__m128);
extern __m128d _mm_acos_pd(__m128d);
extern __m256  _mm256_acos_ps(__m256);
extern __m256d _mm256_acos_pd(__m256d);
extern __m128  _mm_atan_ps(__m128);
extern __m128d _mm_atan_pd(__m128d);
extern __m256  _mm256_atan_ps(__m256);
extern __m256d _mm256_atan_pd(__m256d);
extern __m128  _mm_atan2_ps(__m128, __m128);
extern __m128d _mm_atan2_pd(__m128d, __m128d);
extern __m256  _mm256_atan2_ps(__m256, __m256);
extern __m256d _mm256_atan2_pd(__m256d, __m256d);
extern __m128  _mm_sind_ps(__m128);
extern __m128d _mm_sind_pd(__m128d);
extern __m256  _mm256_sind_ps(__m256);
extern __m256d _mm256_sind_pd(__m256d);
extern __m128  _mm_cosd_ps(__m128);
extern __m128d _mm_cosd_pd(__m128d);
extern __m256  _mm256_cosd_ps(__m256);
extern __m256d _mm256_cosd_pd(__m256d);
extern __m128  _mm_tand_ps(__m128);
extern __m128d _mm_tand_pd(__m128d);
extern __m256  _mm256_tand_ps(__m256);
extern __m256d _mm256_tand_pd(__m256d);
extern __m128  _mm_sinh_ps(__m128);
extern __m128d _mm_sinh_pd(__m128d);
extern __m256  _mm256_sinh_ps(__m256);
extern __m256d _mm256_sinh_pd(__m256d);
extern __m128  _mm_cosh_ps(__m128);
extern __m128d _mm_cosh_pd(__m128d);
extern __m256  _mm256_cosh_ps(__m256);
extern __m256d _mm256_cosh_pd(__m256d);
extern __m128  _mm_tanh_ps(__m128);
extern __m128d _mm_tanh_pd(__m128d);
extern __m256  _mm256_tanh_ps(__m256);
extern __m256d _mm256_tanh_pd(__m256d);
extern __m128  _mm_asinh_ps(__m128);
extern __m128d _mm_asinh_pd(__m128d);
extern __m256  _mm256_asinh_ps(__m256);
extern __m256d _mm256_asinh_pd(__m256d);
extern __m128  _mm_acosh_ps(__m128);
extern __m128d _mm_acosh_pd(__m128d);
extern __m256  _mm256_acosh_ps(__m256);
extern __m256d _mm256_acosh_pd(__m256d);
extern __m128  _mm_atanh_ps(__m128);
extern __m128d _mm_atanh_pd(__m128d);
extern __m256  _mm256_atanh_ps(__m256);
extern __m256d _mm256_atanh_pd(__m256d);
extern __m128  _mm_log_ps(__m128);
extern __m128d _mm_log_pd(__m128d);
extern __m256  _mm256_log_ps(__m256);
extern __m256d _mm256_log_pd(__m256d);
extern __m128  _mm_log1p_ps(__m128);
extern __m128d _mm_log1p_pd(__m128d);
extern __m256  _mm256_log1p_ps(__m256);
extern __m256d _mm256_log1p_pd(__m256d);
extern __m128  _mm_log10_ps(__m128);
extern __m128d _mm_log10_pd(__m128d);
extern __m256  _mm256_log10_ps(__m256);
extern __m256d _mm256_log10_pd(__m256d);
extern __m128  _mm_log2_ps(__m128);
extern __m128d _mm_log2_pd(__m128d);
extern __m256  _mm256_log2_ps(__m256);
extern __m256d _mm256_log2_pd(__m256d);
extern __m128  _mm_logb_ps(__m128);
extern __m128d _mm_logb_pd(__m128d);
extern __m256  _mm256_logb_ps(__m256);
extern __m256d _mm256_logb_pd(__m256d);
extern __m128  _mm_exp_ps(__m128);
extern __m128d _mm_exp_pd(__m128d);
extern __m256  _mm256_exp_ps(__m256);
extern __m256d _mm256_exp_pd(__m256d);
extern __m128  _mm_exp10_ps(__m128);
extern __m128d _mm_exp10_pd(__m128d);
extern __m256  _mm256_exp10_ps(__m256);
extern __m256d _mm256_exp10_pd(__m256d);
extern __m128  _mm_exp2_ps(__m128);
extern __m128d _mm_exp2_pd(__m128d);
extern __m256  _mm256_exp2_ps(__m256);
extern __m256d _mm256_exp2_pd(__m256d);
extern __m128  _mm_expm1_ps(__m128);
extern __m128d _mm_expm1_pd(__m128d);
extern __m256  _mm256_expm1_ps(__m256);
extern __m256d _mm256_expm1_pd(__m256d);
extern __m128  _mm_pow_ps(__m128, __m128);
extern __m128d _mm_pow_pd(__m128d, __m128d);
extern __m256  _mm256_pow_ps(__m256, __m256);
extern __m256d _mm256_pow_pd(__m256d, __m256d);
extern __m128  _mm_trunc_ps(__m128);
extern __m128d _mm_trunc_pd(__m128d);
extern __m256  _mm256_trunc_ps(__m256);
extern __m256d _mm256_trunc_pd(__m256d);
extern __m128  _mm_svml_floor_ps(__m128);
extern __m128d _mm_svml_floor_pd(__m128d);
extern __m256  _mm256_svml_floor_ps(__m256);
extern __m256d _mm256_svml_floor_pd(__m256d);
extern __m128  _mm_svml_ceil_ps(__m128);
extern __m128d _mm_svml_ceil_pd(__m128d);
extern __m256  _mm256_svml_ceil_ps(__m256);
extern __m256d _mm256_svml_ceil_pd(__m256d);
extern __m128  _mm_svml_round_ps(__m128);
extern __m128d _mm_svml_round_pd(__m128d);
extern __m256  _mm256_svml_round_ps(__m256);
extern __m256d _mm256_svml_round_pd(__m256d);
extern __m128  _mm_fmod_ps(__m128, __m128);
extern __m128d _mm_fmod_pd(__m128d, __m128d);
extern __m256  _mm256_fmod_ps(__m256, __m256);
extern __m256d _mm256_fmod_pd(__m256d, __m256d);
extern __m128  _mm_svml_sqrt_ps(__m128);
extern __m128d _mm_svml_sqrt_pd(__m128d);
extern __m256  _mm256_svml_sqrt_ps(__m256);
extern __m256d _mm256_svml_sqrt_pd(__m256d);
extern __m128  _mm_invsqrt_ps(__m128);
extern __m128d _mm_invsqrt_pd(__m128d);
extern __m256  _mm256_invsqrt_ps(__m256);
extern __m256d _mm256_invsqrt_pd(__m256d);
extern __m128  _mm_cbrt_ps(__m128);
extern __m128d _mm_cbrt_pd(__m128d);
extern __m256  _mm256_cbrt_ps(__m256);
extern __m256d _mm256_cbrt_pd(__m256d);
extern __m128  _mm_invcbrt_ps(__m128);
extern __m128d _mm_invcbrt_pd(__m128d);
extern __m256  _mm256_invcbrt_ps(__m256);
extern __m256d _mm256_invcbrt_pd(__m256d);
extern __m128  _mm_hypot_ps(__m128, __m128);
extern __m128d _mm_hypot_pd(__m128d, __m128d);
extern __m256  _mm256_hypot_ps(__m256, __m256);
extern __m256d _mm256_hypot_pd(__m256d, __m256d);
extern __m128  _mm_cdfnorm_ps(__m128);
extern __m128d _mm_cdfnorm_pd(__m128d);
extern __m256  _mm256_cdfnorm_ps(__m256);
extern __m256d _mm256_cdfnorm_pd(__m256d);
extern __m128  _mm_cdfnorminv_ps(__m128);
extern __m128d _mm_cdfnorminv_pd(__m128d);
extern __m256  _mm256_cdfnorminv_ps(__m256);
extern __m256d _mm256_cdfnorminv_pd(__m256d);
extern __m128  _mm_cexp_ps(__m128);
extern __m256  _mm256_cexp_ps(__m256);
extern __m128  _mm_clog_ps(__m128);
extern __m256  _mm256_clog_ps(__m256);
extern __m128  _mm_csqrt_ps(__m128);
extern __m256  _mm256_csqrt_ps(__m256);
extern __m128  _mm_erf_ps(__m128);
extern __m128d _mm_erf_pd(__m128d);
extern __m256  _mm256_erf_ps(__m256);
extern __m256d _mm256_erf_pd(__m256d);
extern __m128  _mm_erfc_ps(__m128);
extern __m128d _mm_erfc_pd(__m128d);
extern __m256  _mm256_erfc_ps(__m256);
extern __m256d _mm256_erfc_pd(__m256d);
extern __m128  _mm_erfcinv_ps(__m128);
extern __m128d _mm_erfcinv_pd(__m128d);
extern __m256  _mm256_erfcinv_ps(__m256);
extern __m256d _mm256_erfcinv_pd(__m256d);
extern __m128  _mm_erfinv_ps(__m128);
extern __m128d _mm_erfinv_pd(__m128d);
extern __m256  _mm256_erfinv_ps(__m256);
extern __m256d _mm256_erfinv_pd(__m256d);


extern void _mm_cldemote(void const *);


extern void _directstoreu_u32(void *, unsigned int);


#line 2419 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"
extern void _movdir64b(void *, void const *);


extern void __cdecl _serialize(void);
extern void __cdecl _xsusldtrk(void);
extern void __cdecl _xresldtrk(void);


extern void _umonitor(void *);
extern unsigned char _umwait(unsigned int, unsigned __int64);
extern unsigned char _tpause(unsigned int, unsigned __int64);


#line 2438 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"


extern void _hreset(unsigned __int32);


extern __m128 _mm_svml_cvtepu32_ps (__m128i);
extern __m256 _mm256_svml_cvtepu32_ps (__m256i);
extern __m128d _mm_svml_cvtepu32_pd (__m128i);
extern __m256d _mm256_svml_cvtepu32_pd (__m128i);
extern __m128d _mm_svml_cvtepi64_pd (__m128i);
extern __m256d _mm256_svml_cvtepi64_pd (__m256i);
extern __m128d _mm_svml_cvtepu64_pd (__m128i);
extern __m256d _mm256_svml_cvtepu64_pd (__m256i);


extern unsigned __int32 _castf32_u32 (float);
extern unsigned __int64 _castf64_u64 (double);
extern float _castu32_f32 (unsigned __int32);
extern double _castu64_f64 (unsigned __int64);


}; 
#line 2461 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\zmmintrin.h"


typedef unsigned char       __mmask8;
typedef unsigned short      __mmask16;
typedef unsigned int        __mmask32;
typedef unsigned __int64    __mmask64;

typedef union __declspec(intrin_type) __declspec(align(64)) __m512 {
    float m512_f32[16];
} __m512;

typedef struct __declspec(intrin_type) __declspec(align(64)) __m512d {
    double m512d_f64[8];
} __m512d;

typedef union  __declspec(intrin_type) __declspec(align(64)) __m512i {
    __int8              m512i_i8[64];
    __int16             m512i_i16[32];
    __int32             m512i_i32[16];
    __int64             m512i_i64[8];
    unsigned __int8     m512i_u8[64];
    unsigned __int16    m512i_u16[32];
    unsigned __int32    m512i_u32[16];
    unsigned __int64    m512i_u64[8];
} __m512i;


extern "C" {

#line 71 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\zmmintrin.h"


extern __m256  __cdecl _mm512_castps512_ps256(__m512);
extern __m512  __cdecl _mm512_castpd_ps(__m512d);
extern __m512  __cdecl _mm512_castps256_ps512(__m256);
extern __m512  __cdecl _mm512_castsi512_ps(__m512i);
extern __m512  __cdecl _mm512_castps128_ps512(__m128);

extern __m256d __cdecl _mm512_castpd512_pd256(__m512d);
extern __m512d __cdecl _mm512_castpd256_pd512(__m256d);
extern __m512d __cdecl _mm512_castps_pd(__m512);
extern __m512d __cdecl _mm512_castsi512_pd(__m512i);
extern __m512d __cdecl _mm512_castpd128_pd512(__m128d);

extern __m256i __cdecl _mm512_castsi512_si256(__m512i);
extern __m512i __cdecl _mm512_castpd_si512(__m512d);
extern __m512i __cdecl _mm512_castps_si512(__m512);
extern __m512i __cdecl _mm512_castsi256_si512(__m256i);


typedef enum {
    _MM_BROADCAST32_NONE,   

    _MM_BROADCAST_1X16,     
    _MM_BROADCAST_4X16      
} _MM_BROADCAST32_ENUM;


typedef enum {
    _MM_BROADCAST64_NONE,   

    _MM_BROADCAST_1X8,      
    _MM_BROADCAST_4X8       
} _MM_BROADCAST64_ENUM;


typedef enum {
    _MM_ROUND_MODE_NEAREST,             
    _MM_ROUND_MODE_DOWN,                
    _MM_ROUND_MODE_UP,                  
    _MM_ROUND_MODE_TOWARD_ZERO,         
    _MM_ROUND_MODE_DEFAULT,             
    _MM_ROUND_MODE_NO_EXC = 8,          
} _MM_ROUND_MODE_ENUM;


typedef enum {
    _MM_EXPADJ_NONE,               
    _MM_EXPADJ_4,                  
    _MM_EXPADJ_5,                  
    _MM_EXPADJ_8,                  
    _MM_EXPADJ_16,                 
    _MM_EXPADJ_24,                 
    _MM_EXPADJ_31,                 
    _MM_EXPADJ_32                  
} _MM_EXP_ADJ_ENUM;


typedef enum {
    _MM_SCALE_1 = 1,
    _MM_SCALE_2 = 2,
    _MM_SCALE_4 = 4,
    _MM_SCALE_8 = 8
} _MM_INDEX_SCALE_ENUM;


typedef enum {
    _MM_PERM_AAAA = 0x00, _MM_PERM_AAAB = 0x01, _MM_PERM_AAAC = 0x02,
    _MM_PERM_AAAD = 0x03, _MM_PERM_AABA = 0x04, _MM_PERM_AABB = 0x05,
    _MM_PERM_AABC = 0x06, _MM_PERM_AABD = 0x07, _MM_PERM_AACA = 0x08,
    _MM_PERM_AACB = 0x09, _MM_PERM_AACC = 0x0A, _MM_PERM_AACD = 0x0B,
    _MM_PERM_AADA = 0x0C, _MM_PERM_AADB = 0x0D, _MM_PERM_AADC = 0x0E,
    _MM_PERM_AADD = 0x0F, _MM_PERM_ABAA = 0x10, _MM_PERM_ABAB = 0x11,
    _MM_PERM_ABAC = 0x12, _MM_PERM_ABAD = 0x13, _MM_PERM_ABBA = 0x14,
    _MM_PERM_ABBB = 0x15, _MM_PERM_ABBC = 0x16, _MM_PERM_ABBD = 0x17,
    _MM_PERM_ABCA = 0x18, _MM_PERM_ABCB = 0x19, _MM_PERM_ABCC = 0x1A,
    _MM_PERM_ABCD = 0x1B, _MM_PERM_ABDA = 0x1C, _MM_PERM_ABDB = 0x1D,
    _MM_PERM_ABDC = 0x1E, _MM_PERM_ABDD = 0x1F, _MM_PERM_ACAA = 0x20,
    _MM_PERM_ACAB = 0x21, _MM_PERM_ACAC = 0x22, _MM_PERM_ACAD = 0x23,
    _MM_PERM_ACBA = 0x24, _MM_PERM_ACBB = 0x25, _MM_PERM_ACBC = 0x26,
    _MM_PERM_ACBD = 0x27, _MM_PERM_ACCA = 0x28, _MM_PERM_ACCB = 0x29,
    _MM_PERM_ACCC = 0x2A, _MM_PERM_ACCD = 0x2B, _MM_PERM_ACDA = 0x2C,
    _MM_PERM_ACDB = 0x2D, _MM_PERM_ACDC = 0x2E, _MM_PERM_ACDD = 0x2F,
    _MM_PERM_ADAA = 0x30, _MM_PERM_ADAB = 0x31, _MM_PERM_ADAC = 0x32,
    _MM_PERM_ADAD = 0x33, _MM_PERM_ADBA = 0x34, _MM_PERM_ADBB = 0x35,
    _MM_PERM_ADBC = 0x36, _MM_PERM_ADBD = 0x37, _MM_PERM_ADCA = 0x38,
    _MM_PERM_ADCB = 0x39, _MM_PERM_ADCC = 0x3A, _MM_PERM_ADCD = 0x3B,
    _MM_PERM_ADDA = 0x3C, _MM_PERM_ADDB = 0x3D, _MM_PERM_ADDC = 0x3E,
    _MM_PERM_ADDD = 0x3F, _MM_PERM_BAAA = 0x40, _MM_PERM_BAAB = 0x41,
    _MM_PERM_BAAC = 0x42, _MM_PERM_BAAD = 0x43, _MM_PERM_BABA = 0x44,
    _MM_PERM_BABB = 0x45, _MM_PERM_BABC = 0x46, _MM_PERM_BABD = 0x47,
    _MM_PERM_BACA = 0x48, _MM_PERM_BACB = 0x49, _MM_PERM_BACC = 0x4A,
    _MM_PERM_BACD = 0x4B, _MM_PERM_BADA = 0x4C, _MM_PERM_BADB = 0x4D,
    _MM_PERM_BADC = 0x4E, _MM_PERM_BADD = 0x4F, _MM_PERM_BBAA = 0x50,
    _MM_PERM_BBAB = 0x51, _MM_PERM_BBAC = 0x52, _MM_PERM_BBAD = 0x53,
    _MM_PERM_BBBA = 0x54, _MM_PERM_BBBB = 0x55, _MM_PERM_BBBC = 0x56,
    _MM_PERM_BBBD = 0x57, _MM_PERM_BBCA = 0x58, _MM_PERM_BBCB = 0x59,
    _MM_PERM_BBCC = 0x5A, _MM_PERM_BBCD = 0x5B, _MM_PERM_BBDA = 0x5C,
    _MM_PERM_BBDB = 0x5D, _MM_PERM_BBDC = 0x5E, _MM_PERM_BBDD = 0x5F,
    _MM_PERM_BCAA = 0x60, _MM_PERM_BCAB = 0x61, _MM_PERM_BCAC = 0x62,
    _MM_PERM_BCAD = 0x63, _MM_PERM_BCBA = 0x64, _MM_PERM_BCBB = 0x65,
    _MM_PERM_BCBC = 0x66, _MM_PERM_BCBD = 0x67, _MM_PERM_BCCA = 0x68,
    _MM_PERM_BCCB = 0x69, _MM_PERM_BCCC = 0x6A, _MM_PERM_BCCD = 0x6B,
    _MM_PERM_BCDA = 0x6C, _MM_PERM_BCDB = 0x6D, _MM_PERM_BCDC = 0x6E,
    _MM_PERM_BCDD = 0x6F, _MM_PERM_BDAA = 0x70, _MM_PERM_BDAB = 0x71,
    _MM_PERM_BDAC = 0x72, _MM_PERM_BDAD = 0x73, _MM_PERM_BDBA = 0x74,
    _MM_PERM_BDBB = 0x75, _MM_PERM_BDBC = 0x76, _MM_PERM_BDBD = 0x77,
    _MM_PERM_BDCA = 0x78, _MM_PERM_BDCB = 0x79, _MM_PERM_BDCC = 0x7A,
    _MM_PERM_BDCD = 0x7B, _MM_PERM_BDDA = 0x7C, _MM_PERM_BDDB = 0x7D,
    _MM_PERM_BDDC = 0x7E, _MM_PERM_BDDD = 0x7F, _MM_PERM_CAAA = 0x80,
    _MM_PERM_CAAB = 0x81, _MM_PERM_CAAC = 0x82, _MM_PERM_CAAD = 0x83,
    _MM_PERM_CABA = 0x84, _MM_PERM_CABB = 0x85, _MM_PERM_CABC = 0x86,
    _MM_PERM_CABD = 0x87, _MM_PERM_CACA = 0x88, _MM_PERM_CACB = 0x89,
    _MM_PERM_CACC = 0x8A, _MM_PERM_CACD = 0x8B, _MM_PERM_CADA = 0x8C,
    _MM_PERM_CADB = 0x8D, _MM_PERM_CADC = 0x8E, _MM_PERM_CADD = 0x8F,
    _MM_PERM_CBAA = 0x90, _MM_PERM_CBAB = 0x91, _MM_PERM_CBAC = 0x92,
    _MM_PERM_CBAD = 0x93, _MM_PERM_CBBA = 0x94, _MM_PERM_CBBB = 0x95,
    _MM_PERM_CBBC = 0x96, _MM_PERM_CBBD = 0x97, _MM_PERM_CBCA = 0x98,
    _MM_PERM_CBCB = 0x99, _MM_PERM_CBCC = 0x9A, _MM_PERM_CBCD = 0x9B,
    _MM_PERM_CBDA = 0x9C, _MM_PERM_CBDB = 0x9D, _MM_PERM_CBDC = 0x9E,
    _MM_PERM_CBDD = 0x9F, _MM_PERM_CCAA = 0xA0, _MM_PERM_CCAB = 0xA1,
    _MM_PERM_CCAC = 0xA2, _MM_PERM_CCAD = 0xA3, _MM_PERM_CCBA = 0xA4,
    _MM_PERM_CCBB = 0xA5, _MM_PERM_CCBC = 0xA6, _MM_PERM_CCBD = 0xA7,
    _MM_PERM_CCCA = 0xA8, _MM_PERM_CCCB = 0xA9, _MM_PERM_CCCC = 0xAA,
    _MM_PERM_CCCD = 0xAB, _MM_PERM_CCDA = 0xAC, _MM_PERM_CCDB = 0xAD,
    _MM_PERM_CCDC = 0xAE, _MM_PERM_CCDD = 0xAF, _MM_PERM_CDAA = 0xB0,
    _MM_PERM_CDAB = 0xB1, _MM_PERM_CDAC = 0xB2, _MM_PERM_CDAD = 0xB3,
    _MM_PERM_CDBA = 0xB4, _MM_PERM_CDBB = 0xB5, _MM_PERM_CDBC = 0xB6,
    _MM_PERM_CDBD = 0xB7, _MM_PERM_CDCA = 0xB8, _MM_PERM_CDCB = 0xB9,
    _MM_PERM_CDCC = 0xBA, _MM_PERM_CDCD = 0xBB, _MM_PERM_CDDA = 0xBC,
    _MM_PERM_CDDB = 0xBD, _MM_PERM_CDDC = 0xBE, _MM_PERM_CDDD = 0xBF,
    _MM_PERM_DAAA = 0xC0, _MM_PERM_DAAB = 0xC1, _MM_PERM_DAAC = 0xC2,
    _MM_PERM_DAAD = 0xC3, _MM_PERM_DABA = 0xC4, _MM_PERM_DABB = 0xC5,
    _MM_PERM_DABC = 0xC6, _MM_PERM_DABD = 0xC7, _MM_PERM_DACA = 0xC8,
    _MM_PERM_DACB = 0xC9, _MM_PERM_DACC = 0xCA, _MM_PERM_DACD = 0xCB,
    _MM_PERM_DADA = 0xCC, _MM_PERM_DADB = 0xCD, _MM_PERM_DADC = 0xCE,
    _MM_PERM_DADD = 0xCF, _MM_PERM_DBAA = 0xD0, _MM_PERM_DBAB = 0xD1,
    _MM_PERM_DBAC = 0xD2, _MM_PERM_DBAD = 0xD3, _MM_PERM_DBBA = 0xD4,
    _MM_PERM_DBBB = 0xD5, _MM_PERM_DBBC = 0xD6, _MM_PERM_DBBD = 0xD7,
    _MM_PERM_DBCA = 0xD8, _MM_PERM_DBCB = 0xD9, _MM_PERM_DBCC = 0xDA,
    _MM_PERM_DBCD = 0xDB, _MM_PERM_DBDA = 0xDC, _MM_PERM_DBDB = 0xDD,
    _MM_PERM_DBDC = 0xDE, _MM_PERM_DBDD = 0xDF, _MM_PERM_DCAA = 0xE0,
    _MM_PERM_DCAB = 0xE1, _MM_PERM_DCAC = 0xE2, _MM_PERM_DCAD = 0xE3,
    _MM_PERM_DCBA = 0xE4, _MM_PERM_DCBB = 0xE5, _MM_PERM_DCBC = 0xE6,
    _MM_PERM_DCBD = 0xE7, _MM_PERM_DCCA = 0xE8, _MM_PERM_DCCB = 0xE9,
    _MM_PERM_DCCC = 0xEA, _MM_PERM_DCCD = 0xEB, _MM_PERM_DCDA = 0xEC,
    _MM_PERM_DCDB = 0xED, _MM_PERM_DCDC = 0xEE, _MM_PERM_DCDD = 0xEF,
    _MM_PERM_DDAA = 0xF0, _MM_PERM_DDAB = 0xF1, _MM_PERM_DDAC = 0xF2,
    _MM_PERM_DDAD = 0xF3, _MM_PERM_DDBA = 0xF4, _MM_PERM_DDBB = 0xF5,
    _MM_PERM_DDBC = 0xF6, _MM_PERM_DDBD = 0xF7, _MM_PERM_DDCA = 0xF8,
    _MM_PERM_DDCB = 0xF9, _MM_PERM_DDCC = 0xFA, _MM_PERM_DDCD = 0xFB,
    _MM_PERM_DDDA = 0xFC, _MM_PERM_DDDB = 0xFD, _MM_PERM_DDDC = 0xFE,
    _MM_PERM_DDDD = 0xFF
} _MM_PERM_ENUM;


typedef enum {
    _MM_FIXUP_NO_CHANGE,
    _MM_FIXUP_NEG_INF,
    _MM_FIXUP_NEG_ZERO,
    _MM_FIXUP_POS_ZERO,
    _MM_FIXUP_POS_INF,
    _MM_FIXUP_NAN,
    _MM_FIXUP_MAX_FLOAT,
    _MM_FIXUP_MIN_FLOAT
} _MM_FIXUPRESULT_ENUM;


typedef enum {
    _MM_MANT_NORM_1_2,      
    _MM_MANT_NORM_p5_2,     
    _MM_MANT_NORM_p5_1,     
    _MM_MANT_NORM_p75_1p5   
} _MM_MANTISSA_NORM_ENUM;

typedef enum {
    _MM_MANT_SIGN_src,      
    _MM_MANT_SIGN_zero,     
    _MM_MANT_SIGN_nan       
} _MM_MANTISSA_SIGN_ENUM;


typedef enum {
    _MM_CMPINT_EQ,      
    _MM_CMPINT_LT,      
    _MM_CMPINT_LE,      
    _MM_CMPINT_UNUSED,
    _MM_CMPINT_NE,      
    _MM_CMPINT_NLT,     

    _MM_CMPINT_NLE      

} _MM_CMPINT_ENUM;


extern __m512  __cdecl _mm512_setzero_ps(void);
extern __m512d __cdecl _mm512_setzero_pd(void);

extern __m512  __cdecl _mm512_set_ps(float , float, float, float, float, float, float, float, float, float, float, float, float, float, float, float );
extern __m512d __cdecl _mm512_set_pd(double , double, double, double, double, double, double, double );

extern __m512  __cdecl _mm512_setr_ps(float , float, float, float, float, float, float, float, float, float, float, float, float, float, float, float );
extern __m512d __cdecl _mm512_setr_pd(double , double, double, double, double, double, double, double );

extern __m512  __cdecl _mm512_set1_ps(float);
extern __m512d __cdecl _mm512_set1_pd(double);

extern __m512  __cdecl _mm512_load_ps(void const*);
extern __m512d __cdecl _mm512_load_pd(void const*);
extern __m512  __cdecl _mm512_maskz_load_ps(__mmask16, void const*);
extern __m512d __cdecl _mm512_maskz_load_pd(__mmask8, void const*);
extern __m512  __cdecl _mm512_mask_load_ps(__m512, __mmask16, void const*);
extern __m512d __cdecl _mm512_mask_load_pd(__m512d, __mmask8, void const*);
extern __m512  __cdecl _mm512_loadu_ps(void const*);
extern __m512d __cdecl _mm512_loadu_pd(void const*);
extern __m512  __cdecl _mm512_maskz_loadu_ps(__mmask16, void const*);
extern __m512d __cdecl _mm512_maskz_loadu_pd(__mmask8, void const*);
extern __m512  __cdecl _mm512_mask_loadu_ps(__m512, __mmask16, void const*);
extern __m512d __cdecl _mm512_mask_loadu_pd(__m512d, __mmask8, void const*);

extern void    __cdecl _mm512_store_ps(void*, __m512);
extern void    __cdecl _mm512_store_pd(void*, __m512d);
extern void    __cdecl _mm512_storeu_ps(void*, __m512);
extern void    __cdecl _mm512_storeu_pd(void*, __m512d);
extern void    __cdecl _mm512_mask_store_ps(void*, __mmask16, __m512);
extern void    __cdecl _mm512_mask_store_pd(void*, __mmask8, __m512d);
extern void    __cdecl _mm512_mask_storeu_ps(void*, __mmask16, __m512);
extern void    __cdecl _mm512_mask_storeu_pd(void*, __mmask8, __m512d);

extern __m512  __cdecl _mm512_add_ps(__m512, __m512);
extern __m512  __cdecl _mm512_maskz_add_ps(__mmask16, __m512, __m512);
extern __m512  __cdecl _mm512_mask_add_ps(__m512, __mmask16, __m512, __m512);
extern __m512  __cdecl _mm512_add_round_ps(__m512, __m512, const int );
extern __m512  __cdecl _mm512_maskz_add_round_ps(__mmask16, __m512, __m512, const int );
extern __m512  __cdecl _mm512_mask_add_round_ps(__m512, __mmask16, __m512, __m512, const int );
extern __m512d __cdecl _mm512_add_pd(__m512d, __m512d);
extern __m512d __cdecl _mm512_maskz_add_pd(__mmask8, __m512d, __m512d);
extern __m512d __cdecl _mm512_mask_add_pd(__m512d, __mmask8, __m512d, __m512d);
extern __m512d __cdecl _mm512_add_round_pd(__m512d, __m512d, const int );
extern __m512d __cdecl _mm512_maskz_add_round_pd(__mmask8, __m512d, __m512d, const int );
extern __m512d __cdecl _mm512_mask_add_round_pd(__m512d, __mmask8, __m512d, __m512d, const int );

extern __m512  __cdecl _mm512_sub_ps(__m512, __m512);
extern __m512  __cdecl _mm512_maskz_sub_ps(__mmask16, __m512, __m512);
extern __m512  __cdecl _mm512_mask_sub_ps(__m512, __mmask16, __m512, __m512);
extern __m512  __cdecl _mm512_sub_round_ps(__m512, __m512, const int );
extern __m512  __cdecl _mm512_maskz_sub_round_ps(__mmask16, __m512, __m512, const int );
extern __m512  __cdecl _mm512_mask_sub_round_ps(__m512, __mmask16, __m512, __m512, const int );
extern __m512d __cdecl _mm512_sub_pd(__m512d, __m512d);
extern __m512d __cdecl _mm512_maskz_sub_pd(__mmask8, __m512d, __m512d);
extern __m512d __cdecl _mm512_mask_sub_pd(__m512d, __mmask8, __m512d, __m512d);
extern __m512d __cdecl _mm512_sub_round_pd(__m512d, __m512d, const int );
extern __m512d __cdecl _mm512_maskz_sub_round_pd(__mmask8, __m512d, __m512d, const int );
extern __m512d __cdecl _mm512_mask_sub_round_pd(__m512d, __mmask8, __m512d, __m512d, const int );

extern __m512  __cdecl _mm512_mul_ps(__m512, __m512);
extern __m512  __cdecl _mm512_maskz_mul_ps(__mmask16, __m512, __m512);
extern __m512  __cdecl _mm512_mask_mul_ps(__m512, __mmask16, __m512, __m512);
extern __m512  __cdecl _mm512_mul_round_ps( __m512, __m512, const int );
extern __m512  __cdecl _mm512_maskz_mul_round_ps(__mmask16, __m512, __m512, const int );
extern __m512  __cdecl _mm512_mask_mul_round_ps(__m512, __mmask16, __m512, __m512, const int );
extern __m512d __cdecl _mm512_mul_pd(__m512d, __m512d);
extern __m512d __cdecl _mm512_maskz_mul_pd(__mmask8, __m512d, __m512d);
extern __m512d __cdecl _mm512_mask_mul_pd(__m512d, __mmask8, __m512d, __m512d);
extern __m512d __cdecl _mm512_mul_round_pd(__m512d, __m512d, const int );
extern __m512d __cdecl _mm512_maskz_mul_round_pd(__mmask8, __m512d, __m512d, const int );
extern __m512d __cdecl _mm512_mask_mul_round_pd(__m512d, __mmask8, __m512d, __m512d, const int );

extern __m512  __cdecl _mm512_div_ps(__m512, __m512);
extern __m512  __cdecl _mm512_maskz_div_ps(__mmask16, __m512, __m512);
extern __m512  __cdecl _mm512_mask_div_ps(__m512, __mmask16, __m512, __m512);
extern __m512  __cdecl _mm512_div_round_ps(__m512, __m512, const int );
extern __m512  __cdecl _mm512_maskz_div_round_ps(__mmask16, __m512, __m512, const int );
extern __m512  __cdecl _mm512_mask_div_round_ps(__m512, __mmask16, __m512, __m512, const int );
extern __m512d __cdecl _mm512_div_pd(__m512d, __m512d);
extern __m512d __cdecl _mm512_maskz_div_pd(__mmask8, __m512d, __m512d);
extern __m512d __cdecl _mm512_mask_div_pd(__m512d, __mmask8, __m512d, __m512d);
extern __m512d __cdecl _mm512_div_round_pd(__m512d, __m512d, const int );
extern __m512d __cdecl _mm512_maskz_div_round_pd(__mmask8, __m512d, __m512d, const int );
extern __m512d __cdecl _mm512_mask_div_round_pd(__m512d, __mmask8, __m512d, __m512d, const int );

extern __m512  __cdecl _mm512_fmadd_ps(__m512, __m512, __m512);
extern __m512  __cdecl _mm512_mask_fmadd_ps(__m512, __mmask16, __m512, __m512);
extern __m512  __cdecl _mm512_mask3_fmadd_ps(__m512, __m512, __m512, __mmask16);
extern __m512  __cdecl _mm512_maskz_fmadd_ps(__mmask16, __m512, __m512, __m512);
extern __m512  __cdecl _mm512_fmadd_round_ps(__m512, __m512, __m512, const int );
extern __m512  __cdecl _mm512_mask_fmadd_round_ps(__m512, __mmask16, __m512, __m512, const int );
extern __m512  __cdecl _mm512_mask3_fmadd_round_ps(__m512, __m512, __m512, __mmask16, const int );
extern __m512  __cdecl _mm512_maskz_fmadd_round_ps(__mmask16, __m512, __m512, __m512, const int );
extern __m512d __cdecl _mm512_fmadd_pd(__m512d, __m512d, __m512d);
extern __m512d __cdecl _mm512_mask_fmadd_pd(__m512d, __mmask8, __m512d, __m512d);
extern __m512d __cdecl _mm512_mask3_fmadd_pd(__m512d, __m512d, __m512d, __mmask8);
extern __m512d __cdecl _mm512_maskz_fmadd_pd(__mmask8, __m512d, __m512d, __m512d);
extern __m512d __cdecl _mm512_fmadd_round_pd(__m512d, __m512d, __m512d, const int );
extern __m512d __cdecl _mm512_mask_fmadd_round_pd(__m512d, __mmask8, __m512d, __m512d, const int );
extern __m512d __cdecl _mm512_mask3_fmadd_round_pd(__m512d, __m512d, __m512d, __mmask8, const int );
extern __m512d __cdecl _mm512_maskz_fmadd_round_pd(__mmask8, __m512d, __m512d, __m512d, const int );

extern __m512  __cdecl _mm512_fmsub_ps(__m512, __m512, __m512);
extern __m512  __cdecl _mm512_mask_fmsub_ps(__m512, __mmask16, __m512, __m512);
extern __m512  __cdecl _mm512_mask3_fmsub_ps(__m512, __m512, __m512, __mmask16);
extern __m512  __cdecl _mm512_maskz_fmsub_ps(__mmask16, __m512, __m512, __m512);
extern __m512  __cdecl _mm512_fmsub_round_ps(__m512, __m512, __m512, const int );
extern __m512  __cdecl _mm512_mask_fmsub_round_ps(__m512, __mmask16, __m512, __m512, const int );
extern __m512  __cdecl _mm512_mask3_fmsub_round_ps(__m512, __m512, __m512, __mmask16, const int );
extern __m512  __cdecl _mm512_maskz_fmsub_round_ps(__mmask16, __m512, __m512, __m512, const int );
extern __m512d __cdecl _mm512_fmsub_pd(__m512d, __m512d, __m512d);
extern __m512d __cdecl _mm512_mask_fmsub_pd(__m512d, __mmask8, __m512d, __m512d);
extern __m512d __cdecl _mm512_mask3_fmsub_pd(__m512d, __m512d, __m512d, __mmask8);
extern __m512d __cdecl _mm512_maskz_fmsub_pd(__mmask8, __m512d, __m512d, __m512d);
extern __m512d __cdecl _mm512_fmsub_round_pd(__m512d, __m512d, __m512d, const int );
extern __m512d __cdecl _mm512_mask_fmsub_round_pd(__m512d, __mmask8, __m512d, __m512d, const int );
extern __m512d __cdecl _mm512_mask3_fmsub_round_pd(__m512d, __m512d, __m512d, __mmask8, const int );
extern __m512d __cdecl _mm512_maskz_fmsub_round_pd(__mmask8, __m512d, __m512d, __m512d, const int );

extern __m512  __cdecl _mm512_fmaddsub_ps(__m512, __m512, __m512);
extern __m512  __cdecl _mm512_mask_fmaddsub_ps(__m512, __mmask16, __m512, __m512);
extern __m512  __cdecl _mm512_mask3_fmaddsub_ps(__m512, __m512, __m512, __mmask16);
extern __m512  __cdecl _mm512_maskz_fmaddsub_ps(__mmask16, __m512, __m512, __m512);
extern __m512  __cdecl _mm512_fmaddsub_round_ps(__m512, __m512, __m512, const int );
extern __m512  __cdecl _mm512_mask_fmaddsub_round_ps(__m512, __mmask16, __m512, __m512, const int );
extern __m512  __cdecl _mm512_mask3_fmaddsub_round_ps(__m512, __m512, __m512, __mmask16, const int );
extern __m512  __cdecl _mm512_maskz_fmaddsub_round_ps(__mmask16, __m512, __m512, __m512, const int );
extern __m512d __cdecl _mm512_fmaddsub_pd(__m512d, __m512d, __m512d);
extern __m512d __cdecl _mm512_mask_fmaddsub_pd(__m512d, __mmask8, __m512d, __m512d);
extern __m512d __cdecl _mm512_mask3_fmaddsub_pd(__m512d, __m512d, __m512d, __mmask8);
extern __m512d __cdecl _mm512_maskz_fmaddsub_pd(__mmask8, __m512d, __m512d, __m512d);
extern __m512d __cdecl _mm512_fmaddsub_round_pd(__m512d, __m512d, __m512d, const int );
extern __m512d __cdecl _mm512_mask_fmaddsub_round_pd(__m512d, __mmask8, __m512d, __m512d, const int );
extern __m512d __cdecl _mm512_mask3_fmaddsub_round_pd(__m512d, __m512d, __m512d, __mmask8, const int );
extern __m512d __cdecl _mm512_maskz_fmaddsub_round_pd(__mmask8, __m512d, __m512d, __m512d, const int );

extern __m512  __cdecl _mm512_fmsubadd_ps(__m512, __m512, __m512);
extern __m512  __cdecl _mm512_mask_fmsubadd_ps(__m512, __mmask16, __m512, __m512);
extern __m512  __cdecl _mm512_mask3_fmsubadd_ps(__m512, __m512, __m512, __mmask16);
extern __m512  __cdecl _mm512_maskz_fmsubadd_ps(__mmask16, __m512, __m512, __m512);
extern __m512  __cdecl _mm512_fmsubadd_round_ps(__m512, __m512, __m512, const int );
extern __m512  __cdecl _mm512_mask_fmsubadd_round_ps(__m512, __mmask16, __m512, __m512, const int );
extern __m512  __cdecl _mm512_mask3_fmsubadd_round_ps(__m512, __m512, __m512, __mmask16, const int );
extern __m512  __cdecl _mm512_maskz_fmsubadd_round_ps(__mmask16, __m512, __m512, __m512, const int );
extern __m512d __cdecl _mm512_fmsubadd_pd(__m512d, __m512d, __m512d);
extern __m512d __cdecl _mm512_mask_fmsubadd_pd(__m512d, __mmask8, __m512d, __m512d);
extern __m512d __cdecl _mm512_mask3_fmsubadd_pd(__m512d, __m512d, __m512d, __mmask8);
extern __m512d __cdecl _mm512_maskz_fmsubadd_pd(__mmask8, __m512d, __m512d, __m512d);
extern __m512d __cdecl _mm512_fmsubadd_round_pd(__m512d, __m512d, __m512d, const int );
extern __m512d __cdecl _mm512_mask_fmsubadd_round_pd(__m512d, __mmask8, __m512d, __m512d, const int );
extern __m512d __cdecl _mm512_mask3_fmsubadd_round_pd(__m512d, __m512d, __m512d, __mmask8, const int );
extern __m512d __cdecl _mm512_maskz_fmsubadd_round_pd(__mmask8, __m512d, __m512d, __m512d, const int );

extern __m512  __cdecl _mm512_fnmadd_ps(__m512, __m512, __m512);
extern __m512  __cdecl _mm512_mask_fnmadd_ps(__m512, __mmask16, __m512, __m512);
extern __m512  __cdecl _mm512_mask3_fnmadd_ps(__m512, __m512, __m512, __mmask16);
extern __m512  __cdecl _mm512_maskz_fnmadd_ps(__mmask16, __m512, __m512, __m512);
extern __m512  __cdecl _mm512_fnmadd_round_ps(__m512, __m512, __m512, const int );
extern __m512  __cdecl _mm512_mask_fnmadd_round_ps(__m512, __mmask16, __m512, __m512, const int );
extern __m512  __cdecl _mm512_mask3_fnmadd_round_ps(__m512, __m512, __m512, __mmask16, const int );
extern __m512  __cdecl _mm512_maskz_fnmadd_round_ps(__mmask16, __m512, __m512, __m512, const int );
extern __m512d __cdecl _mm512_fnmadd_pd(__m512d, __m512d, __m512d);
extern __m512d __cdecl _mm512_mask_fnmadd_pd(__m512d, __mmask8, __m512d, __m512d);
extern __m512d __cdecl _mm512_mask3_fnmadd_pd(__m512d, __m512d, __m512d, __mmask8);
extern __m512d __cdecl _mm512_maskz_fnmadd_pd(__mmask8, __m512d, __m512d, __m512d);
extern __m512d __cdecl _mm512_fnmadd_round_pd(__m512d, __m512d, __m512d, const int );
extern __m512d __cdecl _mm512_mask_fnmadd_round_pd(__m512d, __mmask8, __m512d, __m512d, const int );
extern __m512d __cdecl _mm512_mask3_fnmadd_round_pd(__m512d, __m512d, __m512d, __mmask8, const int );
extern __m512d __cdecl _mm512_maskz_fnmadd_round_pd(__mmask8, __m512d, __m512d, __m512d, const int );

extern __m512  __cdecl _mm512_fnmsub_ps(__m512, __m512, __m512);
extern __m512  __cdecl _mm512_mask_fnmsub_ps(__m512, __mmask16, __m512, __m512);
extern __m512  __cdecl _mm512_mask3_fnmsub_ps(__m512, __m512, __m512, __mmask16);
extern __m512  __cdecl _mm512_maskz_fnmsub_ps(__mmask16, __m512, __m512, __m512);
extern __m512  __cdecl _mm512_fnmsub_round_ps(__m512, __m512, __m512, const int );
extern __m512  __cdecl _mm512_mask_fnmsub_round_ps(__m512, __mmask16, __m512, __m512, const int );
extern __m512  __cdecl _mm512_mask3_fnmsub_round_ps(__m512, __m512, __m512, __mmask16, const int );
extern __m512  __cdecl _mm512_maskz_fnmsub_round_ps(__mmask16, __m512, __m512, __m512, const int );
extern __m512d __cdecl _mm512_fnmsub_pd(__m512d, __m512d, __m512d);
extern __m512d __cdecl _mm512_mask_fnmsub_pd(__m512d, __mmask8, __m512d, __m512d);
extern __m512d __cdecl _mm512_mask3_fnmsub_pd(__m512d, __m512d, __m512d, __mmask8);
extern __m512d __cdecl _mm512_maskz_fnmsub_pd(__mmask8, __m512d, __m512d, __m512d);
extern __m512d __cdecl _mm512_fnmsub_round_pd(__m512d, __m512d, __m512d, const int );
extern __m512d __cdecl _mm512_mask_fnmsub_round_pd(__m512d, __mmask8, __m512d, __m512d, const int );
extern __m512d __cdecl _mm512_mask3_fnmsub_round_pd(__m512d, __m512d, __m512d, __mmask8, const int );
extern __m512d __cdecl _mm512_maskz_fnmsub_round_pd(__mmask8, __m512d, __m512d, __m512d, const int );

extern __m512  __cdecl _mm512_sqrt_ps(__m512);
extern __m512d __cdecl _mm512_sqrt_pd(__m512d);
extern __m512  __cdecl _mm512_maskz_sqrt_ps(__mmask16, __m512);
extern __m512d __cdecl _mm512_maskz_sqrt_pd(__mmask8, __m512d);
extern __m512  __cdecl _mm512_mask_sqrt_ps(__m512, __mmask16, __m512);
extern __m512d __cdecl _mm512_mask_sqrt_pd(__m512d, __mmask8, __m512d);
extern __m512  __cdecl _mm512_sqrt_round_ps(__m512, const int );
extern __m512d __cdecl _mm512_sqrt_round_pd(__m512d, const int );
extern __m512  __cdecl _mm512_maskz_sqrt_round_ps(__mmask16, __m512, const int );
extern __m512d __cdecl _mm512_maskz_sqrt_round_pd(__mmask8, __m512d, const int );
extern __m512  __cdecl _mm512_mask_sqrt_round_ps(__m512, __mmask16, __m512, const int );
extern __m512d __cdecl _mm512_mask_sqrt_round_pd(__m512d, __mmask8, __m512d, const int );

extern __m512  __cdecl _mm512_abs_ps(__m512);
extern __m512  __cdecl _mm512_maskz_abs_ps(__mmask16, __m512);
extern __m512  __cdecl _mm512_mask_abs_ps(__m512, __mmask16, __m512);
extern __m512d __cdecl _mm512_abs_pd(__m512d);
extern __m512d __cdecl _mm512_maskz_abs_pd(__mmask8, __m512d);
extern __m512d __cdecl _mm512_mask_abs_pd(__m512d, __mmask8, __m512d);

extern __m512  __cdecl _mm512_max_ps(__m512, __m512);
extern __m512d __cdecl _mm512_max_pd(__m512d, __m512d);
extern __m512  __cdecl _mm512_maskz_max_ps(__mmask16, __m512, __m512);
extern __m512d __cdecl _mm512_maskz_max_pd(__mmask8, __m512d, __m512d);
extern __m512  __cdecl _mm512_mask_max_ps(__m512, __mmask16, __m512, __m512);
extern __m512d __cdecl _mm512_mask_max_pd(__m512d, __mmask8, __m512d, __m512d);
extern __m512  __cdecl _mm512_max_round_ps(__m512, __m512, const int );
extern __m512d __cdecl _mm512_max_round_pd(__m512d, __m512d, const int );
extern __m512  __cdecl _mm512_maskz_max_round_ps(__mmask16, __m512, __m512, const int );
extern __m512d __cdecl _mm512_maskz_max_round_pd(__mmask8, __m512d, __m512d, const int );
extern __m512  __cdecl _mm512_mask_max_round_ps(__m512, __mmask16, __m512, __m512, const int );
extern __m512d __cdecl _mm512_mask_max_round_pd(__m512d, __mmask8, __m512d, __m512d, const int );

extern __m512  __cdecl _mm512_min_ps(__m512, __m512);
extern __m512d __cdecl _mm512_min_pd(__m512d, __m512d);
extern __m512  __cdecl _mm512_maskz_min_ps(__mmask16, __m512, __m512);
extern __m512d __cdecl _mm512_maskz_min_pd(__mmask8, __m512d, __m512d);
extern __m512  __cdecl _mm512_mask_min_ps(__m512, __mmask16, __m512, __m512);
extern __m512d __cdecl _mm512_mask_min_pd(__m512d, __mmask8, __m512d, __m512d);
extern __m512  __cdecl _mm512_min_round_ps(__m512, __m512, const int );
extern __m512d __cdecl _mm512_min_round_pd(__m512d, __m512d, const int );
extern __m512  __cdecl _mm512_maskz_min_round_ps(__mmask16, __m512, __m512, const int );
extern __m512d __cdecl _mm512_maskz_min_round_pd(__mmask8, __m512d, __m512d, const int );
extern __m512  __cdecl _mm512_mask_min_round_ps(__m512, __mmask16, __m512, __m512, const int );
extern __m512d __cdecl _mm512_mask_min_round_pd(__m512d, __mmask8, __m512d, __m512d, const int );

extern __m512  __cdecl _mm512_rcp14_ps(__m512);
extern __m512d __cdecl _mm512_rcp14_pd(__m512d);
extern __m512  __cdecl _mm512_maskz_rcp14_ps(__mmask16, __m512);
extern __m512d __cdecl _mm512_maskz_rcp14_pd(__mmask8, __m512d);
extern __m512  __cdecl _mm512_mask_rcp14_ps(__m512, __mmask16, __m512);
extern __m512d __cdecl _mm512_mask_rcp14_pd(__m512d, __mmask8, __m512d);

extern __m512  __cdecl _mm512_rsqrt14_ps(__m512);
extern __m512d __cdecl _mm512_rsqrt14_pd(__m512d);
extern __m512  __cdecl _mm512_maskz_rsqrt14_ps(__mmask16, __m512);
extern __m512d __cdecl _mm512_maskz_rsqrt14_pd(__mmask8, __m512d);
extern __m512  __cdecl _mm512_mask_rsqrt14_ps(__m512, __mmask16, __m512);
extern __m512d __cdecl _mm512_mask_rsqrt14_pd(__m512d, __mmask8, __m512d);

extern __m512d __cdecl _mm512_cvtps_pd(__m256);
extern __m256  __cdecl _mm512_cvtpd_ps(__m512d);
extern __m512d __cdecl _mm512_maskz_cvtps_pd(__mmask8, __m256);
extern __m256  __cdecl _mm512_maskz_cvtpd_ps(__mmask8, __m512d);
extern __m512d __cdecl _mm512_mask_cvtps_pd(__m512d, __mmask8, __m256);
extern __m256  __cdecl _mm512_mask_cvtpd_ps(__m256, __mmask8, __m512d);
extern __m512d __cdecl _mm512_cvt_roundps_pd(__m256, const int );
extern __m256  __cdecl _mm512_cvt_roundpd_ps(__m512d, const int );
extern __m512d __cdecl _mm512_maskz_cvt_roundps_pd(__mmask8, __m256, const int );
extern __m256  __cdecl _mm512_maskz_cvt_roundpd_ps(__mmask8, __m512d, const int );
extern __m512d __cdecl _mm512_mask_cvt_roundps_pd(__m512d, __mmask8, __m256, const int );
extern __m256  __cdecl _mm512_mask_cvt_roundpd_ps(__m256, __mmask8, __m512d, const int );

extern __mmask16 __cdecl _mm512_cmp_ps_mask(__m512, __m512, const int);
extern __mmask16 __cdecl _mm512_mask_cmp_ps_mask(__mmask16, __m512, __m512, const int);
extern __mmask16 __cdecl _mm512_cmp_round_ps_mask(__m512, __m512, const int, const int );
extern __mmask16 __cdecl _mm512_mask_cmp_round_ps_mask(__mmask16, __m512, __m512, const int, const int );
extern __mmask8  __cdecl _mm512_cmp_pd_mask(__m512d, __m512d, const int);
extern __mmask8  __cdecl _mm512_mask_cmp_pd_mask(__mmask8, __m512d, __m512d, const int);
extern __mmask8  __cdecl _mm512_cmp_round_pd_mask(__m512d, __m512d, const int, const int );
extern __mmask8  __cdecl _mm512_mask_cmp_round_pd_mask(__mmask8, __m512d, __m512d, const int, const int );

extern __m512  __cdecl _mm512_broadcast_f32x2(__m128);
extern __m512  __cdecl _mm512_mask_broadcast_f32x2(__m512, __mmask16, __m128);
extern __m512  __cdecl _mm512_maskz_broadcast_f32x2(__mmask16, __m128);
extern __m512  __cdecl _mm512_broadcast_f32x4(__m128);
extern __m512  __cdecl _mm512_mask_broadcast_f32x4(__m512, __mmask16, __m128);
extern __m512  __cdecl _mm512_maskz_broadcast_f32x4(__mmask16, __m128);
extern __m512  __cdecl _mm512_broadcast_f32x8(__m256);
extern __m512  __cdecl _mm512_mask_broadcast_f32x8(__m512, __mmask16, __m256);
extern __m512  __cdecl _mm512_maskz_broadcast_f32x8(__mmask16, __m256);
extern __m512d __cdecl _mm512_broadcast_f64x2(__m128d);
extern __m512d __cdecl _mm512_mask_broadcast_f64x2(__m512d, __mmask8, __m128d);
extern __m512d __cdecl _mm512_maskz_broadcast_f64x2(__mmask8, __m128d);
extern __m512d __cdecl _mm512_broadcast_f64x4(__m256d);
extern __m512d __cdecl _mm512_mask_broadcast_f64x4(__m512d, __mmask8, __m256d);
extern __m512d __cdecl _mm512_maskz_broadcast_f64x4(__mmask8, __m256d);
extern __m512d __cdecl _mm512_broadcastsd_pd(__m128d);
extern __m512d __cdecl _mm512_mask_broadcastsd_pd(__m512d, __mmask8, __m128d);
extern __m512d __cdecl _mm512_maskz_broadcastsd_pd(__mmask8, __m128d);
extern __m512  __cdecl _mm512_broadcastss_ps(__m128);
extern __m512  __cdecl _mm512_mask_broadcastss_ps(__m512, __mmask16, __m128);
extern __m512  __cdecl _mm512_maskz_broadcastss_ps(__mmask16, __m128);

extern __m128  __cdecl _mm512_extractf32x4_ps(__m512, int);
extern __m128  __cdecl _mm512_mask_extractf32x4_ps(__m128, __mmask8, __m512, const int);
extern __m128  __cdecl _mm512_maskz_extractf32x4_ps(__mmask8, __m512, int);
extern __m256  __cdecl _mm512_extractf32x8_ps(__m512, int);
extern __m256  __cdecl _mm512_mask_extractf32x8_ps(__m256, __mmask8, __m512, const int);
extern __m256  __cdecl _mm512_maskz_extractf32x8_ps(__mmask8, __m512, int);
extern __m128d __cdecl _mm512_extractf64x2_pd(__m512d, int);
extern __m128d __cdecl _mm512_mask_extractf64x2_pd(__m128d, __mmask8, __m512d, const int);
extern __m128d __cdecl _mm512_maskz_extractf64x2_pd(__mmask8, __m512d, int);
extern __m256d __cdecl _mm512_extractf64x4_pd(__m512d, int);
extern __m256d __cdecl _mm512_mask_extractf64x4_pd(__m256d, __mmask8, __m512d, const int);
extern __m256d __cdecl _mm512_maskz_extractf64x4_pd(__mmask8, __m512d, int);

extern __m512  __cdecl _mm512_insertf32x4(__m512, __m128, int);
extern __m512  __cdecl _mm512_mask_insertf32x4(__m512, __mmask16, __m512, __m128, const int);
extern __m512  __cdecl _mm512_maskz_insertf32x4(__mmask16, __m512, __m128, int);
extern __m512  __cdecl _mm512_insertf32x8(__m512, __m256, int);
extern __m512  __cdecl _mm512_mask_insertf32x8(__m512, __mmask16, __m512, __m256, const int);
extern __m512  __cdecl _mm512_maskz_insertf32x8(__mmask16, __m512, __m256, int);
extern __m512d __cdecl _mm512_insertf64x2(__m512d, __m128d, int);
extern __m512d __cdecl _mm512_mask_insertf64x2(__m512d, __mmask8, __m512d, __m128d, const int);
extern __m512d __cdecl _mm512_maskz_insertf64x2(__mmask8, __m512d, __m128d, int);
extern __m512d __cdecl _mm512_insertf64x4(__m512d, __m256d, int);
extern __m512d __cdecl _mm512_mask_insertf64x4(__m512d, __mmask8, __m512d, __m256d, const int);
extern __m512d __cdecl _mm512_maskz_insertf64x4(__mmask8, __m512d, __m256d, int);

extern __m512  __cdecl _mm512_shuffle_f32x4(__m512, __m512, const int);
extern __m512  __cdecl _mm512_mask_shuffle_f32x4(__m512, __mmask16, __m512, __m512, const int);
extern __m512  __cdecl _mm512_maskz_shuffle_f32x4(__mmask16, __m512, __m512, const int);
extern __m512d __cdecl _mm512_shuffle_f64x2(__m512d, __m512d, const int);
extern __m512d __cdecl _mm512_mask_shuffle_f64x2(__m512d, __mmask8, __m512d, __m512d, const int);
extern __m512d __cdecl _mm512_maskz_shuffle_f64x2(__mmask8, __m512d, __m512d, const int);
extern __m512d __cdecl _mm512_shuffle_pd(__m512d, __m512d, const int);
extern __m512d __cdecl _mm512_mask_shuffle_pd(__m512d, __mmask8, __m512d, __m512d, const int);
extern __m512d __cdecl _mm512_maskz_shuffle_pd(__mmask8, __m512d, __m512d, const int);
extern __m512  __cdecl _mm512_shuffle_ps(__m512, __m512, const int);
extern __m512  __cdecl _mm512_mask_shuffle_ps(__m512, __mmask16, __m512, __m512, const int);
extern __m512  __cdecl _mm512_maskz_shuffle_ps(__mmask16, __m512, __m512, const int);

extern __mmask16 _mm512_cmpeq_ps_mask(__m512, __m512);
extern __mmask16 _mm512_cmple_ps_mask(__m512, __m512);
extern __mmask16 _mm512_cmplt_ps_mask(__m512, __m512);
extern __mmask16 _mm512_cmpneq_ps_mask(__m512, __m512);
extern __mmask16 _mm512_cmpnle_ps_mask(__m512, __m512);
extern __mmask16 _mm512_cmpnlt_ps_mask(__m512, __m512);
extern __mmask16 _mm512_cmpord_ps_mask(__m512, __m512);
extern __mmask16 _mm512_cmpunord_ps_mask(__m512, __m512);

extern __mmask16 _mm512_mask_cmpeq_ps_mask(__mmask16, __m512, __m512);
extern __mmask16 _mm512_mask_cmple_ps_mask(__mmask16, __m512, __m512);
extern __mmask16 _mm512_mask_cmplt_ps_mask(__mmask16, __m512, __m512);
extern __mmask16 _mm512_mask_cmpneq_ps_mask(__mmask16, __m512, __m512);
extern __mmask16 _mm512_mask_cmpnle_ps_mask(__mmask16, __m512, __m512);
extern __mmask16 _mm512_mask_cmpnlt_ps_mask(__mmask16, __m512, __m512);
extern __mmask16 _mm512_mask_cmpord_ps_mask(__mmask16, __m512, __m512);
extern __mmask16 _mm512_mask_cmpunord_ps_mask(__mmask16, __m512, __m512);

extern __mmask8 _mm512_cmpeq_pd_mask(__m512d, __m512d);
extern __mmask8 _mm512_cmple_pd_mask(__m512d, __m512d);
extern __mmask8 _mm512_cmplt_pd_mask(__m512d, __m512d);
extern __mmask8 _mm512_cmpneq_pd_mask(__m512d, __m512d);
extern __mmask8 _mm512_cmpnle_pd_mask(__m512d, __m512d);
extern __mmask8 _mm512_cmpnlt_pd_mask(__m512d, __m512d);
extern __mmask8 _mm512_cmpord_pd_mask(__m512d, __m512d);
extern __mmask8 _mm512_cmpunord_pd_mask(__m512d, __m512d);

extern __mmask8 _mm512_mask_cmpeq_pd_mask(__mmask8, __m512d, __m512d);
extern __mmask8 _mm512_mask_cmple_pd_mask(__mmask8, __m512d, __m512d);
extern __mmask8 _mm512_mask_cmplt_pd_mask(__mmask8, __m512d, __m512d);
extern __mmask8 _mm512_mask_cmpneq_pd_mask(__mmask8, __m512d, __m512d);
extern __mmask8 _mm512_mask_cmpnle_pd_mask(__mmask8, __m512d, __m512d);
extern __mmask8 _mm512_mask_cmpnlt_pd_mask(__mmask8, __m512d, __m512d);
extern __mmask8 _mm512_mask_cmpord_pd_mask(__mmask8, __m512d, __m512d);
extern __mmask8 _mm512_mask_cmpunord_pd_mask(__mmask8, __m512d, __m512d);


extern __m512i __cdecl _mm512_setzero_si512(void);

extern __m512i __cdecl _mm512_set_epi8(char , char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char );
extern __m512i __cdecl _mm512_set_epi16(short , short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short );
extern __m512i __cdecl _mm512_set_epi32(int , int, int, int, int, int, int, int, int, int, int, int, int, int, int, int );
extern __m512i __cdecl _mm512_set_epi64(__int64 , __int64, __int64, __int64, __int64, __int64, __int64, __int64 );

extern __m512i __cdecl _mm512_setr_epi8(char , char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char );
extern __m512i __cdecl _mm512_setr_epi16(short , short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short, short );
extern __m512i __cdecl _mm512_setr_epi32(int , int, int, int, int, int, int, int, int, int, int, int, int, int, int, int );
extern __m512i __cdecl _mm512_setr_epi64(__int64 , __int64, __int64, __int64, __int64, __int64, __int64, __int64 );

extern __m512i __cdecl _mm512_set1_epi8(char);
extern __m512i __cdecl _mm512_mask_set1_epi8(__m512i, __mmask64, char);
extern __m512i __cdecl _mm512_maskz_set1_epi8(__mmask64, char);
extern __m512i __cdecl _mm512_set1_epi16(short);
extern __m512i __cdecl _mm512_mask_set1_epi16(__m512i, __mmask32, short);
extern __m512i __cdecl _mm512_maskz_set1_epi16(__mmask32, short);
extern __m512i __cdecl _mm512_set1_epi32(int);
extern __m512i __cdecl _mm512_mask_set1_epi32(__m512i, __mmask16, int);
extern __m512i __cdecl _mm512_maskz_set1_epi32(__mmask16, int);
extern __m512i __cdecl _mm512_set1_epi64(__int64);
extern __m512i __cdecl _mm512_mask_set1_epi64(__m512i, __mmask8, __int64);
extern __m512i __cdecl _mm512_maskz_set1_epi64(__mmask8, __int64);

extern __m512i __cdecl _mm512_add_epi8(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_add_epi8(__m512i, __mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_add_epi8(__mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_add_epi16(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_add_epi16(__m512i, __mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_add_epi16(__mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_add_epi32(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_add_epi32(__m512i, __mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_add_epi32(__mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_add_epi64(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_add_epi64(__m512i, __mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_add_epi64(__mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_adds_epi8(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_adds_epi8(__m512i, __mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_adds_epi8(__mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_adds_epi16(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_adds_epi16(__m512i, __mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_adds_epi16(__mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_adds_epu8(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_adds_epu8(__m512i, __mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_adds_epu8(__mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_adds_epu16(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_adds_epu16(__m512i, __mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_adds_epu16(__mmask32, __m512i, __m512i);

extern __m512i __cdecl _mm512_abs_epi8(__m512i);
extern __m512i __cdecl _mm512_mask_abs_epi8(__m512i, __mmask64, __m512i);
extern __m512i __cdecl _mm512_maskz_abs_epi8(__mmask64, __m512i);
extern __m512i __cdecl _mm512_abs_epi16(__m512i);
extern __m512i __cdecl _mm512_mask_abs_epi16(__m512i, __mmask32, __m512i);
extern __m512i __cdecl _mm512_maskz_abs_epi16(__mmask32, __m512i);
extern __m512i __cdecl _mm512_abs_epi32(__m512i);
extern __m512i __cdecl _mm512_mask_abs_epi32(__m512i, __mmask16, __m512i);
extern __m512i __cdecl _mm512_maskz_abs_epi32(__mmask16, __m512i);
extern __m512i __cdecl _mm512_abs_epi64(__m512i);
extern __m512i __cdecl _mm512_mask_abs_epi64(__m512i, __mmask8, __m512i);
extern __m512i __cdecl _mm512_maskz_abs_epi64(__mmask8, __m512i);

extern __m512i  __cdecl _mm512_broadcast_i32x2(__m128i);
extern __m512i  __cdecl _mm512_mask_broadcast_i32x2(__m512i, __mmask16, __m128i);
extern __m512i  __cdecl _mm512_maskz_broadcast_i32x2(__mmask16, __m128i);
extern __m512i  __cdecl _mm512_broadcast_i32x4(__m128i);
extern __m512i  __cdecl _mm512_mask_broadcast_i32x4(__m512i, __mmask16, __m128i);
extern __m512i  __cdecl _mm512_maskz_broadcast_i32x4(__mmask16, __m128i);
extern __m512i  __cdecl _mm512_broadcast_i32x8(__m256i);
extern __m512i  __cdecl _mm512_mask_broadcast_i32x8(__m512i, __mmask16, __m256i);
extern __m512i  __cdecl _mm512_maskz_broadcast_i32x8(__mmask16, __m256i);
extern __m512i  __cdecl _mm512_broadcast_i64x2(__m128i);
extern __m512i  __cdecl _mm512_mask_broadcast_i64x2(__m512i, __mmask8, __m128i);
extern __m512i  __cdecl _mm512_maskz_broadcast_i64x2(__mmask8, __m128i);
extern __m512i  __cdecl _mm512_broadcast_i64x4(__m256i);
extern __m512i  __cdecl _mm512_mask_broadcast_i64x4(__m512i, __mmask8, __m256i);
extern __m512i  __cdecl _mm512_maskz_broadcast_i64x4(__mmask8, __m256i);
extern __m512i __cdecl _mm512_broadcastb_epi8(__m128i);
extern __m512i __cdecl _mm512_mask_broadcastb_epi8(__m512i, __mmask64, __m128i);
extern __m512i __cdecl _mm512_maskz_broadcastb_epi8(__mmask64, __m128i);
extern __m512i __cdecl _mm512_broadcastw_epi16(__m128i);
extern __m512i __cdecl _mm512_mask_broadcastw_epi16(__m512i, __mmask32, __m128i);
extern __m512i __cdecl _mm512_maskz_broadcastw_epi16(__mmask32, __m128i);
extern __m512i __cdecl _mm512_broadcastd_epi32(__m128i);
extern __m512i __cdecl _mm512_mask_broadcastd_epi32(__m512i, __mmask16, __m128i);
extern __m512i __cdecl _mm512_maskz_broadcastd_epi32(__mmask16, __m128i);
extern __m512i __cdecl _mm512_broadcastq_epi64(__m128i);
extern __m512i __cdecl _mm512_mask_broadcastq_epi64(__m512i, __mmask8, __m128i);
extern __m512i __cdecl _mm512_maskz_broadcastq_epi64(__mmask8, __m128i);
extern __m512i __cdecl _mm512_broadcastmw_epi32(__mmask16);
extern __m512i __cdecl _mm512_broadcastmb_epi64(__mmask8);

extern __m512i __cdecl _mm512_sub_epi8(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_sub_epi8(__m512i, __mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_sub_epi8(__mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_sub_epi16(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_sub_epi16(__m512i, __mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_sub_epi16(__mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_sub_epi32(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_sub_epi32(__m512i, __mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_sub_epi32(__mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_sub_epi64(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_sub_epi64(__m512i, __mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_sub_epi64(__mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_subs_epi8(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_subs_epi8(__m512i, __mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_subs_epi8(__mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_subs_epi16(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_subs_epi16(__m512i, __mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_subs_epi16(__mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_subs_epu8(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_subs_epu8(__m512i, __mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_subs_epu8(__mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_subs_epu16(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_subs_epu16(__m512i, __mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_subs_epu16(__mmask32, __m512i, __m512i);

extern __m512i __cdecl _mm512_max_epi8(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_max_epi8(__m512i, __mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_max_epi8(__mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_max_epi16(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_max_epi16(__m512i, __mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_max_epi16(__mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_max_epi32(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_max_epi32(__m512i, __mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_max_epi32(__mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_max_epi64(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_max_epi64(__m512i, __mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_max_epi64(__mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_max_epu8(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_max_epu8(__m512i, __mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_max_epu8(__mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_max_epu16(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_max_epu16(__m512i, __mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_max_epu16(__mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_max_epu32(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_max_epu32(__m512i, __mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_max_epu32(__mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_max_epu64(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_max_epu64(__m512i, __mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_max_epu64(__mmask8, __m512i, __m512i);

extern __m512i __cdecl _mm512_min_epi8(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_min_epi8(__m512i, __mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_min_epi8(__mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_min_epi16(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_min_epi16(__m512i, __mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_min_epi16(__mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_min_epi32(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_min_epi32(__m512i, __mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_min_epi32(__mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_min_epi64(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_min_epi64(__m512i, __mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_min_epi64(__mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_min_epu8(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_min_epu8(__m512i, __mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_min_epu8(__mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_min_epu16(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_min_epu16(__m512i, __mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_min_epu16(__mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_min_epu32(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_min_epu32(__m512i, __mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_min_epu32(__mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_min_epu64(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_min_epu64(__m512i, __mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_min_epu64(__mmask8, __m512i, __m512i);

extern __m512i __cdecl _mm512_mul_epi32(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_mul_epi32(__m512i, __mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_mul_epi32(__mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_mul_epu32(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_mul_epu32(__m512i, __mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_mul_epu32(__mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_mulhi_epi16(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_mulhi_epi16(__m512i, __mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_mulhi_epi16(__mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_mulhi_epu16(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_mulhi_epu16(__m512i, __mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_mulhi_epu16(__mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_mullo_epi16(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_mullo_epi16(__m512i, __mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_mullo_epi16(__mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_mullo_epi32(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_mullo_epi32(__m512i, __mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_mullo_epi32(__mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_mullo_epi64(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_mullo_epi64(__m512i, __mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_mullo_epi64(__mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_mullox_epi64(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_mullox_epi64(__m512i, __mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_mulhrs_epi16(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_mulhrs_epi16(__m512i, __mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_mulhrs_epi16(__mmask32, __m512i, __m512i);

extern __m512i __cdecl _mm512_load_epi32(void const*);
extern __m512i __cdecl _mm512_mask_load_epi32(__m512i, __mmask16, void const*);
extern __m512i __cdecl _mm512_maskz_load_epi32(__mmask16, void const*);
extern __m512i __cdecl _mm512_load_epi64(void const*);
extern __m512i __cdecl _mm512_mask_load_epi64(__m512i, __mmask8, void const*);
extern __m512i __cdecl _mm512_maskz_load_epi64(__mmask8, void const*);
extern __m512i __cdecl _mm512_loadu_epi8(void const*);
extern __m512i __cdecl _mm512_mask_loadu_epi8(__m512i, __mmask64, void const*);
extern __m512i __cdecl _mm512_maskz_loadu_epi8(__mmask64, void const*);
extern __m512i __cdecl _mm512_loadu_epi16(void const*);
extern __m512i __cdecl _mm512_mask_loadu_epi16(__m512i, __mmask32, void const*);
extern __m512i __cdecl _mm512_maskz_loadu_epi16(__mmask32, void const*);
extern __m512i __cdecl _mm512_loadu_epi32(void const*);
extern __m512i __cdecl _mm512_mask_loadu_epi32(__m512i, __mmask16, void const*);
extern __m512i __cdecl _mm512_maskz_loadu_epi32(__mmask16, void const*);
extern __m512i __cdecl _mm512_loadu_epi64(void const*);
extern __m512i __cdecl _mm512_mask_loadu_epi64(__m512i, __mmask8, void const*);
extern __m512i __cdecl _mm512_maskz_loadu_epi64(__mmask8, void const*);

extern void    __cdecl _mm512_store_epi32(void*, __m512i);
extern void    __cdecl _mm512_mask_store_epi32(void*, __mmask16, __m512i);
extern void    __cdecl _mm512_store_epi64(void*, __m512i);
extern void    __cdecl _mm512_mask_store_epi64(void*, __mmask8, __m512i);
extern void    __cdecl _mm512_storeu_epi8(void*, __m512i);
extern void    __cdecl _mm512_mask_storeu_epi8(void*, __mmask64, __m512i);
extern void    __cdecl _mm512_storeu_epi16(void*, __m512i);
extern void    __cdecl _mm512_mask_storeu_epi16(void*, __mmask32, __m512i);
extern void    __cdecl _mm512_storeu_epi32(void*, __m512i);
extern void    __cdecl _mm512_mask_storeu_epi32(void*, __mmask16, __m512i);
extern void    __cdecl _mm512_storeu_epi64(void*, __m512i);
extern void    __cdecl _mm512_mask_storeu_epi64(void*, __mmask8, __m512i);

extern __m128i __cdecl _mm512_extracti32x4_epi32(__m512i, int);
extern __m128i __cdecl _mm512_mask_extracti32x4_epi32(__m128i, __mmask8, __m512i, int);
extern __m128i __cdecl _mm512_maskz_extracti32x4_epi32(__mmask8, __m512i, int);
extern __m256i __cdecl _mm512_extracti32x8_epi32(__m512i, int);
extern __m256i __cdecl _mm512_mask_extracti32x8_epi32(__m256i, __mmask8, __m512i, int);
extern __m256i __cdecl _mm512_maskz_extracti32x8_epi32(__mmask8, __m512i, int);
extern __m128i __cdecl _mm512_extracti64x2_epi64(__m512i, int);
extern __m128i __cdecl _mm512_mask_extracti64x2_epi64(__m128i, __mmask8, __m512i, int);
extern __m128i __cdecl _mm512_maskz_extracti64x2_epi64(__mmask8, __m512i, int);
extern __m256i __cdecl _mm512_extracti64x4_epi64(__m512i, int);
extern __m256i __cdecl _mm512_mask_extracti64x4_epi64(__m256i, __mmask8, __m512i, int);
extern __m256i __cdecl _mm512_maskz_extracti64x4_epi64(__mmask8, __m512i, int);

extern __m512i __cdecl _mm512_inserti32x4(__m512i, __m128i, int);
extern __m512i __cdecl _mm512_mask_inserti32x4(__m512i, __mmask16, __m512i, __m128i, int);
extern __m512i __cdecl _mm512_maskz_inserti32x4(__mmask16, __m512i, __m128i, int);
extern __m512i __cdecl _mm512_inserti32x8(__m512i, __m256i, int);
extern __m512i __cdecl _mm512_mask_inserti32x8(__m512i, __mmask16, __m512i, __m256i, int);
extern __m512i __cdecl _mm512_maskz_inserti32x8(__mmask16, __m512i, __m256i, int);
extern __m512i __cdecl _mm512_inserti64x2(__m512i, __m128i, int);
extern __m512i __cdecl _mm512_mask_inserti64x2(__m512i, __mmask8, __m512i, __m128i, int);
extern __m512i __cdecl _mm512_maskz_inserti64x2(__mmask8, __m512i, __m128i, int);
extern __m512i __cdecl _mm512_inserti64x4(__m512i, __m256i, int);
extern __m512i __cdecl _mm512_mask_inserti64x4(__m512i, __mmask8, __m512i, __m256i, int);
extern __m512i __cdecl _mm512_maskz_inserti64x4(__mmask8, __m512i, __m256i, int);

extern __m512i __cdecl _mm512_shuffle_epi8(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_shuffle_epi8(__m512i, __mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_shuffle_epi8(__mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_shuffle_epi32(__m512i, int);
extern __m512i __cdecl _mm512_mask_shuffle_epi32(__m512i, __mmask16, __m512i, int);
extern __m512i __cdecl _mm512_maskz_shuffle_epi32(__mmask16, __m512i, int);
extern __m512i __cdecl _mm512_shuffle_i32x4(__m512i, __m512i, const int);
extern __m512i __cdecl _mm512_mask_shuffle_i32x4(__m512i, __mmask16, __m512i, __m512i, const int);
extern __m512i __cdecl _mm512_maskz_shuffle_i32x4(__mmask16, __m512i, __m512i, const int);
extern __m512i __cdecl _mm512_shuffle_i64x2(__m512i, __m512i, const int);
extern __m512i __cdecl _mm512_mask_shuffle_i64x2(__m512i, __mmask8, __m512i, __m512i, const int);
extern __m512i __cdecl _mm512_maskz_shuffle_i64x2(__mmask8, __m512i, __m512i, const int);
extern __m512i __cdecl _mm512_shufflehi_epi16(__m512i, int);
extern __m512i __cdecl _mm512_mask_shufflehi_epi16(__m512i, __mmask32, __m512i, int);
extern __m512i __cdecl _mm512_maskz_shufflehi_epi16(__mmask32, __m512i, int);
extern __m512i __cdecl _mm512_shufflelo_epi16(__m512i, int);
extern __m512i __cdecl _mm512_mask_shufflelo_epi16(__m512i, __mmask32, __m512i, int);
extern __m512i __cdecl _mm512_maskz_shufflelo_epi16(__mmask32, __m512i, int);

extern __m512  __cdecl _mm512_mask_mov_ps(__m512, __mmask16, __m512);
extern __m512  __cdecl _mm512_maskz_mov_ps(__mmask16, __m512);
extern __m512d __cdecl _mm512_mask_mov_pd(__m512d, __mmask8, __m512d);
extern __m512d __cdecl _mm512_maskz_mov_pd(__mmask8, __m512d);
extern __m512i __cdecl _mm512_mask_mov_epi8(__m512i, __mmask64, __m512i);
extern __m512i __cdecl _mm512_maskz_mov_epi8(__mmask64, __m512i);
extern __m512i __cdecl _mm512_mask_mov_epi16(__m512i, __mmask32, __m512i);
extern __m512i __cdecl _mm512_maskz_mov_epi16(__mmask32, __m512i);
extern __m512i __cdecl _mm512_mask_mov_epi32(__m512i, __mmask16, __m512i);
extern __m512i __cdecl _mm512_maskz_mov_epi32(__mmask16, __m512i);
extern __m512i __cdecl _mm512_mask_mov_epi64(__m512i, __mmask8, __m512i);
extern __m512i __cdecl _mm512_maskz_mov_epi64(__mmask8, __m512i);
extern __m512d __cdecl _mm512_movedup_pd(__m512d);
extern __m512d __cdecl _mm512_mask_movedup_pd(__m512d, __mmask8, __m512d);
extern __m512d __cdecl _mm512_maskz_movedup_pd(__mmask8, __m512d);
extern __m512  __cdecl _mm512_movehdup_ps(__m512);
extern __m512  __cdecl _mm512_mask_movehdup_ps(__m512, __mmask16, __m512);
extern __m512  __cdecl _mm512_maskz_movehdup_ps(__mmask16, __m512);
extern __m512  __cdecl _mm512_moveldup_ps(__m512);
extern __m512  __cdecl _mm512_mask_moveldup_ps(__m512, __mmask16, __m512);
extern __m512  __cdecl _mm512_maskz_moveldup_ps(__mmask16, __m512);

extern __m512i __cdecl _mm512_movm_epi8(__mmask64);
extern __m512i __cdecl _mm512_movm_epi16(__mmask32);
extern __m512i __cdecl _mm512_movm_epi32(__mmask16);
extern __m512i __cdecl _mm512_movm_epi64(__mmask8);
extern __mmask64 __cdecl _mm512_movepi8_mask(__m512i);
extern __mmask32 __cdecl _mm512_movepi16_mask(__m512i);
extern __mmask16 __cdecl _mm512_movepi32_mask(__m512i);
extern __mmask8  __cdecl _mm512_movepi64_mask(__m512i);

extern __m512i __cdecl _mm512_alignr_epi8(__m512i, __m512i, const int);
extern __m512i __cdecl _mm512_mask_alignr_epi8(__m512i, __mmask64, __m512i, __m512i, const int);
extern __m512i __cdecl _mm512_maskz_alignr_epi8(__mmask64, __m512i, __m512i, const int);
extern __m512i __cdecl _mm512_alignr_epi32(__m512i, __m512i, const int);
extern __m512i __cdecl _mm512_mask_alignr_epi32(__m512i, __mmask16, __m512i, __m512i, const int );
extern __m512i __cdecl _mm512_maskz_alignr_epi32(__mmask16, __m512i, __m512i, const int);
extern __m512i __cdecl _mm512_alignr_epi64(__m512i, __m512i, const int);
extern __m512i __cdecl _mm512_mask_alignr_epi64(__m512i, __mmask8, __m512i, __m512i, const int);
extern __m512i __cdecl _mm512_maskz_alignr_epi64(__mmask8, __m512i, __m512i, const int);

extern __m512d __cdecl _mm512_and_pd(__m512d, __m512d);
extern __m512d __cdecl _mm512_mask_and_pd(__m512d, __mmask8, __m512d, __m512d);
extern __m512d __cdecl _mm512_maskz_and_pd(__mmask8, __m512d, __m512d);
extern __m512  __cdecl _mm512_and_ps(__m512, __m512);
extern __m512  __cdecl _mm512_mask_and_ps(__m512, __mmask16, __m512, __m512);
extern __m512  __cdecl _mm512_maskz_and_ps(__mmask16, __m512, __m512);
extern __m512i __cdecl _mm512_and_epi32(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_and_epi32(__m512i, __mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_and_epi32(__mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_and_epi64(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_and_epi64(__m512i, __mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_and_epi64(__mmask8, __m512i, __m512i);

extern __m512d __cdecl _mm512_andnot_pd(__m512d, __m512d);
extern __m512d __cdecl _mm512_mask_andnot_pd(__m512d, __mmask8, __m512d, __m512d);
extern __m512d __cdecl _mm512_maskz_andnot_pd(__mmask8, __m512d, __m512d);
extern __m512  __cdecl _mm512_andnot_ps(__m512, __m512);
extern __m512  __cdecl _mm512_mask_andnot_ps(__m512, __mmask16, __m512, __m512);
extern __m512  __cdecl _mm512_maskz_andnot_ps(__mmask16, __m512, __m512);
extern __m512i __cdecl _mm512_andnot_epi32(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_andnot_epi32(__m512i, __mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_andnot_epi32(__mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_andnot_epi64(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_andnot_epi64(__m512i, __mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_andnot_epi64(__mmask8, __m512i, __m512i);

extern __m512d __cdecl _mm512_or_pd(__m512d, __m512d);
extern __m512d __cdecl _mm512_mask_or_pd(__m512d, __mmask8, __m512d, __m512d);
extern __m512d __cdecl _mm512_maskz_or_pd(__mmask8, __m512d, __m512d);
extern __m512  __cdecl _mm512_or_ps(__m512, __m512);
extern __m512  __cdecl _mm512_mask_or_ps(__m512, __mmask16, __m512, __m512);
extern __m512  __cdecl _mm512_maskz_or_ps(__mmask16, __m512, __m512);
extern __m512i __cdecl _mm512_or_epi32(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_or_epi32(__m512i, __mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_or_epi32(__mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_or_epi64(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_or_epi64(__m512i, __mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_or_epi64(__mmask8, __m512i, __m512i);

extern __m512d __cdecl _mm512_xor_pd(__m512d, __m512d);
extern __m512d __cdecl _mm512_mask_xor_pd(__m512d, __mmask8, __m512d, __m512d);
extern __m512d __cdecl _mm512_maskz_xor_pd(__mmask8, __m512d, __m512d);
extern __m512  __cdecl _mm512_xor_ps(__m512, __m512);
extern __m512  __cdecl _mm512_mask_xor_ps(__m512, __mmask16, __m512, __m512);
extern __m512  __cdecl _mm512_maskz_xor_ps(__mmask16, __m512, __m512);
extern __m512i __cdecl _mm512_xor_epi32(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_xor_epi32(__m512i, __mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_xor_epi32(__mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_xor_epi64(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_xor_epi64(__m512i, __mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_xor_epi64(__mmask8, __m512i, __m512i);

extern __m512  __cdecl _mm512_mask_blend_ps(__mmask16, __m512, __m512);
extern __m512d __cdecl _mm512_mask_blend_pd(__mmask8, __m512d, __m512d);
extern __m512i __cdecl _mm512_mask_blend_epi8(__mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_mask_blend_epi16(__mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_mask_blend_epi32(__mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_mask_blend_epi64(__mmask8, __m512i, __m512i);

extern __m512i __cdecl _mm512_sll_epi16(__m512i, __m128i);
extern __m512i __cdecl _mm512_sll_epi32(__m512i, __m128i);
extern __m512i __cdecl _mm512_sll_epi64(__m512i, __m128i);
extern __m512i __cdecl _mm512_slli_epi16(__m512i, unsigned int);
extern __m512i __cdecl _mm512_slli_epi32(__m512i, unsigned int);
extern __m512i __cdecl _mm512_slli_epi64(__m512i, unsigned int);
extern __m512i __cdecl _mm512_sllv_epi16(__m512i, __m512i);
extern __m512i __cdecl _mm512_sllv_epi32(__m512i, __m512i);
extern __m512i __cdecl _mm512_sllv_epi64(__m512i, __m512i);

extern __m512i __cdecl _mm512_mask_sll_epi16(__m512i, __mmask32, __m512i, __m128i);
extern __m512i __cdecl _mm512_maskz_sll_epi16(__mmask32, __m512i, __m128i);
extern __m512i __cdecl _mm512_mask_sll_epi32(__m512i, __mmask16, __m512i, __m128i);
extern __m512i __cdecl _mm512_maskz_sll_epi32(__mmask16, __m512i, __m128i);
extern __m512i __cdecl _mm512_mask_sll_epi64(__m512i, __mmask8, __m512i, __m128i);
extern __m512i __cdecl _mm512_maskz_sll_epi64(__mmask8, __m512i, __m128i);
extern __m512i __cdecl _mm512_mask_slli_epi16(__m512i, __mmask32, __m512i, unsigned int);
extern __m512i __cdecl _mm512_maskz_slli_epi16(__mmask32, __m512i, unsigned int);
extern __m512i __cdecl _mm512_mask_slli_epi32(__m512i, __mmask16, __m512i, unsigned int);
extern __m512i __cdecl _mm512_maskz_slli_epi32(__mmask16, __m512i, unsigned int);
extern __m512i __cdecl _mm512_mask_slli_epi64(__m512i, __mmask8, __m512i, unsigned int);
extern __m512i __cdecl _mm512_maskz_slli_epi64(__mmask8, __m512i, unsigned int);
extern __m512i __cdecl _mm512_mask_sllv_epi16(__m512i, __mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_sllv_epi16(__mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_mask_sllv_epi32(__m512i, __mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_sllv_epi32(__mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_mask_sllv_epi64(__m512i, __mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_sllv_epi64(__mmask8, __m512i, __m512i);

extern __m512i __cdecl _mm512_srl_epi16(__m512i, __m128i);
extern __m512i __cdecl _mm512_srl_epi32(__m512i, __m128i);
extern __m512i __cdecl _mm512_srl_epi64(__m512i, __m128i);
extern __m512i __cdecl _mm512_srli_epi16(__m512i, int);
extern __m512i __cdecl _mm512_srli_epi32(__m512i, unsigned int);
extern __m512i __cdecl _mm512_srli_epi64(__m512i, unsigned int);
extern __m512i __cdecl _mm512_srlv_epi16(__m512i, __m512i);
extern __m512i __cdecl _mm512_srlv_epi32(__m512i, __m512i);
extern __m512i __cdecl _mm512_srlv_epi64(__m512i, __m512i);

extern __m512i __cdecl _mm512_mask_srl_epi16(__m512i, __mmask32, __m512i, __m128i);
extern __m512i __cdecl _mm512_maskz_srl_epi16(__mmask32, __m512i, __m128i);
extern __m512i __cdecl _mm512_mask_srl_epi32(__m512i, __mmask16, __m512i, __m128i);
extern __m512i __cdecl _mm512_maskz_srl_epi32(__mmask16, __m512i, __m128i);
extern __m512i __cdecl _mm512_mask_srl_epi64(__m512i, __mmask8, __m512i, __m128i);
extern __m512i __cdecl _mm512_maskz_srl_epi64(__mmask8, __m512i, __m128i);
extern __m512i __cdecl _mm512_mask_srli_epi16(__m512i, __mmask32, __m512i, unsigned int);
extern __m512i __cdecl _mm512_maskz_srli_epi16(__mmask32, __m512i, int);
extern __m512i __cdecl _mm512_mask_srli_epi32(__m512i, __mmask16, __m512i, unsigned int);
extern __m512i __cdecl _mm512_maskz_srli_epi32(__mmask16, __m512i, unsigned int);
extern __m512i __cdecl _mm512_mask_srli_epi64(__m512i, __mmask8, __m512i, unsigned int);
extern __m512i __cdecl _mm512_maskz_srli_epi64(__mmask8, __m512i, unsigned int);
extern __m512i __cdecl _mm512_mask_srlv_epi16(__m512i, __mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_srlv_epi16(__mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_mask_srlv_epi32(__m512i, __mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_srlv_epi32(__mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_mask_srlv_epi64(__m512i, __mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_srlv_epi64(__mmask8, __m512i, __m512i);

extern __m512i __cdecl _mm512_sra_epi16(__m512i, __m128i);
extern __m512i __cdecl _mm512_sra_epi32(__m512i, __m128i);
extern __m512i __cdecl _mm512_sra_epi64(__m512i, __m128i);
extern __m512i __cdecl _mm512_srai_epi16(__m512i, unsigned int);
extern __m512i __cdecl _mm512_srai_epi32(__m512i, unsigned int);
extern __m512i __cdecl _mm512_srai_epi64(__m512i, unsigned int);
extern __m512i __cdecl _mm512_srav_epi16(__m512i, __m512i);
extern __m512i __cdecl _mm512_srav_epi32(__m512i, __m512i);
extern __m512i __cdecl _mm512_srav_epi64(__m512i, __m512i);

extern __m512i __cdecl _mm512_mask_sra_epi16(__m512i, __mmask32, __m512i, __m128i);
extern __m512i __cdecl _mm512_maskz_sra_epi16(__mmask32, __m512i, __m128i);
extern __m512i __cdecl _mm512_mask_sra_epi32(__m512i, __mmask16, __m512i, __m128i);
extern __m512i __cdecl _mm512_maskz_sra_epi32(__mmask16, __m512i, __m128i);
extern __m512i __cdecl _mm512_mask_sra_epi64(__m512i, __mmask8, __m512i, __m128i);
extern __m512i __cdecl _mm512_maskz_sra_epi64(__mmask8, __m512i, __m128i);
extern __m512i __cdecl _mm512_mask_srai_epi16(__m512i, __mmask32, __m512i, unsigned int);
extern __m512i __cdecl _mm512_maskz_srai_epi16(__mmask32, __m512i, unsigned int);
extern __m512i __cdecl _mm512_mask_srai_epi32(__m512i, __mmask16, __m512i, unsigned int);
extern __m512i __cdecl _mm512_maskz_srai_epi32(__mmask16, __m512i, unsigned int);
extern __m512i __cdecl _mm512_mask_srai_epi64(__m512i, __mmask8, __m512i, unsigned int);
extern __m512i __cdecl _mm512_maskz_srai_epi64(__mmask8, __m512i, unsigned int);
extern __m512i __cdecl _mm512_mask_srav_epi16(__m512i, __mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_srav_epi16(__mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_mask_srav_epi32(__m512i, __mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_srav_epi32(__mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_mask_srav_epi64(__m512i, __mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_srav_epi64(__mmask8, __m512i, __m512i);

extern __m512i __cdecl _mm512_bslli_epi128(__m512i, int);
extern __m512i __cdecl _mm512_bsrli_epi128(__m512i, int);

extern __m512i __cdecl _mm512_rol_epi32(__m512i, const int);
extern __m512i __cdecl _mm512_mask_rol_epi32(__m512i, __mmask16, __m512i, const int);
extern __m512i __cdecl _mm512_maskz_rol_epi32(__mmask16, __m512i, const int);
extern __m512i __cdecl _mm512_rol_epi64(__m512i, const int);
extern __m512i __cdecl _mm512_mask_rol_epi64(__m512i, __mmask8, __m512i, const int);
extern __m512i __cdecl _mm512_maskz_rol_epi64(__mmask8, __m512i, const int);
extern __m512i __cdecl _mm512_rolv_epi32(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_rolv_epi32(__m512i, __mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_rolv_epi32(__mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_rolv_epi64(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_rolv_epi64(__m512i, __mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_rolv_epi64(__mmask8, __m512i, __m512i);

extern __m512i __cdecl _mm512_ror_epi32(__m512i, int);
extern __m512i __cdecl _mm512_mask_ror_epi32(__m512i, __mmask16, __m512i, int);
extern __m512i __cdecl _mm512_maskz_ror_epi32(__mmask16, __m512i, int);
extern __m512i __cdecl _mm512_ror_epi64(__m512i, int);
extern __m512i __cdecl _mm512_mask_ror_epi64(__m512i, __mmask8, __m512i, int);
extern __m512i __cdecl _mm512_maskz_ror_epi64(__mmask8, __m512i, int);
extern __m512i __cdecl _mm512_rorv_epi32(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_rorv_epi32(__m512i, __mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_rorv_epi32(__mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_rorv_epi64(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_rorv_epi64(__m512i, __mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_rorv_epi64(__mmask8, __m512i, __m512i);

extern __m512d __cdecl _mm512_unpackhi_pd(__m512d, __m512d);
extern __m512d __cdecl _mm512_mask_unpackhi_pd(__m512d, __mmask8, __m512d, __m512d);
extern __m512d __cdecl _mm512_maskz_unpackhi_pd(__mmask8, __m512d, __m512d);
extern __m512  __cdecl _mm512_unpackhi_ps(__m512, __m512);
extern __m512  __cdecl _mm512_mask_unpackhi_ps(__m512, __mmask16, __m512, __m512);
extern __m512  __cdecl _mm512_maskz_unpackhi_ps(__mmask16, __m512, __m512);
extern __m512d __cdecl _mm512_unpacklo_pd(__m512d, __m512d);
extern __m512d __cdecl _mm512_mask_unpacklo_pd(__m512d, __mmask8, __m512d, __m512d);
extern __m512d __cdecl _mm512_maskz_unpacklo_pd(__mmask8, __m512d, __m512d);
extern __m512  __cdecl _mm512_unpacklo_ps(__m512, __m512);
extern __m512  __cdecl _mm512_mask_unpacklo_ps(__m512, __mmask16, __m512, __m512);
extern __m512  __cdecl _mm512_maskz_unpacklo_ps(__mmask16, __m512, __m512);
extern __m512i __cdecl _mm512_unpackhi_epi8(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_unpackhi_epi8(__m512i, __mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_unpackhi_epi8(__mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_unpackhi_epi16(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_unpackhi_epi16(__m512i, __mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_unpackhi_epi16(__mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_unpackhi_epi32(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_unpackhi_epi32(__m512i, __mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_unpackhi_epi32(__mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_unpackhi_epi64(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_unpackhi_epi64(__m512i, __mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_unpackhi_epi64(__mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_unpacklo_epi8(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_unpacklo_epi8(__m512i, __mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_unpacklo_epi8(__mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_unpacklo_epi16(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_unpacklo_epi16(__m512i, __mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_unpacklo_epi16(__mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_unpacklo_epi32(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_unpacklo_epi32(__m512i, __mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_unpacklo_epi32(__mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_unpacklo_epi64(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_unpacklo_epi64(__m512i, __mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_unpacklo_epi64(__mmask8, __m512i, __m512i);

extern __m512  __cdecl _mm512_getexp_ps(__m512);
extern __m512  __cdecl _mm512_mask_getexp_ps(__m512, __mmask16, __m512);
extern __m512  __cdecl _mm512_maskz_getexp_ps(__mmask16, __m512);
extern __m512  __cdecl _mm512_getexp_round_ps(__m512, int);
extern __m512  __cdecl _mm512_mask_getexp_round_ps(__m512, __mmask16, __m512, int);
extern __m512  __cdecl _mm512_maskz_getexp_round_ps(__mmask16, __m512, int);
extern __m512d __cdecl _mm512_getexp_pd(__m512d);
extern __m512d __cdecl _mm512_mask_getexp_pd(__m512d, __mmask8, __m512d);
extern __m512d __cdecl _mm512_maskz_getexp_pd(__mmask8, __m512d);
extern __m512d __cdecl _mm512_getexp_round_pd(__m512d, int);
extern __m512d __cdecl _mm512_mask_getexp_round_pd(__m512d, __mmask8, __m512d, int);
extern __m512d __cdecl _mm512_maskz_getexp_round_pd(__mmask8, __m512d, int);

extern __m512  __cdecl _mm512_getmant_ps(__m512, int, int);
extern __m512  __cdecl _mm512_mask_getmant_ps(__m512, __mmask16, __m512, int, int);
extern __m512  __cdecl _mm512_maskz_getmant_ps(__mmask16, __m512, int, int);
extern __m512  __cdecl _mm512_getmant_round_ps(__m512, int, int, int);
extern __m512  __cdecl _mm512_mask_getmant_round_ps(__m512, __mmask16, __m512, int, int, int);
extern __m512  __cdecl _mm512_maskz_getmant_round_ps(__mmask16, __m512, int, int, int);
extern __m512d __cdecl _mm512_getmant_pd(__m512d, int, int);
extern __m512d __cdecl _mm512_mask_getmant_pd(__m512d, __mmask8, __m512d, int, int);
extern __m512d __cdecl _mm512_maskz_getmant_pd(__mmask8, __m512d, int, int);
extern __m512d __cdecl _mm512_getmant_round_pd(__m512d, int, int, int);
extern __m512d __cdecl _mm512_mask_getmant_round_pd(__m512d, __mmask8, __m512d, int, int, int);
extern __m512d __cdecl _mm512_maskz_getmant_round_pd(__mmask8, __m512d, int, int, int);

extern __m512d __cdecl _mm512_permute_pd(__m512d, const int);
extern __m512d __cdecl _mm512_mask_permute_pd(__m512d, __mmask8, __m512d, const int);
extern __m512d __cdecl _mm512_maskz_permute_pd(__mmask8, __m512d, const int);
extern __m512  __cdecl _mm512_permute_ps(__m512, const int);
extern __m512  __cdecl _mm512_mask_permute_ps(__m512, __mmask16, __m512, const int);
extern __m512  __cdecl _mm512_maskz_permute_ps(__mmask16, __m512, const int);
extern __m512d __cdecl _mm512_permutevar_pd(__m512d, __m512i);
extern __m512d __cdecl _mm512_mask_permutevar_pd(__m512d, __mmask8, __m512d, __m512i);
extern __m512d __cdecl _mm512_maskz_permutevar_pd(__mmask8, __m512d, __m512i);
extern __m512  __cdecl _mm512_permutevar_ps(__m512, __m512i);
extern __m512  __cdecl _mm512_mask_permutevar_ps(__m512, __mmask16, __m512, __m512i);
extern __m512  __cdecl _mm512_maskz_permutevar_ps(__mmask16, __m512, __m512i);
extern __m512i __cdecl _mm512_permutevar_epi32(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_permutevar_epi32(__m512i, __mmask16, __m512i, __m512i);

extern __m512d __cdecl _mm512_permutex_pd(__m512d, const int);
extern __m512d __cdecl _mm512_mask_permutex_pd(__m512d, __mmask8, __m512d, const int);
extern __m512d __cdecl _mm512_maskz_permutex_pd(__mmask8, __m512d, const int);
extern __m512i __cdecl _mm512_permutex_epi64(__m512i, const int);
extern __m512i __cdecl _mm512_mask_permutex_epi64(__m512i, __mmask8, __m512i, const int);
extern __m512i __cdecl _mm512_maskz_permutex_epi64(__mmask8, __m512i, const int);
extern __m512d __cdecl _mm512_permutexvar_pd(__m512i, __m512d);
extern __m512d __cdecl _mm512_mask_permutexvar_pd(__m512d, __mmask8, __m512i, __m512d);
extern __m512d __cdecl _mm512_maskz_permutexvar_pd(__mmask8, __m512i, __m512d);
extern __m512  __cdecl _mm512_permutexvar_ps(__m512i, __m512);
extern __m512  __cdecl _mm512_mask_permutexvar_ps(__m512, __mmask16, __m512i, __m512);
extern __m512  __cdecl _mm512_maskz_permutexvar_ps(__mmask16, __m512i, __m512);
extern __m512i __cdecl _mm512_permutexvar_epi16(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_permutexvar_epi16(__m512i, __mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_permutexvar_epi16(__mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_permutexvar_epi32(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_permutexvar_epi32(__m512i, __mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_permutexvar_epi32(__mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_permutexvar_epi64(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_permutexvar_epi64(__m512i, __mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_permutexvar_epi64(__mmask8, __m512i, __m512i);

extern __m512d __cdecl _mm512_permutex2var_pd(__m512d, __m512i , __m512d);
extern __m512d __cdecl _mm512_mask_permutex2var_pd(__m512d, __mmask8, __m512i , __m512d);
extern __m512d __cdecl _mm512_mask2_permutex2var_pd(__m512d, __m512i , __mmask8, __m512d);
extern __m512d __cdecl _mm512_maskz_permutex2var_pd(__mmask8, __m512d, __m512i , __m512d);
extern __m512  __cdecl _mm512_permutex2var_ps(__m512, __m512i , __m512);
extern __m512  __cdecl _mm512_mask_permutex2var_ps(__m512, __mmask16, __m512i , __m512);
extern __m512  __cdecl _mm512_mask2_permutex2var_ps(__m512, __m512i , __mmask16, __m512);
extern __m512  __cdecl _mm512_maskz_permutex2var_ps(__mmask16, __m512, __m512i , __m512);
extern __m512i __cdecl _mm512_permutex2var_epi16(__m512i, __m512i , __m512i);
extern __m512i __cdecl _mm512_mask_permutex2var_epi16(__m512i, __mmask32, __m512i , __m512i);
extern __m512i __cdecl _mm512_mask2_permutex2var_epi16(__m512i, __m512i , __mmask32, __m512i);
extern __m512i __cdecl _mm512_maskz_permutex2var_epi16(__mmask32, __m512i, __m512i , __m512i);
extern __m512i __cdecl _mm512_permutex2var_epi32(__m512i, __m512i , __m512i);
extern __m512i __cdecl _mm512_mask_permutex2var_epi32(__m512i, __mmask16, __m512i , __m512i);
extern __m512i __cdecl _mm512_mask2_permutex2var_epi32(__m512i, __m512i , __mmask16, __m512i);
extern __m512i __cdecl _mm512_maskz_permutex2var_epi32(__mmask16, __m512i, __m512i , __m512i);
extern __m512i __cdecl _mm512_permutex2var_epi64(__m512i, __m512i , __m512i);
extern __m512i __cdecl _mm512_mask_permutex2var_epi64(__m512i, __mmask8, __m512i , __m512i);
extern __m512i __cdecl _mm512_mask2_permutex2var_epi64(__m512i, __m512i , __mmask8, __m512i);
extern __m512i __cdecl _mm512_maskz_permutex2var_epi64(__mmask8, __m512i, __m512i , __m512i);

extern __m512d __cdecl _mm512_mask_compress_pd(__m512d, __mmask8, __m512d);
extern __m512d __cdecl _mm512_maskz_compress_pd(__mmask8, __m512d);
extern __m512  __cdecl _mm512_mask_compress_ps(__m512, __mmask16, __m512);
extern __m512  __cdecl _mm512_maskz_compress_ps(__mmask16, __m512);
extern __m512i __cdecl _mm512_mask_compress_epi8(__m512i, __mmask64, __m512i);
extern __m512i __cdecl _mm512_maskz_compress_epi8(__mmask64, __m512i);
extern __m512i __cdecl _mm512_mask_compress_epi16(__m512i, __mmask32, __m512i);
extern __m512i __cdecl _mm512_maskz_compress_epi16(__mmask32, __m512i);
extern __m512i __cdecl _mm512_mask_compress_epi32(__m512i, __mmask16, __m512i);
extern __m512i __cdecl _mm512_maskz_compress_epi32(__mmask16, __m512i);
extern __m512i __cdecl _mm512_mask_compress_epi64(__m512i, __mmask8, __m512i);
extern __m512i __cdecl _mm512_maskz_compress_epi64(__mmask8, __m512i);

extern void    __cdecl _mm512_mask_compressstoreu_pd(void*, __mmask8, __m512d);
extern void    __cdecl _mm512_mask_compressstoreu_ps(void*, __mmask16, __m512);
extern void    __cdecl _mm512_mask_compressstoreu_epi8(void*, __mmask64, __m512i);
extern void    __cdecl _mm512_mask_compressstoreu_epi16(void*, __mmask32, __m512i);
extern void    __cdecl _mm512_mask_compressstoreu_epi32(void*, __mmask16, __m512i);
extern void    __cdecl _mm512_mask_compressstoreu_epi64(void*, __mmask8, __m512i);

extern __m512d __cdecl _mm512_mask_expand_pd(__m512d, __mmask8, __m512d);
extern __m512d __cdecl _mm512_maskz_expand_pd(__mmask8, __m512d);
extern __m512  __cdecl _mm512_mask_expand_ps(__m512, __mmask16, __m512);
extern __m512  __cdecl _mm512_maskz_expand_ps(__mmask16, __m512);
extern __m512i __cdecl _mm512_mask_expand_epi8(__m512i, __mmask64, __m512i);
extern __m512i __cdecl _mm512_maskz_expand_epi8(__mmask64, __m512i);
extern __m512i __cdecl _mm512_mask_expand_epi16(__m512i, __mmask32, __m512i);
extern __m512i __cdecl _mm512_maskz_expand_epi16(__mmask32, __m512i);
extern __m512i __cdecl _mm512_mask_expand_epi32(__m512i, __mmask16, __m512i);
extern __m512i __cdecl _mm512_maskz_expand_epi32(__mmask16, __m512i);
extern __m512i __cdecl _mm512_mask_expand_epi64(__m512i, __mmask8, __m512i);
extern __m512i __cdecl _mm512_maskz_expand_epi64(__mmask8, __m512i);
extern __m512d __cdecl _mm512_mask_expandloadu_pd(__m512d, __mmask8, void const*);
extern __m512d __cdecl _mm512_maskz_expandloadu_pd(__mmask8, void const*);
extern __m512  __cdecl _mm512_mask_expandloadu_ps(__m512, __mmask16, void const*);
extern __m512  __cdecl _mm512_maskz_expandloadu_ps(__mmask16, void const*);
extern __m512i __cdecl _mm512_mask_expandloadu_epi8(__m512i, __mmask64, const void*);
extern __m512i __cdecl _mm512_maskz_expandloadu_epi8(__mmask64, const void*);
extern __m512i __cdecl _mm512_mask_expandloadu_epi16(__m512i, __mmask32, const void*);
extern __m512i __cdecl _mm512_maskz_expandloadu_epi16(__mmask32, const void*);
extern __m512i __cdecl _mm512_mask_expandloadu_epi32(__m512i, __mmask16, void const*);
extern __m512i __cdecl _mm512_maskz_expandloadu_epi32(__mmask16, void const*);
extern __m512i __cdecl _mm512_mask_expandloadu_epi64(__m512i, __mmask8, void const*);
extern __m512i __cdecl _mm512_maskz_expandloadu_epi64(__mmask8, void const*);

extern __m512i __cdecl _mm512_ternarylogic_epi32(__m512i, __m512i, __m512i, int);
extern __m512i __cdecl _mm512_mask_ternarylogic_epi32(__m512i, __mmask16, __m512i, __m512i, int);
extern __m512i __cdecl _mm512_maskz_ternarylogic_epi32(__mmask16, __m512i, __m512i, __m512i, int);
extern __m512i __cdecl _mm512_ternarylogic_epi64(__m512i, __m512i, __m512i, int);
extern __m512i __cdecl _mm512_mask_ternarylogic_epi64(__m512i, __mmask8, __m512i, __m512i, int);
extern __m512i __cdecl _mm512_maskz_ternarylogic_epi64(__mmask8, __m512i, __m512i, __m512i, int);

extern __m512i __cdecl _mm512_conflict_epi32(__m512i);
extern __m512i __cdecl _mm512_mask_conflict_epi32(__m512i, __mmask16, __m512i);
extern __m512i __cdecl _mm512_maskz_conflict_epi32(__mmask16, __m512i);
extern __m512i __cdecl _mm512_conflict_epi64(__m512i);
extern __m512i __cdecl _mm512_mask_conflict_epi64(__m512i, __mmask8, __m512i);
extern __m512i __cdecl _mm512_maskz_conflict_epi64(__mmask8, __m512i);

extern __m512i __cdecl _mm512_lzcnt_epi32(__m512i);
extern __m512i __cdecl _mm512_mask_lzcnt_epi32(__m512i, __mmask16, __m512i);
extern __m512i __cdecl _mm512_maskz_lzcnt_epi32(__mmask16, __m512i);
extern __m512i __cdecl _mm512_lzcnt_epi64(__m512i);
extern __m512i __cdecl _mm512_mask_lzcnt_epi64(__m512i, __mmask8, __m512i);
extern __m512i __cdecl _mm512_maskz_lzcnt_epi64(__mmask8, __m512i);

extern __m512i __cdecl _mm512_avg_epu8(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_avg_epu8(__m512i, __mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_avg_epu8(__mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_avg_epu16(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_avg_epu16(__m512i, __mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_avg_epu16(__mmask32, __m512i, __m512i);

extern __m512i __cdecl _mm512_sad_epu8(__m512i, __m512i);
extern __m512i __cdecl _mm512_dbsad_epu8(__m512i, __m512i, int);
extern __m512i __cdecl _mm512_mask_dbsad_epu8(__m512i, __mmask32, __m512i, __m512i, int);
extern __m512i __cdecl _mm512_maskz_dbsad_epu8(__mmask32, __m512i, __m512i, int);

extern float   __cdecl _mm512_reduce_add_ps(__m512);
extern float   __cdecl _mm512_mask_reduce_add_ps(__mmask16, __m512);
extern double  __cdecl _mm512_reduce_add_pd(__m512d);
extern double  __cdecl _mm512_mask_reduce_add_pd(__mmask8, __m512d);
extern int     __cdecl _mm512_reduce_add_epi8(__m512i);
extern int     __cdecl _mm512_mask_reduce_add_epi8(__mmask64, __m512i);
extern int     __cdecl _mm512_reduce_add_epi16(__m512i);
extern int     __cdecl _mm512_mask_reduce_add_epi16(__mmask32, __m512i);
extern int     __cdecl _mm512_reduce_add_epi32(__m512i);
extern int     __cdecl _mm512_mask_reduce_add_epi32(__mmask16, __m512i);
extern __int64 __cdecl _mm512_reduce_add_epi64(__m512i);
extern __int64 __cdecl _mm512_mask_reduce_add_epi64(__mmask8, __m512i);
extern int     __cdecl _mm512_reduce_add_epu8(__m512i);
extern int     __cdecl _mm512_mask_reduce_add_epu8(__mmask64, __m512i);
extern int     __cdecl _mm512_reduce_add_epu16(__m512i);
extern int     __cdecl _mm512_mask_reduce_add_epu16(__mmask32, __m512i);

extern float   __cdecl _mm512_reduce_mul_ps(__m512);
extern float   __cdecl _mm512_mask_reduce_mul_ps(__mmask16, __m512);
extern double  __cdecl _mm512_reduce_mul_pd(__m512d);
extern double  __cdecl _mm512_mask_reduce_mul_pd(__mmask8, __m512d);
extern int     __cdecl _mm512_reduce_mul_epi32(__m512i);
extern int     __cdecl _mm512_mask_reduce_mul_epi32(__mmask16, __m512i);
extern __int64 __cdecl _mm512_reduce_mul_epi64(__m512i);
extern __int64 __cdecl _mm512_mask_reduce_mul_epi64(__mmask8, __m512i);

extern float   __cdecl _mm512_reduce_min_ps(__m512);
extern float   __cdecl _mm512_mask_reduce_min_ps(__mmask16, __m512);
extern double  __cdecl _mm512_reduce_min_pd(__m512d);
extern double  __cdecl _mm512_mask_reduce_min_pd(__mmask8, __m512d);
extern int     __cdecl _mm512_reduce_min_epi32(__m512i);
extern int     __cdecl _mm512_mask_reduce_min_epi32(__mmask16, __m512i);
extern __int64 __cdecl _mm512_reduce_min_epi64(__m512i);
extern __int64 __cdecl _mm512_mask_reduce_min_epi64(__mmask8, __m512i);
extern unsigned int     __cdecl _mm512_reduce_min_epu32(__m512i);
extern unsigned int     __cdecl _mm512_mask_reduce_min_epu32(__mmask16, __m512i);
extern unsigned __int64 __cdecl _mm512_reduce_min_epu64(__m512i);
extern unsigned __int64 __cdecl _mm512_mask_reduce_min_epu64(__mmask8, __m512i);

extern float   __cdecl _mm512_reduce_max_ps(__m512);
extern float   __cdecl _mm512_mask_reduce_max_ps(__mmask16, __m512);
extern double  __cdecl _mm512_reduce_max_pd(__m512d);
extern double  __cdecl _mm512_mask_reduce_max_pd(__mmask8, __m512d);
extern int     __cdecl _mm512_reduce_max_epi32(__m512i);
extern int     __cdecl _mm512_mask_reduce_max_epi32(__mmask16, __m512i);
extern __int64 __cdecl _mm512_reduce_max_epi64(__m512i);
extern __int64 __cdecl _mm512_mask_reduce_max_epi64(__mmask8, __m512i);
extern unsigned int     __cdecl _mm512_reduce_max_epu32(__m512i);
extern unsigned int     __cdecl _mm512_mask_reduce_max_epu32(__mmask16, __m512i);
extern unsigned __int64 __cdecl _mm512_reduce_max_epu64(__m512i);
extern unsigned __int64 __cdecl _mm512_mask_reduce_max_epu64(__mmask8, __m512i);

extern int     __cdecl _mm512_reduce_and_epi32(__m512i);
extern int     __cdecl _mm512_mask_reduce_and_epi32(__mmask16, __m512i);
extern __int64 __cdecl _mm512_reduce_and_epi64(__m512i);
extern __int64 __cdecl _mm512_mask_reduce_and_epi64(__mmask8, __m512i);

extern int     __cdecl _mm512_reduce_or_epi32(__m512i);
extern int     __cdecl _mm512_mask_reduce_or_epi32(__mmask16, __m512i);
extern __int64 __cdecl _mm512_reduce_or_epi64(__m512i);
extern __int64 __cdecl _mm512_mask_reduce_or_epi64(__mmask8, __m512i);

extern int     __cdecl _mm512_reduce_xor_epi32(__m512i);
extern int     __cdecl _mm512_mask_reduce_xor_epi32(__mmask16, __m512i);
extern __int64 __cdecl _mm512_reduce_xor_epi64(__m512i);
extern __int64 __cdecl _mm512_mask_reduce_xor_epi64(__mmask8, __m512i);

extern __m512d __cdecl _mm512_reduce_pd(__m512d, int);
extern __m512d __cdecl _mm512_mask_reduce_pd(__m512d, __mmask8, __m512d, int);
extern __m512d __cdecl _mm512_maskz_reduce_pd(__mmask8, __m512d, int);
extern __m512d __cdecl _mm512_reduce_round_pd(__m512d, int, int);
extern __m512d __cdecl _mm512_mask_reduce_round_pd(__m512d, __mmask8, __m512d, int, int);
extern __m512d __cdecl _mm512_maskz_reduce_round_pd(__mmask8, __m512d, int, int);
extern __m512  __cdecl _mm512_reduce_ps(__m512, int);
extern __m512  __cdecl _mm512_mask_reduce_ps(__m512, __mmask16, __m512, int);
extern __m512  __cdecl _mm512_maskz_reduce_ps(__mmask16, __m512, int);
extern __m512  __cdecl _mm512_reduce_round_ps(__m512, int, int);
extern __m512  __cdecl _mm512_mask_reduce_round_ps(__m512, __mmask16, __m512, int, int);
extern __m512  __cdecl _mm512_maskz_reduce_round_ps(__mmask16, __m512, int, int);

extern __m512d __cdecl _mm512_roundscale_pd(__m512d, int);
extern __m512d __cdecl _mm512_mask_roundscale_pd(__m512d, __mmask8, __m512d, int);
extern __m512d __cdecl _mm512_maskz_roundscale_pd(__mmask8, __m512d, int);
extern __m512d __cdecl _mm512_roundscale_round_pd(__m512d, int, int);
extern __m512d __cdecl _mm512_mask_roundscale_round_pd(__m512d, __mmask8, __m512d, int, int);
extern __m512d __cdecl _mm512_maskz_roundscale_round_pd(__mmask8, __m512d, int, int);
extern __m512  __cdecl _mm512_roundscale_ps(__m512, int);
extern __m512  __cdecl _mm512_mask_roundscale_ps(__m512, __mmask16, __m512, int);
extern __m512  __cdecl _mm512_maskz_roundscale_ps(__mmask16, __m512, int);
extern __m512  __cdecl _mm512_roundscale_round_ps(__m512, int, int);
extern __m512  __cdecl _mm512_mask_roundscale_round_ps(__m512, __mmask16, __m512, int, int);
extern __m512  __cdecl _mm512_maskz_roundscale_round_ps(__mmask16, __m512, int, int);

extern __m512d __cdecl _mm512_scalef_pd(__m512d, __m512d);
extern __m512d __cdecl _mm512_mask_scalef_pd(__m512d, __mmask8, __m512d, __m512d);
extern __m512d __cdecl _mm512_maskz_scalef_pd(__mmask8, __m512d, __m512d);
extern __m512d __cdecl _mm512_scalef_round_pd(__m512d, __m512d, int);
extern __m512d __cdecl _mm512_mask_scalef_round_pd(__m512d, __mmask8, __m512d, __m512d, int);
extern __m512d __cdecl _mm512_maskz_scalef_round_pd(__mmask8, __m512d, __m512d, int);
extern __m512  __cdecl _mm512_scalef_ps(__m512, __m512);
extern __m512  __cdecl _mm512_mask_scalef_ps(__m512, __mmask16, __m512, __m512);
extern __m512  __cdecl _mm512_maskz_scalef_ps(__mmask16, __m512, __m512);
extern __m512  __cdecl _mm512_scalef_round_ps(__m512, __m512, int);
extern __m512  __cdecl _mm512_mask_scalef_round_ps(__m512, __mmask16, __m512, __m512, int);
extern __m512  __cdecl _mm512_maskz_scalef_round_ps(__mmask16, __m512, __m512, int);

extern __m512d __cdecl _mm512_fixupimm_pd(__m512d, __m512d, __m512i, const int);
extern __m512d __cdecl _mm512_mask_fixupimm_pd(__m512d, __mmask8, __m512d, __m512i, const int);
extern __m512d __cdecl _mm512_maskz_fixupimm_pd(__mmask8, __m512d, __m512d, __m512i, const int);
extern __m512d __cdecl _mm512_fixupimm_round_pd(__m512d, __m512d, __m512i, const int, const int);
extern __m512d __cdecl _mm512_mask_fixupimm_round_pd(__m512d, __mmask8, __m512d, __m512i, const int, const int);
extern __m512d __cdecl _mm512_maskz_fixupimm_round_pd(__mmask8, __m512d, __m512d, __m512i, const int, const int);
extern __m512  __cdecl _mm512_fixupimm_ps(__m512, __m512, __m512i, const int);
extern __m512  __cdecl _mm512_mask_fixupimm_ps(__m512, __mmask16, __m512, __m512i, const int);
extern __m512  __cdecl _mm512_maskz_fixupimm_ps(__mmask16, __m512, __m512, __m512i, const int);
extern __m512  __cdecl _mm512_fixupimm_round_ps(__m512, __m512, __m512i, const int, const int);
extern __m512  __cdecl _mm512_mask_fixupimm_round_ps(__m512, __mmask16, __m512, __m512i, const int, const int);
extern __m512  __cdecl _mm512_maskz_fixupimm_round_ps(__mmask16, __m512, __m512, __m512i, const int, const int);

extern void    __cdecl _mm512_stream_pd(void*, __m512d);
extern void    __cdecl _mm512_stream_ps(void*, __m512);
extern void    __cdecl _mm512_stream_si512(void*, __m512i);
extern __m512i __cdecl _mm512_stream_load_si512(void const*);

extern __m128d __cdecl _mm512_castpd512_pd128(__m512d);
extern __m128  __cdecl _mm512_castps512_ps128(__m512);
extern __m128i __cdecl _mm512_castsi512_si128(__m512i);
extern __m512i __cdecl _mm512_castsi128_si512(__m128i);

extern __mmask16 __cdecl _mm512_fpclass_ps_mask(__m512, int);
extern __mmask16 __cdecl _mm512_mask_fpclass_ps_mask(__mmask16, __m512, int);
extern __mmask8  __cdecl _mm512_fpclass_pd_mask(__m512d, int);
extern __mmask8  __cdecl _mm512_mask_fpclass_pd_mask(__mmask8, __m512d, int);

extern __m512d __cdecl _mm512_range_pd(__m512d, __m512d, int);
extern __m512d __cdecl _mm512_mask_range_pd(__m512d, __mmask8, __m512d, __m512d, int);
extern __m512d __cdecl _mm512_maskz_range_pd(__mmask8, __m512d, __m512d, int);
extern __m512d __cdecl _mm512_range_round_pd(__m512d, __m512d, int, int);
extern __m512d __cdecl _mm512_mask_range_round_pd(__m512d, __mmask8, __m512d, __m512d, int, int);
extern __m512d __cdecl _mm512_maskz_range_round_pd(__mmask8, __m512d, __m512d, int, int);
extern __m512  __cdecl _mm512_range_ps(__m512, __m512, int);
extern __m512  __cdecl _mm512_mask_range_ps(__m512, __mmask16, __m512, __m512, int);
extern __m512  __cdecl _mm512_maskz_range_ps(__mmask16, __m512, __m512, int);
extern __m512  __cdecl _mm512_range_round_ps(__m512, __m512, int, int);
extern __m512  __cdecl _mm512_mask_range_round_ps(__m512, __mmask16, __m512, __m512, int, int);
extern __m512  __cdecl _mm512_maskz_range_round_ps(__mmask16, __m512, __m512, int, int);

extern __m512i __cdecl _mm512_madd_epi16(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_madd_epi16(__m512i, __mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_madd_epi16(__mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_maddubs_epi16(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_maddubs_epi16(__m512i, __mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_maddubs_epi16(__mmask32, __m512i, __m512i);

extern __m512i __cdecl _mm512_packs_epi16(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_packs_epi16(__m512i, __mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_packs_epi16(__mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_packs_epi32(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_packs_epi32(__m512i, __mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_packs_epi32(__mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_packus_epi16(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_packus_epi16(__m512i, __mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_packus_epi16(__mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_packus_epi32(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_packus_epi32(__m512i, __mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_packus_epi32(__mmask32, __m512i, __m512i);

extern __mmask64 __cdecl _mm512_cmp_epi8_mask(__m512i, __m512i, const int);
extern __mmask64 __cdecl _mm512_mask_cmp_epi8_mask(__mmask64, __m512i, __m512i, const int);
extern __mmask32 __cdecl _mm512_cmp_epi16_mask(__m512i, __m512i, const int);
extern __mmask32 __cdecl _mm512_mask_cmp_epi16_mask(__mmask32, __m512i, __m512i, const int);
extern __mmask16 __cdecl _mm512_cmp_epi32_mask(__m512i, __m512i, const int);
extern __mmask16 __cdecl _mm512_mask_cmp_epi32_mask(__mmask16, __m512i, __m512i, const int);
extern __mmask8  __cdecl _mm512_cmp_epi64_mask(__m512i, __m512i, const int);
extern __mmask8  __cdecl _mm512_mask_cmp_epi64_mask(__mmask8, __m512i, __m512i, const int);
extern __mmask64 __cdecl _mm512_cmp_epu8_mask(__m512i, __m512i, const int);
extern __mmask64 __cdecl _mm512_mask_cmp_epu8_mask(__mmask64, __m512i, __m512i, const int);
extern __mmask32 __cdecl _mm512_cmp_epu16_mask(__m512i, __m512i, const int);
extern __mmask32 __cdecl _mm512_mask_cmp_epu16_mask(__mmask32, __m512i, __m512i, const int);
extern __mmask16 __cdecl _mm512_cmp_epu32_mask(__m512i, __m512i, const int);
extern __mmask16 __cdecl _mm512_mask_cmp_epu32_mask(__mmask16, __m512i, __m512i, const int);
extern __mmask8  __cdecl _mm512_cmp_epu64_mask(__m512i, __m512i, const int);
extern __mmask8  __cdecl _mm512_mask_cmp_epu64_mask(__mmask8, __m512i, __m512i, const int);

extern __mmask64 __cdecl _mm512_test_epi8_mask(__m512i, __m512i);
extern __mmask64 __cdecl _mm512_mask_test_epi8_mask(__mmask64, __m512i, __m512i);
extern __mmask32 __cdecl _mm512_test_epi16_mask(__m512i, __m512i);
extern __mmask32 __cdecl _mm512_mask_test_epi16_mask(__mmask32, __m512i, __m512i);
extern __mmask64 __cdecl _mm512_testn_epi8_mask(__m512i, __m512i);
extern __mmask64 __cdecl _mm512_mask_testn_epi8_mask(__mmask64, __m512i, __m512i);
extern __mmask32 __cdecl _mm512_testn_epi16_mask(__m512i, __m512i);
extern __mmask32 __cdecl _mm512_mask_testn_epi16_mask(__mmask32, __m512i, __m512i);
extern __mmask16 __cdecl _mm512_test_epi32_mask(__m512i, __m512i);
extern __mmask16 __cdecl _mm512_mask_test_epi32_mask(__mmask16, __m512i, __m512i);
extern __mmask8  __cdecl _mm512_test_epi64_mask(__m512i, __m512i);
extern __mmask8  __cdecl _mm512_mask_test_epi64_mask(__mmask8, __m512i, __m512i);
extern __mmask16 __cdecl _mm512_testn_epi32_mask(__m512i, __m512i);
extern __mmask16 __cdecl _mm512_mask_testn_epi32_mask(__mmask16, __m512i, __m512i);
extern __mmask8  __cdecl _mm512_testn_epi64_mask(__m512i, __m512i);
extern __mmask8  __cdecl _mm512_mask_testn_epi64_mask(__mmask8, __m512i, __m512i);

extern __mmask16 __cdecl _mm512_kunpackb(__mmask16, __mmask16);
extern __mmask32 __cdecl _mm512_kunpackw(__mmask32, __mmask32);
extern __mmask64 __cdecl _mm512_kunpackd(__mmask64, __mmask64);

extern unsigned char __cdecl _mm512_testz_and_mask8(__mmask8, __mmask8);
extern unsigned char __cdecl _mm512_testz_and_mask16(__mmask16, __mmask16);
extern unsigned char __cdecl _mm512_testz_and_mask32(__mmask32, __mmask32);
extern unsigned char __cdecl _mm512_testz_and_mask64(__mmask64, __mmask64);
extern unsigned char __cdecl _mm512_testz_andn_mask8(__mmask8, __mmask8);
extern unsigned char __cdecl _mm512_testz_andn_mask16(__mmask16, __mmask16);
extern unsigned char __cdecl _mm512_testz_andn_mask32(__mmask32, __mmask32);
extern unsigned char __cdecl _mm512_testz_andn_mask64(__mmask64, __mmask64);
extern unsigned char __cdecl _mm512_testz_or_mask8(__mmask8, __mmask8);
extern unsigned char __cdecl _mm512_testz_or_mask16(__mmask16, __mmask16);
extern unsigned char __cdecl _mm512_testz_or_mask32(__mmask32, __mmask32);
extern unsigned char __cdecl _mm512_testz_or_mask64(__mmask64, __mmask64);
extern unsigned char __cdecl _mm512_testz_nor_mask8(__mmask8, __mmask8);
extern unsigned char __cdecl _mm512_testz_nor_mask16(__mmask16, __mmask16);
extern unsigned char __cdecl _mm512_testz_nor_mask32(__mmask32, __mmask32);
extern unsigned char __cdecl _mm512_testz_nor_mask64(__mmask64, __mmask64);

extern __m512  __cdecl _mm512_i32gather_ps(__m512i, void const*, int);
extern __m512  __cdecl _mm512_mask_i32gather_ps(__m512, __mmask16, __m512i, void const*, int);
extern void    __cdecl _mm512_i32scatter_ps(void*, __m512i, __m512, int);
extern void    __cdecl _mm512_mask_i32scatter_ps(void*, __mmask16, __m512i, __m512, int);
extern __m512d __cdecl _mm512_i64gather_pd(__m512i, void const*, int);
extern __m512d __cdecl _mm512_mask_i64gather_pd(__m512d, __mmask8, __m512i, void const*, int);
extern void    __cdecl _mm512_i64scatter_pd(void*, __m512i, __m512d, int);
extern void    __cdecl _mm512_mask_i64scatter_pd(void*, __mmask8, __m512i, __m512d, int);
extern __m512d __cdecl _mm512_i32gather_pd(__m256i, void const*, int);
extern __m512d __cdecl _mm512_mask_i32gather_pd(__m512d, __mmask8, __m256i, void const*, int);
extern void    __cdecl _mm512_i32scatter_pd(void*, __m256i, __m512d, int);
extern void    __cdecl _mm512_mask_i32scatter_pd(void*, __mmask8, __m256i, __m512d, int);
extern __m512i __cdecl _mm512_i32gather_epi32(__m512i, void const*, int);
extern __m512i __cdecl _mm512_mask_i32gather_epi32(__m512i, __mmask16, __m512i, void const*, int);
extern void    __cdecl _mm512_i32scatter_epi32(void*, __m512i, __m512i, int);
extern void    __cdecl _mm512_mask_i32scatter_epi32(void*, __mmask16, __m512i, __m512i, int);
extern __m512i __cdecl _mm512_i32gather_epi64(__m256i, void const*, int);
extern __m512i __cdecl _mm512_mask_i32gather_epi64(__m512i, __mmask8, __m256i, void const*, int);
extern __m512i __cdecl _mm512_i64gather_epi64(__m512i, void const*, int);
extern __m512i __cdecl _mm512_mask_i64gather_epi64(__m512i, __mmask8, __m512i, void const*, int);
extern void    __cdecl _mm512_i32scatter_epi64(void*, __m256i, __m512i, int);
extern void    __cdecl _mm512_mask_i32scatter_epi64(void*, __mmask8, __m256i, __m512i, int);
extern void    __cdecl _mm512_i64scatter_epi64(void*, __m512i, __m512i, int);
extern void    __cdecl _mm512_mask_i64scatter_epi64(void*, __mmask8, __m512i, __m512i, int);
extern __m256  __cdecl _mm512_i64gather_ps(__m512i, void const*, int);
extern __m256  __cdecl _mm512_mask_i64gather_ps(__m256, __mmask8, __m512i, void const*, int);
extern void    __cdecl _mm512_i64scatter_ps(void*, __m512i, __m256, int);
extern void    __cdecl _mm512_mask_i64scatter_ps(void*, __mmask8, __m512i, __m256, int);
extern __m256i __cdecl _mm512_i64gather_epi32(__m512i, void const*, int);
extern __m256i __cdecl _mm512_mask_i64gather_epi32(__m256i, __mmask8, __m512i, void const*, int);
extern void    __cdecl _mm512_i64scatter_epi32(void*, __m512i, __m256i, int);
extern void    __cdecl _mm512_mask_i64scatter_epi32(void*, __mmask8, __m512i, __m256i, int);

extern __m512d __cdecl _mm512_cvtpslo_pd(__m512);
extern __m512d __cdecl _mm512_mask_cvtpslo_pd(__m512d, __mmask8, __m512);
extern __m512d __cdecl _mm512_cvtepi32lo_pd(__m512i);
extern __m512d __cdecl _mm512_mask_cvtepi32lo_pd(__m512d, __mmask8, __m512i);
extern __m512d __cdecl _mm512_cvtepu32lo_pd(__m512i);
extern __m512d __cdecl _mm512_mask_cvtepu32lo_pd(__m512d, __mmask8, __m512i);
extern __m512d __cdecl _mm512_cvtepi32_pd(__m256i);
extern __m512d __cdecl _mm512_mask_cvtepi32_pd(__m512d, __mmask8, __m256i);
extern __m512d __cdecl _mm512_maskz_cvtepi32_pd(__mmask8, __m256i);
extern __m512d __cdecl _mm512_cvtepu32_pd(__m256i);
extern __m512d __cdecl _mm512_mask_cvtepu32_pd(__m512d, __mmask8, __m256i);
extern __m512d __cdecl _mm512_maskz_cvtepu32_pd(__mmask8, __m256i);

extern __m512  __cdecl _mm512_cvtepi32_ps( __m512i);
extern __m512  __cdecl _mm512_mask_cvtepi32_ps(__m512, __mmask16, __m512i);
extern __m512  __cdecl _mm512_maskz_cvtepi32_ps(__mmask16, __m512i);
extern __m512  __cdecl _mm512_cvt_roundepi32_ps(__m512i, int);
extern __m512  __cdecl _mm512_mask_cvt_roundepi32_ps(__m512, __mmask16, __m512i, int);
extern __m512  __cdecl _mm512_maskz_cvt_roundepi32_ps(__mmask16, __m512i, int);
extern __m512  __cdecl _mm512_cvtepu32_ps( __m512i);
extern __m512  __cdecl _mm512_mask_cvtepu32_ps(__m512, __mmask16, __m512i);
extern __m512  __cdecl _mm512_maskz_cvtepu32_ps(__mmask16, __m512i);
extern __m512  __cdecl _mm512_cvt_roundepu32_ps(__m512i, int);
extern __m512  __cdecl _mm512_mask_cvt_roundepu32_ps(__m512, __mmask16, __m512i, int);
extern __m512  __cdecl _mm512_maskz_cvt_roundepu32_ps(__mmask16, __m512i, int);
extern __m512  __cdecl _mm512_cvtph_ps(__m256i);
extern __m512  __cdecl _mm512_mask_cvtph_ps(__m512, __mmask16, __m256i);
extern __m512  __cdecl _mm512_maskz_cvtph_ps(__mmask16, __m256i);
extern __m512  __cdecl _mm512_cvt_roundph_ps(__m256i, int);
extern __m512  __cdecl _mm512_mask_cvt_roundph_ps(__m512, __mmask16, __m256i, int);
extern __m512  __cdecl _mm512_maskz_cvt_roundph_ps(__mmask16, __m256i, int);
extern __m256i __cdecl _mm512_cvtps_ph(__m512, int);
extern __m256i __cdecl _mm512_mask_cvtps_ph(__m256i, __mmask16, __m512, int);
extern __m256i __cdecl _mm512_maskz_cvtps_ph(__mmask16, __m512, int);
extern __m256i __cdecl _mm512_cvt_roundps_ph(__m512, int);
extern __m256i __cdecl _mm512_mask_cvt_roundps_ph(__m256i, __mmask16, __m512, int);
extern __m256i __cdecl _mm512_maskz_cvt_roundps_ph(__mmask16, __m512, int);
extern __m256  __cdecl _mm512_cvtepi64_ps(__m512i);
extern __m256  __cdecl _mm512_mask_cvtepi64_ps(__m256, __mmask8, __m512i);
extern __m256  __cdecl _mm512_maskz_cvtepi64_ps(__mmask8, __m512i);
extern __m256  __cdecl _mm512_cvt_roundepi64_ps(__m512i, int);
extern __m256  __cdecl _mm512_mask_cvt_roundepi64_ps(__m256, __mmask8, __m512i, int);
extern __m256  __cdecl _mm512_maskz_cvt_roundepi64_ps(__mmask8, __m512i, int);
extern __m256  __cdecl _mm512_cvtepu64_ps(__m512i);
extern __m256  __cdecl _mm512_mask_cvtepu64_ps(__m256, __mmask8, __m512i);
extern __m256  __cdecl _mm512_maskz_cvtepu64_ps(__mmask8, __m512i);
extern __m256  __cdecl _mm512_cvt_roundepu64_ps(__m512i, int);
extern __m256  __cdecl _mm512_mask_cvt_roundepu64_ps(__m256, __mmask8, __m512i, int);
extern __m256  __cdecl _mm512_maskz_cvt_roundepu64_ps(__mmask8, __m512i, int);

extern __m512i __cdecl _mm512_cvtepi8_epi32(__m128i);
extern __m512i __cdecl _mm512_mask_cvtepi8_epi32(__m512i, __mmask16, __m128i);
extern __m512i __cdecl _mm512_maskz_cvtepi8_epi32(__mmask16, __m128i);
extern __m512i __cdecl _mm512_cvtepi8_epi64(__m128i);
extern __m512i __cdecl _mm512_mask_cvtepi8_epi64(__m512i, __mmask8, __m128i);
extern __m512i __cdecl _mm512_maskz_cvtepi8_epi64(__mmask8, __m128i);
extern __m512i __cdecl _mm512_cvtepi16_epi32(__m256i);
extern __m512i __cdecl _mm512_mask_cvtepi16_epi32(__m512i, __mmask16, __m256i);
extern __m512i __cdecl _mm512_maskz_cvtepi16_epi32(__mmask16, __m256i);
extern __m512i __cdecl _mm512_cvtepi16_epi64(__m128i);
extern __m512i __cdecl _mm512_mask_cvtepi16_epi64(__m512i, __mmask8, __m128i);
extern __m512i __cdecl _mm512_maskz_cvtepi16_epi64(__mmask8, __m128i);
extern __m128i __cdecl _mm512_cvtepi32_epi8(__m512i);
extern __m128i __cdecl _mm512_mask_cvtepi32_epi8(__m128i, __mmask16, __m512i);
extern __m128i __cdecl _mm512_maskz_cvtepi32_epi8(__mmask16, __m512i);
extern void    __cdecl _mm512_mask_cvtepi32_storeu_epi8(void*, __mmask16, __m512i);
extern __m128i __cdecl _mm512_cvtsepi32_epi8(__m512i);
extern __m128i __cdecl _mm512_mask_cvtsepi32_epi8(__m128i, __mmask16, __m512i);
extern __m128i __cdecl _mm512_maskz_cvtsepi32_epi8(__mmask16, __m512i);
extern void    __cdecl _mm512_mask_cvtsepi32_storeu_epi8(void*, __mmask16, __m512i);
extern __m128i __cdecl _mm512_cvtusepi32_epi8(__m512i);
extern __m128i __cdecl _mm512_mask_cvtusepi32_epi8(__m128i, __mmask16, __m512i);
extern __m128i __cdecl _mm512_maskz_cvtusepi32_epi8(__mmask16, __m512i);
extern void    __cdecl _mm512_mask_cvtusepi32_storeu_epi8(void*, __mmask16, __m512i);
extern __m256i __cdecl _mm512_cvtepi32_epi16(__m512i);
extern __m256i __cdecl _mm512_mask_cvtepi32_epi16(__m256i, __mmask16, __m512i);
extern __m256i __cdecl _mm512_maskz_cvtepi32_epi16(__mmask16, __m512i);
extern void    __cdecl _mm512_mask_cvtepi32_storeu_epi16(void*, __mmask16, __m512i);
extern __m256i __cdecl _mm512_cvtsepi32_epi16(__m512i);
extern __m256i __cdecl _mm512_mask_cvtsepi32_epi16(__m256i, __mmask16, __m512i);
extern __m256i __cdecl _mm512_maskz_cvtsepi32_epi16(__mmask16, __m512i);
extern void    __cdecl _mm512_mask_cvtsepi32_storeu_epi16(void*, __mmask16, __m512i);
extern __m256i __cdecl _mm512_cvtusepi32_epi16(__m512i);
extern __m256i __cdecl _mm512_mask_cvtusepi32_epi16(__m256i, __mmask16, __m512i);
extern __m256i __cdecl _mm512_maskz_cvtusepi32_epi16(__mmask16, __m512i);
extern void    __cdecl _mm512_mask_cvtusepi32_storeu_epi16(void*, __mmask16, __m512i);
extern __m512i __cdecl _mm512_cvtepi32_epi64(__m256i);
extern __m512i __cdecl _mm512_mask_cvtepi32_epi64(__m512i, __mmask8, __m256i);
extern __m512i __cdecl _mm512_maskz_cvtepi32_epi64(__mmask8, __m256i);
extern __m128i __cdecl _mm512_cvtepi64_epi8(__m512i);
extern __m128i __cdecl _mm512_mask_cvtepi64_epi8(__m128i, __mmask8, __m512i);
extern __m128i __cdecl _mm512_maskz_cvtepi64_epi8(__mmask8, __m512i);
extern void    __cdecl _mm512_mask_cvtepi64_storeu_epi8(void*, __mmask8, __m512i);
extern __m128i __cdecl _mm512_cvtsepi64_epi8(__m512i);
extern __m128i __cdecl _mm512_mask_cvtsepi64_epi8(__m128i, __mmask8, __m512i);
extern __m128i __cdecl _mm512_maskz_cvtsepi64_epi8(__mmask8, __m512i);
extern void    __cdecl _mm512_mask_cvtsepi64_storeu_epi8(void*, __mmask8, __m512i);
extern __m128i __cdecl _mm512_cvtusepi64_epi8(__m512i);
extern __m128i __cdecl _mm512_mask_cvtusepi64_epi8(__m128i, __mmask8, __m512i);
extern __m128i __cdecl _mm512_maskz_cvtusepi64_epi8(__mmask8, __m512i);
extern void    __cdecl _mm512_mask_cvtusepi64_storeu_epi8(void*, __mmask8, __m512i);
extern __m128i __cdecl _mm512_cvtepi64_epi16(__m512i);
extern __m128i __cdecl _mm512_mask_cvtepi64_epi16(__m128i, __mmask8, __m512i);
extern __m128i __cdecl _mm512_maskz_cvtepi64_epi16(__mmask8, __m512i);
extern void    __cdecl _mm512_mask_cvtepi64_storeu_epi16(void*, __mmask8, __m512i);
extern __m128i __cdecl _mm512_cvtsepi64_epi16(__m512i);
extern __m128i __cdecl _mm512_mask_cvtsepi64_epi16(__m128i, __mmask8, __m512i);
extern __m128i __cdecl _mm512_maskz_cvtsepi64_epi16(__mmask8, __m512i);
extern void    __cdecl _mm512_mask_cvtsepi64_storeu_epi16(void*, __mmask8, __m512i);
extern __m128i __cdecl _mm512_cvtusepi64_epi16(__m512i);
extern __m128i __cdecl _mm512_mask_cvtusepi64_epi16(__m128i, __mmask8, __m512i);
extern __m128i __cdecl _mm512_maskz_cvtusepi64_epi16(__mmask8, __m512i);
extern void    __cdecl _mm512_mask_cvtusepi64_storeu_epi16(void*, __mmask8, __m512i);
extern __m256i __cdecl _mm512_cvtepi64_epi32(__m512i);
extern __m256i __cdecl _mm512_mask_cvtepi64_epi32(__m256i, __mmask8, __m512i);
extern __m256i __cdecl _mm512_maskz_cvtepi64_epi32(__mmask8, __m512i);
extern void    __cdecl _mm512_mask_cvtepi64_storeu_epi32(void*, __mmask8, __m512i);
extern __m256i __cdecl _mm512_cvtsepi64_epi32(__m512i);
extern __m256i __cdecl _mm512_mask_cvtsepi64_epi32(__m256i, __mmask8, __m512i);
extern __m256i __cdecl _mm512_maskz_cvtsepi64_epi32(__mmask8, __m512i);
extern void    __cdecl _mm512_mask_cvtsepi64_storeu_epi32(void*, __mmask8, __m512i);
extern __m256i __cdecl _mm512_cvtusepi64_epi32(__m512i);
extern __m256i __cdecl _mm512_mask_cvtusepi64_epi32(__m256i, __mmask8, __m512i);
extern __m256i __cdecl _mm512_maskz_cvtusepi64_epi32(__mmask8, __m512i);
extern void    __cdecl _mm512_mask_cvtusepi64_storeu_epi32(void*, __mmask8, __m512i);
extern __m512i __cdecl _mm512_cvtepu8_epi32(__m128i);
extern __m512i __cdecl _mm512_mask_cvtepu8_epi32(__m512i, __mmask16, __m128i);
extern __m512i __cdecl _mm512_maskz_cvtepu8_epi32(__mmask16, __m128i);
extern __m512i __cdecl _mm512_cvtepu8_epi64(__m128i);
extern __m512i __cdecl _mm512_mask_cvtepu8_epi64(__m512i, __mmask8, __m128i);
extern __m512i __cdecl _mm512_maskz_cvtepu8_epi64(__mmask8, __m128i);
extern __m512i __cdecl _mm512_cvtepu16_epi32(__m256i);
extern __m512i __cdecl _mm512_mask_cvtepu16_epi32(__m512i, __mmask16, __m256i);
extern __m512i __cdecl _mm512_maskz_cvtepu16_epi32(__mmask16, __m256i);
extern __m512i __cdecl _mm512_cvtepu16_epi64(__m128i);
extern __m512i __cdecl _mm512_mask_cvtepu16_epi64(__m512i, __mmask8, __m128i);
extern __m512i __cdecl _mm512_maskz_cvtepu16_epi64(__mmask8, __m128i);
extern __m512i __cdecl _mm512_cvtepu32_epi64(__m256i);
extern __m512i __cdecl _mm512_mask_cvtepu32_epi64(__m512i, __mmask8, __m256i);
extern __m512i __cdecl _mm512_maskz_cvtepu32_epi64(__mmask8, __m256i);

extern __m512i __cdecl _mm512_cvtps_epi32(__m512);
extern __m512i __cdecl _mm512_mask_cvtps_epi32(__m512i, __mmask16, __m512);
extern __m512i __cdecl _mm512_maskz_cvtps_epi32(__mmask16, __m512);
extern __m512i __cdecl _mm512_cvt_roundps_epi32(__m512, int);
extern __m512i __cdecl _mm512_mask_cvt_roundps_epi32(__m512i, __mmask16, __m512, int);
extern __m512i __cdecl _mm512_maskz_cvt_roundps_epi32(__mmask16, __m512, int);
extern __m512i __cdecl _mm512_cvttps_epi32(__m512);
extern __m512i __cdecl _mm512_mask_cvttps_epi32(__m512i, __mmask16, __m512);
extern __m512i __cdecl _mm512_maskz_cvttps_epi32(__mmask16, __m512);
extern __m512i __cdecl _mm512_cvtt_roundps_epi32(__m512, int);
extern __m512i __cdecl _mm512_mask_cvtt_roundps_epi32(__m512i, __mmask16, __m512, int);
extern __m512i __cdecl _mm512_maskz_cvtt_roundps_epi32(__mmask16, __m512, int);
extern __m512i __cdecl _mm512_cvtps_epu32(__m512);
extern __m512i __cdecl _mm512_mask_cvtps_epu32(__m512i, __mmask16, __m512);
extern __m512i __cdecl _mm512_maskz_cvtps_epu32(__mmask16, __m512);
extern __m512i __cdecl _mm512_cvt_roundps_epu32(__m512, int);
extern __m512i __cdecl _mm512_mask_cvt_roundps_epu32(__m512i, __mmask16, __m512, int);
extern __m512i __cdecl _mm512_maskz_cvt_roundps_epu32(__mmask16, __m512, int);
extern __m512i __cdecl _mm512_cvttps_epu32(__m512);
extern __m512i __cdecl _mm512_mask_cvttps_epu32(__m512i, __mmask16, __m512);
extern __m512i __cdecl _mm512_maskz_cvttps_epu32(__mmask16, __m512);
extern __m512i __cdecl _mm512_cvtt_roundps_epu32(__m512, int);
extern __m512i __cdecl _mm512_mask_cvtt_roundps_epu32(__m512i, __mmask16, __m512, int);
extern __m512i __cdecl _mm512_maskz_cvtt_roundps_epu32(__mmask16, __m512, int);
extern __m256i __cdecl _mm512_cvtpd_epi32(__m512d);
extern __m256i __cdecl _mm512_mask_cvtpd_epi32(__m256i, __mmask8, __m512d);
extern __m256i __cdecl _mm512_maskz_cvtpd_epi32(__mmask8, __m512d);
extern __m256i __cdecl _mm512_cvt_roundpd_epi32(__m512d, int);
extern __m256i __cdecl _mm512_mask_cvt_roundpd_epi32(__m256i, __mmask8, __m512d, int);
extern __m256i __cdecl _mm512_maskz_cvt_roundpd_epi32(__mmask8, __m512d, int);
extern __m256i __cdecl _mm512_cvttpd_epi32(__m512d);
extern __m256i __cdecl _mm512_mask_cvttpd_epi32(__m256i, __mmask8, __m512d);
extern __m256i __cdecl _mm512_maskz_cvttpd_epi32(__mmask8, __m512d);
extern __m256i __cdecl _mm512_cvtt_roundpd_epi32(__m512d, int);
extern __m256i __cdecl _mm512_mask_cvtt_roundpd_epi32(__m256i, __mmask8, __m512d, int);
extern __m256i __cdecl _mm512_maskz_cvtt_roundpd_epi32(__mmask8, __m512d, int);
extern __m256i __cdecl _mm512_cvtpd_epu32(__m512d);
extern __m256i __cdecl _mm512_mask_cvtpd_epu32(__m256i, __mmask8, __m512d);
extern __m256i __cdecl _mm512_maskz_cvtpd_epu32(__mmask8, __m512d);
extern __m256i __cdecl _mm512_cvt_roundpd_epu32(__m512d, int);
extern __m256i __cdecl _mm512_mask_cvt_roundpd_epu32(__m256i, __mmask8, __m512d, int);
extern __m256i __cdecl _mm512_maskz_cvt_roundpd_epu32(__mmask8, __m512d, int);
extern __m256i __cdecl _mm512_cvttpd_epu32(__m512d);
extern __m256i __cdecl _mm512_mask_cvttpd_epu32(__m256i, __mmask8, __m512d);
extern __m256i __cdecl _mm512_maskz_cvttpd_epu32(__mmask8, __m512d);
extern __m256i __cdecl _mm512_cvtt_roundpd_epu32(__m512d, int);
extern __m256i __cdecl _mm512_mask_cvtt_roundpd_epu32(__m256i, __mmask8, __m512d, int);
extern __m256i __cdecl _mm512_maskz_cvtt_roundpd_epu32(__mmask8, __m512d, int);

extern __m512i __cdecl _mm512_cvtepi8_epi16(__m256i);
extern __m512i __cdecl _mm512_mask_cvtepi8_epi16(__m512i, __mmask32, __m256i);
extern __m512i __cdecl _mm512_maskz_cvtepi8_epi16(__mmask32, __m256i);
extern __m512i __cdecl _mm512_cvtepu8_epi16(__m256i);
extern __m512i __cdecl _mm512_mask_cvtepu8_epi16(__m512i, __mmask32, __m256i);
extern __m512i __cdecl _mm512_maskz_cvtepu8_epi16(__mmask32, __m256i);
extern __m256i __cdecl _mm512_cvtepi16_epi8(__m512i);
extern __m256i __cdecl _mm512_mask_cvtepi16_epi8(__m256i, __mmask32, __m512i);
extern __m256i __cdecl _mm512_maskz_cvtepi16_epi8(__mmask32, __m512i);
extern void    __cdecl _mm512_mask_cvtepi16_storeu_epi8(void*, __mmask32, __m512i);
extern __m256i __cdecl _mm512_cvtsepi16_epi8(__m512i);
extern __m256i __cdecl _mm512_mask_cvtsepi16_epi8(__m256i, __mmask32, __m512i);
extern __m256i __cdecl _mm512_maskz_cvtsepi16_epi8(__mmask32, __m512i);
extern void    __cdecl _mm512_mask_cvtsepi16_storeu_epi8(void*, __mmask32, __m512i);
extern __m256i __cdecl _mm512_cvtusepi16_epi8(__m512i);
extern __m256i __cdecl _mm512_mask_cvtusepi16_epi8(__m256i, __mmask32, __m512i);
extern __m256i __cdecl _mm512_maskz_cvtusepi16_epi8(__mmask32, __m512i);
extern void    __cdecl _mm512_mask_cvtusepi16_storeu_epi8(void*, __mmask32, __m512i);

extern __m512d __cdecl _mm512_cvtepi64_pd(__m512i);
extern __m512d __cdecl _mm512_mask_cvtepi64_pd(__m512d, __mmask8, __m512i);
extern __m512d __cdecl _mm512_maskz_cvtepi64_pd(__mmask8, __m512i);
extern __m512d __cdecl _mm512_cvt_roundepi64_pd(__m512i, int);
extern __m512d __cdecl _mm512_mask_cvt_roundepi64_pd(__m512d, __mmask8, __m512i, int);
extern __m512d __cdecl _mm512_maskz_cvt_roundepi64_pd(__mmask8, __m512i, int);
extern __m512d __cdecl _mm512_cvtepu64_pd(__m512i);
extern __m512d __cdecl _mm512_mask_cvtepu64_pd(__m512d, __mmask8, __m512i);
extern __m512d __cdecl _mm512_maskz_cvtepu64_pd(__mmask8, __m512i);
extern __m512d __cdecl _mm512_cvt_roundepu64_pd(__m512i, int);
extern __m512d __cdecl _mm512_mask_cvt_roundepu64_pd(__m512d, __mmask8, __m512i, int);
extern __m512d __cdecl _mm512_maskz_cvt_roundepu64_pd(__mmask8, __m512i, int);
extern __m512i __cdecl _mm512_cvtpd_epi64(__m512d);
extern __m512i __cdecl _mm512_mask_cvtpd_epi64(__m512i, __mmask8, __m512d);
extern __m512i __cdecl _mm512_maskz_cvtpd_epi64(__mmask8, __m512d);
extern __m512i __cdecl _mm512_cvt_roundpd_epi64(__m512d, int);
extern __m512i __cdecl _mm512_mask_cvt_roundpd_epi64(__m512i, __mmask8, __m512d, int);
extern __m512i __cdecl _mm512_maskz_cvt_roundpd_epi64(__mmask8, __m512d, int);
extern __m512i __cdecl _mm512_cvtpd_epu64(__m512d);
extern __m512i __cdecl _mm512_mask_cvtpd_epu64(__m512i, __mmask8, __m512d);
extern __m512i __cdecl _mm512_maskz_cvtpd_epu64(__mmask8, __m512d);
extern __m512i __cdecl _mm512_cvt_roundpd_epu64(__m512d, int);
extern __m512i __cdecl _mm512_mask_cvt_roundpd_epu64(__m512i, __mmask8, __m512d, int);
extern __m512i __cdecl _mm512_maskz_cvt_roundpd_epu64(__mmask8, __m512d, int);
extern __m512i __cdecl _mm512_cvttpd_epi64(__m512d);
extern __m512i __cdecl _mm512_mask_cvttpd_epi64(__m512i, __mmask8, __m512d);
extern __m512i __cdecl _mm512_maskz_cvttpd_epi64(__mmask8, __m512d);
extern __m512i __cdecl _mm512_cvtt_roundpd_epi64(__m512d, int);
extern __m512i __cdecl _mm512_mask_cvtt_roundpd_epi64(__m512i, __mmask8, __m512d, int);
extern __m512i __cdecl _mm512_maskz_cvtt_roundpd_epi64(__mmask8, __m512d, int);
extern __m512i __cdecl _mm512_cvttpd_epu64(__m512d);
extern __m512i __cdecl _mm512_mask_cvttpd_epu64(__m512i, __mmask8, __m512d);
extern __m512i __cdecl _mm512_maskz_cvttpd_epu64(__mmask8, __m512d);
extern __m512i __cdecl _mm512_cvtt_roundpd_epu64(__m512d, int);
extern __m512i __cdecl _mm512_mask_cvtt_roundpd_epu64(__m512i, __mmask8, __m512d, int);
extern __m512i __cdecl _mm512_maskz_cvtt_roundpd_epu64(__mmask8, __m512d, int);
extern __m512i __cdecl _mm512_cvtps_epi64(__m256);
extern __m512i __cdecl _mm512_mask_cvtps_epi64(__m512i, __mmask8, __m256);
extern __m512i __cdecl _mm512_maskz_cvtps_epi64(__mmask8, __m256);
extern __m512i __cdecl _mm512_cvt_roundps_epi64(__m256, int);
extern __m512i __cdecl _mm512_mask_cvt_roundps_epi64(__m512i, __mmask8, __m256, int);
extern __m512i __cdecl _mm512_maskz_cvt_roundps_epi64(__mmask8, __m256, int);
extern __m512i __cdecl _mm512_cvtps_epu64(__m256);
extern __m512i __cdecl _mm512_mask_cvtps_epu64(__m512i, __mmask8, __m256);
extern __m512i __cdecl _mm512_maskz_cvtps_epu64(__mmask8, __m256);
extern __m512i __cdecl _mm512_cvt_roundps_epu64(__m256, int);
extern __m512i __cdecl _mm512_mask_cvt_roundps_epu64(__m512i, __mmask8, __m256, int);
extern __m512i __cdecl _mm512_maskz_cvt_roundps_epu64(__mmask8, __m256, int);
extern __m512i __cdecl _mm512_cvttps_epi64(__m256);
extern __m512i __cdecl _mm512_mask_cvttps_epi64(__m512i, __mmask8, __m256);
extern __m512i __cdecl _mm512_maskz_cvttps_epi64(__mmask8, __m256);
extern __m512i __cdecl _mm512_cvtt_roundps_epi64(__m256, int);
extern __m512i __cdecl _mm512_mask_cvtt_roundps_epi64(__m512i, __mmask8, __m256, int);
extern __m512i __cdecl _mm512_maskz_cvtt_roundps_epi64(__mmask8, __m256, int);
extern __m512i __cdecl _mm512_cvttps_epu64(__m256);
extern __m512i __cdecl _mm512_mask_cvttps_epu64(__m512i, __mmask8, __m256);
extern __m512i __cdecl _mm512_maskz_cvttps_epu64(__mmask8, __m256);
extern __m512i __cdecl _mm512_cvtt_roundps_epu64(__m256, int);
extern __m512i __cdecl _mm512_mask_cvtt_roundps_epu64(__m512i, __mmask8, __m256, int);
extern __m512i __cdecl _mm512_maskz_cvtt_roundps_epu64(__mmask8, __m256, int);

extern __mmask64  __cdecl _mm512_cmpeq_epi8_mask(__m512i, __m512i);
extern __mmask64  __cdecl _mm512_cmpge_epi8_mask(__m512i, __m512i);
extern __mmask64  __cdecl _mm512_cmpgt_epi8_mask(__m512i, __m512i);
extern __mmask64  __cdecl _mm512_cmple_epi8_mask(__m512i, __m512i);
extern __mmask64  __cdecl _mm512_cmplt_epi8_mask(__m512i, __m512i);
extern __mmask64  __cdecl _mm512_cmpneq_epi8_mask(__m512i, __m512i);
extern __mmask64  __cdecl _mm512_cmpeq_epu8_mask(__m512i, __m512i);
extern __mmask64  __cdecl _mm512_cmpge_epu8_mask(__m512i, __m512i);
extern __mmask64  __cdecl _mm512_cmpgt_epu8_mask(__m512i, __m512i);
extern __mmask64  __cdecl _mm512_cmple_epu8_mask(__m512i, __m512i);
extern __mmask64  __cdecl _mm512_cmplt_epu8_mask(__m512i, __m512i);
extern __mmask64  __cdecl _mm512_cmpneq_epu8_mask(__m512i, __m512i);

extern __mmask64  __cdecl _mm512_mask_cmpeq_epi8_mask(__mmask64, __m512i, __m512i);
extern __mmask64  __cdecl _mm512_mask_cmpge_epi8_mask(__mmask64, __m512i, __m512i);
extern __mmask64  __cdecl _mm512_mask_cmpgt_epi8_mask(__mmask64, __m512i, __m512i);
extern __mmask64  __cdecl _mm512_mask_cmple_epi8_mask(__mmask64, __m512i, __m512i);
extern __mmask64  __cdecl _mm512_mask_cmplt_epi8_mask(__mmask64, __m512i, __m512i);
extern __mmask64  __cdecl _mm512_mask_cmpneq_epi8_mask(__mmask64, __m512i, __m512i);
extern __mmask64  __cdecl _mm512_mask_cmpeq_epu8_mask(__mmask64, __m512i, __m512i);
extern __mmask64  __cdecl _mm512_mask_cmpge_epu8_mask(__mmask64, __m512i, __m512i);
extern __mmask64  __cdecl _mm512_mask_cmpgt_epu8_mask(__mmask64, __m512i, __m512i);
extern __mmask64  __cdecl _mm512_mask_cmple_epu8_mask(__mmask64, __m512i, __m512i);
extern __mmask64  __cdecl _mm512_mask_cmplt_epu8_mask(__mmask64, __m512i, __m512i);
extern __mmask64  __cdecl _mm512_mask_cmpneq_epu8_mask(__mmask64, __m512i, __m512i);

extern __mmask32  __cdecl _mm512_cmpeq_epi16_mask(__m512i, __m512i);
extern __mmask32  __cdecl _mm512_cmpge_epi16_mask(__m512i, __m512i);
extern __mmask32  __cdecl _mm512_cmpgt_epi16_mask(__m512i, __m512i);
extern __mmask32  __cdecl _mm512_cmple_epi16_mask(__m512i, __m512i);
extern __mmask32  __cdecl _mm512_cmplt_epi16_mask(__m512i, __m512i);
extern __mmask32  __cdecl _mm512_cmpneq_epi16_mask(__m512i, __m512i);
extern __mmask32  __cdecl _mm512_cmpeq_epu16_mask(__m512i, __m512i);
extern __mmask32  __cdecl _mm512_cmpge_epu16_mask(__m512i, __m512i);
extern __mmask32  __cdecl _mm512_cmpgt_epu16_mask(__m512i, __m512i);
extern __mmask32  __cdecl _mm512_cmple_epu16_mask(__m512i, __m512i);
extern __mmask32  __cdecl _mm512_cmplt_epu16_mask(__m512i, __m512i);
extern __mmask32  __cdecl _mm512_cmpneq_epu16_mask(__m512i, __m512i);

extern __mmask32  __cdecl _mm512_mask_cmpeq_epi16_mask(__mmask32, __m512i, __m512i);
extern __mmask32  __cdecl _mm512_mask_cmpge_epi16_mask(__mmask32, __m512i, __m512i);
extern __mmask32  __cdecl _mm512_mask_cmpgt_epi16_mask(__mmask32, __m512i, __m512i);
extern __mmask32  __cdecl _mm512_mask_cmple_epi16_mask(__mmask32, __m512i, __m512i);
extern __mmask32  __cdecl _mm512_mask_cmplt_epi16_mask(__mmask32, __m512i, __m512i);
extern __mmask32  __cdecl _mm512_mask_cmpneq_epi16_mask(__mmask32, __m512i, __m512i);
extern __mmask32  __cdecl _mm512_mask_cmpeq_epu16_mask(__mmask32, __m512i, __m512i);
extern __mmask32  __cdecl _mm512_mask_cmpge_epu16_mask(__mmask32, __m512i, __m512i);
extern __mmask32  __cdecl _mm512_mask_cmpgt_epu16_mask(__mmask32, __m512i, __m512i);
extern __mmask32  __cdecl _mm512_mask_cmple_epu16_mask(__mmask32, __m512i, __m512i);
extern __mmask32  __cdecl _mm512_mask_cmplt_epu16_mask(__mmask32, __m512i, __m512i);
extern __mmask32  __cdecl _mm512_mask_cmpneq_epu16_mask(__mmask32, __m512i, __m512i);

extern __mmask16  __cdecl _mm512_cmpeq_epi32_mask(__m512i, __m512i);
extern __mmask16  __cdecl _mm512_cmpge_epi32_mask(__m512i, __m512i);
extern __mmask16  __cdecl _mm512_cmpgt_epi32_mask(__m512i, __m512i);
extern __mmask16  __cdecl _mm512_cmple_epi32_mask(__m512i, __m512i);
extern __mmask16  __cdecl _mm512_cmplt_epi32_mask(__m512i, __m512i);
extern __mmask16  __cdecl _mm512_cmpneq_epi32_mask(__m512i, __m512i);
extern __mmask16  __cdecl _mm512_cmpeq_epu32_mask(__m512i, __m512i);
extern __mmask16  __cdecl _mm512_cmpge_epu32_mask(__m512i, __m512i);
extern __mmask16  __cdecl _mm512_cmpgt_epu32_mask(__m512i, __m512i);
extern __mmask16  __cdecl _mm512_cmple_epu32_mask(__m512i, __m512i);
extern __mmask16  __cdecl _mm512_cmplt_epu32_mask(__m512i, __m512i);
extern __mmask16  __cdecl _mm512_cmpneq_epu32_mask(__m512i, __m512i);

extern __mmask16  __cdecl _mm512_mask_cmpeq_epi32_mask(__mmask16, __m512i, __m512i);
extern __mmask16  __cdecl _mm512_mask_cmpge_epi32_mask(__mmask16, __m512i, __m512i);
extern __mmask16  __cdecl _mm512_mask_cmpgt_epi32_mask(__mmask16, __m512i, __m512i);
extern __mmask16  __cdecl _mm512_mask_cmple_epi32_mask(__mmask16, __m512i, __m512i);
extern __mmask16  __cdecl _mm512_mask_cmplt_epi32_mask(__mmask16, __m512i, __m512i);
extern __mmask16  __cdecl _mm512_mask_cmpneq_epi32_mask(__mmask16, __m512i, __m512i);
extern __mmask16  __cdecl _mm512_mask_cmpeq_epu32_mask(__mmask16, __m512i, __m512i);
extern __mmask16  __cdecl _mm512_mask_cmpge_epu32_mask(__mmask16, __m512i, __m512i);
extern __mmask16  __cdecl _mm512_mask_cmpgt_epu32_mask(__mmask16, __m512i, __m512i);
extern __mmask16  __cdecl _mm512_mask_cmple_epu32_mask(__mmask16, __m512i, __m512i);
extern __mmask16  __cdecl _mm512_mask_cmplt_epu32_mask(__mmask16, __m512i, __m512i);
extern __mmask16  __cdecl _mm512_mask_cmpneq_epu32_mask(__mmask16, __m512i, __m512i);

extern __mmask8  __cdecl _mm512_cmpeq_epi64_mask(__m512i, __m512i);
extern __mmask8  __cdecl _mm512_cmpge_epi64_mask(__m512i, __m512i);
extern __mmask8  __cdecl _mm512_cmpgt_epi64_mask(__m512i, __m512i);
extern __mmask8  __cdecl _mm512_cmple_epi64_mask(__m512i, __m512i);
extern __mmask8  __cdecl _mm512_cmplt_epi64_mask(__m512i, __m512i);
extern __mmask8  __cdecl _mm512_cmpneq_epi64_mask(__m512i, __m512i);
extern __mmask8  __cdecl _mm512_cmpeq_epu64_mask(__m512i, __m512i);
extern __mmask8  __cdecl _mm512_cmpge_epu64_mask(__m512i, __m512i);
extern __mmask8  __cdecl _mm512_cmpgt_epu64_mask(__m512i, __m512i);
extern __mmask8  __cdecl _mm512_cmple_epu64_mask(__m512i, __m512i);
extern __mmask8  __cdecl _mm512_cmplt_epu64_mask(__m512i, __m512i);
extern __mmask8  __cdecl _mm512_cmpneq_epu64_mask(__m512i, __m512i);

extern __mmask8  __cdecl _mm512_mask_cmpeq_epi64_mask(__mmask8, __m512i, __m512i);
extern __mmask8  __cdecl _mm512_mask_cmpge_epi64_mask(__mmask8, __m512i, __m512i);
extern __mmask8  __cdecl _mm512_mask_cmpgt_epi64_mask(__mmask8, __m512i, __m512i);
extern __mmask8  __cdecl _mm512_mask_cmple_epi64_mask(__mmask8, __m512i, __m512i);
extern __mmask8  __cdecl _mm512_mask_cmplt_epi64_mask(__mmask8, __m512i, __m512i);
extern __mmask8  __cdecl _mm512_mask_cmpneq_epi64_mask(__mmask8, __m512i, __m512i);
extern __mmask8  __cdecl _mm512_mask_cmpeq_epu64_mask(__mmask8, __m512i, __m512i);
extern __mmask8  __cdecl _mm512_mask_cmpge_epu64_mask(__mmask8, __m512i, __m512i);
extern __mmask8  __cdecl _mm512_mask_cmpgt_epu64_mask(__mmask8, __m512i, __m512i);
extern __mmask8  __cdecl _mm512_mask_cmple_epu64_mask(__mmask8, __m512i, __m512i);
extern __mmask8  __cdecl _mm512_mask_cmplt_epu64_mask(__mmask8, __m512i, __m512i);
extern __mmask8  __cdecl _mm512_mask_cmpneq_epu64_mask(__mmask8, __m512i, __m512i);


extern __m128i   __cdecl _mm_mask_abs_epi16(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_abs_epi16(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_mask_abs_epi16(__m256i, __mmask16, __m256i);
extern __m256i   __cdecl _mm256_maskz_abs_epi16(__mmask16, __m256i);
extern __m128i   __cdecl _mm_mask_abs_epi32(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_abs_epi32(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_mask_abs_epi32(__m256i, __mmask8, __m256i);
extern __m256i   __cdecl _mm256_maskz_abs_epi32(__mmask8, __m256i);
extern __m128i   __cdecl _mm_abs_epi64(__m128i);
extern __m128i   __cdecl _mm_mask_abs_epi64(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_abs_epi64(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_abs_epi64(__m256i);
extern __m256i   __cdecl _mm256_mask_abs_epi64(__m256i, __mmask8, __m256i);
extern __m256i   __cdecl _mm256_maskz_abs_epi64(__mmask8, __m256i);
extern __m128i   __cdecl _mm_mask_abs_epi8(__m128i, __mmask16, __m128i);
extern __m128i   __cdecl _mm_maskz_abs_epi8(__mmask16, __m128i);
extern __m256i   __cdecl _mm256_mask_abs_epi8(__m256i, __mmask32, __m256i);
extern __m256i   __cdecl _mm256_maskz_abs_epi8(__mmask32, __m256i);
extern __m128i   __cdecl _mm_mask_add_epi16(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_add_epi16(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_add_epi16(__m256i, __mmask16, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_add_epi16(__mmask16, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_add_epi32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_add_epi32(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_add_epi32(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_add_epi32(__mmask8, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_add_epi64(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_add_epi64(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_add_epi64(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_add_epi64(__mmask8, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_add_epi8(__m128i, __mmask16, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_add_epi8(__mmask16, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_add_epi8(__m256i, __mmask32, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_add_epi8(__mmask32, __m256i, __m256i);
extern __m128d   __cdecl _mm_mask_add_pd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_maskz_add_pd(__mmask8, __m128d, __m128d);
extern __m256d   __cdecl _mm256_mask_add_pd(__m256d, __mmask8, __m256d, __m256d);
extern __m256d   __cdecl _mm256_maskz_add_pd(__mmask8, __m256d, __m256d);
extern __m128    __cdecl _mm_mask_add_ps(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_maskz_add_ps(__mmask8, __m128, __m128);
extern __m256    __cdecl _mm256_mask_add_ps(__m256, __mmask8, __m256, __m256);
extern __m256    __cdecl _mm256_maskz_add_ps(__mmask8, __m256, __m256);
extern __m128i   __cdecl _mm_mask_adds_epi16(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_adds_epi16(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_adds_epi16(__m256i, __mmask16, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_adds_epi16(__mmask16, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_adds_epi8(__m128i, __mmask16, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_adds_epi8(__mmask16, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_adds_epi8(__m256i, __mmask32, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_adds_epi8(__mmask32, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_adds_epu16(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_adds_epu16(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_adds_epu16(__m256i, __mmask16, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_adds_epu16(__mmask16, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_adds_epu8(__m128i, __mmask16, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_adds_epu8(__mmask16, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_adds_epu8(__m256i, __mmask32, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_adds_epu8(__mmask32, __m256i, __m256i);
extern __m128i   __cdecl _mm_alignr_epi32(__m128i, __m128i, const int);
extern __m128i   __cdecl _mm_mask_alignr_epi32(__m128i, __mmask8, __m128i, __m128i, const int);
extern __m128i   __cdecl _mm_maskz_alignr_epi32(__mmask8, __m128i, __m128i, const int);
extern __m256i   __cdecl _mm256_alignr_epi32(__m256i, __m256i, const int);
extern __m256i   __cdecl _mm256_mask_alignr_epi32(__m256i, __mmask8, __m256i, __m256i, const int);
extern __m256i   __cdecl _mm256_maskz_alignr_epi32(__mmask8, __m256i, __m256i, const int);
extern __m128i   __cdecl _mm_alignr_epi64(__m128i, __m128i, const int);
extern __m128i   __cdecl _mm_mask_alignr_epi64(__m128i, __mmask8, __m128i, __m128i, const int);
extern __m128i   __cdecl _mm_maskz_alignr_epi64(__mmask8, __m128i, __m128i, const int);
extern __m256i   __cdecl _mm256_alignr_epi64(__m256i, __m256i, const int);
extern __m256i   __cdecl _mm256_mask_alignr_epi64(__m256i, __mmask8, __m256i, __m256i, const int);
extern __m256i   __cdecl _mm256_maskz_alignr_epi64(__mmask8, __m256i, __m256i, const int);
extern __m128i   __cdecl _mm_mask_alignr_epi8(__m128i, __mmask16, __m128i, __m128i, const int);
extern __m128i   __cdecl _mm_maskz_alignr_epi8(__mmask16, __m128i, __m128i, const int);
extern __m256i   __cdecl _mm256_mask_alignr_epi8(__m256i, __mmask32, __m256i, __m256i, const int);
extern __m256i   __cdecl _mm256_maskz_alignr_epi8(__mmask32, __m256i, __m256i, const int);
extern __m128i   __cdecl _mm_and_epi32(__m128i, __m128i);
extern __m128i   __cdecl _mm_mask_and_epi32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_and_epi32(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_and_epi32(__m256i, __m256i);
extern __m256i   __cdecl _mm256_mask_and_epi32(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_and_epi32(__mmask8, __m256i, __m256i);
extern __m128i   __cdecl _mm_and_epi64(__m128i, __m128i);
extern __m128i   __cdecl _mm_mask_and_epi64(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_and_epi64(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_and_epi64(__m256i, __m256i);
extern __m256i   __cdecl _mm256_mask_and_epi64(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_and_epi64(__mmask8, __m256i, __m256i);
extern __m128d   __cdecl _mm_mask_and_pd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_maskz_and_pd(__mmask8, __m128d, __m128d);
extern __m256d   __cdecl _mm256_mask_and_pd(__m256d, __mmask8, __m256d, __m256d);
extern __m256d   __cdecl _mm256_maskz_and_pd(__mmask8, __m256d, __m256d);
extern __m128    __cdecl _mm_mask_and_ps(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_maskz_and_ps(__mmask8, __m128, __m128);
extern __m256    __cdecl _mm256_mask_and_ps(__m256, __mmask8, __m256, __m256);
extern __m256    __cdecl _mm256_maskz_and_ps(__mmask8, __m256, __m256);
extern __m128i   __cdecl _mm_andnot_epi32(__m128i, __m128i);
extern __m128i   __cdecl _mm_mask_andnot_epi32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_andnot_epi32(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_andnot_epi32(__m256i, __m256i);
extern __m256i   __cdecl _mm256_mask_andnot_epi32(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_andnot_epi32(__mmask8, __m256i, __m256i);
extern __m128i   __cdecl _mm_andnot_epi64(__m128i, __m128i);
extern __m128i   __cdecl _mm_mask_andnot_epi64(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_andnot_epi64(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_andnot_epi64(__m256i, __m256i);
extern __m256i   __cdecl _mm256_mask_andnot_epi64(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_andnot_epi64(__mmask8, __m256i, __m256i);
extern __m128d   __cdecl _mm_mask_andnot_pd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_maskz_andnot_pd(__mmask8, __m128d, __m128d);
extern __m256d   __cdecl _mm256_mask_andnot_pd(__m256d, __mmask8, __m256d, __m256d);
extern __m256d   __cdecl _mm256_maskz_andnot_pd(__mmask8, __m256d, __m256d);
extern __m128    __cdecl _mm_mask_andnot_ps(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_maskz_andnot_ps(__mmask8, __m128, __m128);
extern __m256    __cdecl _mm256_mask_andnot_ps(__m256, __mmask8, __m256, __m256);
extern __m256    __cdecl _mm256_maskz_andnot_ps(__mmask8, __m256, __m256);
extern __m128i   __cdecl _mm_mask_avg_epu16(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_avg_epu16(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_avg_epu16(__m256i, __mmask16, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_avg_epu16(__mmask16, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_avg_epu8(__m128i, __mmask16, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_avg_epu8(__mmask16, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_avg_epu8(__m256i, __mmask32, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_avg_epu8(__mmask32, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_blend_epi16(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_blend_epi16(__mmask16, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_blend_epi32(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_blend_epi32(__mmask8, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_blend_epi64(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_blend_epi64(__mmask8, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_blend_epi8(__mmask16, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_blend_epi8(__mmask32, __m256i, __m256i);
extern __m128d   __cdecl _mm_mask_blend_pd(__mmask8, __m128d, __m128d);
extern __m256d   __cdecl _mm256_mask_blend_pd(__mmask8, __m256d, __m256d);
extern __m128    __cdecl _mm_mask_blend_ps(__mmask8, __m128, __m128);
extern __m256    __cdecl _mm256_mask_blend_ps(__mmask8, __m256, __m256);
extern __m256    __cdecl _mm256_broadcast_f32x2(__m128);
extern __m256    __cdecl _mm256_mask_broadcast_f32x2(__m256, __mmask8, __m128);
extern __m256    __cdecl _mm256_maskz_broadcast_f32x2(__mmask8, __m128);
extern __m256    __cdecl _mm256_broadcast_f32x4(__m128);
extern __m256    __cdecl _mm256_mask_broadcast_f32x4(__m256, __mmask8, __m128);
extern __m256    __cdecl _mm256_maskz_broadcast_f32x4(__mmask8, __m128);
extern __m256d   __cdecl _mm256_broadcast_f64x2(__m128d);
extern __m256d   __cdecl _mm256_mask_broadcast_f64x2(__m256d, __mmask8, __m128d);
extern __m256d   __cdecl _mm256_maskz_broadcast_f64x2(__mmask8, __m128d);
extern __m128i   __cdecl _mm_broadcast_i32x2(__m128i);
extern __m128i   __cdecl _mm_mask_broadcast_i32x2(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_broadcast_i32x2(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_broadcast_i32x2(__m128i);
extern __m256i   __cdecl _mm256_mask_broadcast_i32x2(__m256i, __mmask8, __m128i);
extern __m256i   __cdecl _mm256_maskz_broadcast_i32x2(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_broadcast_i32x4(__m128i);
extern __m256i   __cdecl _mm256_mask_broadcast_i32x4(__m256i, __mmask8, __m128i);
extern __m256i   __cdecl _mm256_maskz_broadcast_i32x4(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_broadcast_i64x2(__m128i);
extern __m256i   __cdecl _mm256_mask_broadcast_i64x2(__m256i, __mmask8, __m128i);
extern __m256i   __cdecl _mm256_maskz_broadcast_i64x2(__mmask8, __m128i);
extern __m128i   __cdecl _mm_mask_broadcastb_epi8(__m128i, __mmask16, __m128i);
extern __m128i   __cdecl _mm_maskz_broadcastb_epi8(__mmask16, __m128i);
extern __m256i   __cdecl _mm256_mask_broadcastb_epi8(__m256i, __mmask32, __m128i);
extern __m256i   __cdecl _mm256_maskz_broadcastb_epi8(__mmask32, __m128i);
extern __m128i   __cdecl _mm_mask_broadcastd_epi32(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_broadcastd_epi32(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_mask_broadcastd_epi32(__m256i, __mmask8, __m128i);
extern __m256i   __cdecl _mm256_maskz_broadcastd_epi32(__mmask8, __m128i);
extern __m128i   __cdecl _mm_broadcastmb_epi64(__mmask8);
extern __m256i   __cdecl _mm256_broadcastmb_epi64(__mmask8);
extern __m128i   __cdecl _mm_broadcastmw_epi32(__mmask16);
extern __m256i   __cdecl _mm256_broadcastmw_epi32(__mmask16);
extern __m128i   __cdecl _mm_mask_broadcastq_epi64(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_broadcastq_epi64(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_mask_broadcastq_epi64(__m256i, __mmask8, __m128i);
extern __m256i   __cdecl _mm256_maskz_broadcastq_epi64(__mmask8, __m128i);
extern __m256d   __cdecl _mm256_mask_broadcastsd_pd(__m256d, __mmask8, __m128d);
extern __m256d   __cdecl _mm256_maskz_broadcastsd_pd(__mmask8, __m128d);
extern __m128    __cdecl _mm_mask_broadcastss_ps(__m128, __mmask8, __m128);
extern __m128    __cdecl _mm_maskz_broadcastss_ps(__mmask8, __m128);
extern __m256    __cdecl _mm256_mask_broadcastss_ps(__m256, __mmask8, __m128);
extern __m256    __cdecl _mm256_maskz_broadcastss_ps(__mmask8, __m128);
extern __m128i   __cdecl _mm_mask_broadcastw_epi16(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_broadcastw_epi16(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_mask_broadcastw_epi16(__m256i, __mmask16, __m128i);
extern __m256i   __cdecl _mm256_maskz_broadcastw_epi16(__mmask16, __m128i);
extern __mmask8  __cdecl _mm_cmp_epi16_mask(__m128i, __m128i, const int);
extern __mmask8  __cdecl _mm_mask_cmp_epi16_mask(__mmask8, __m128i, __m128i, const int);
extern __mmask16 __cdecl _mm256_cmp_epi16_mask(__m256i, __m256i, const int);
extern __mmask16 __cdecl _mm256_mask_cmp_epi16_mask(__mmask16, __m256i, __m256i, const int);
extern __mmask8  __cdecl _mm_cmp_epi32_mask(__m128i, __m128i, int);
extern __mmask8  __cdecl _mm_mask_cmp_epi32_mask(__mmask8, __m128i, __m128i, int);
extern __mmask8  __cdecl _mm256_cmp_epi32_mask(__m256i, __m256i, int);
extern __mmask8  __cdecl _mm256_mask_cmp_epi32_mask(__mmask8, __m256i, __m256i, int);
extern __mmask8  __cdecl _mm_cmp_epi64_mask(__m128i, __m128i, int);
extern __mmask8  __cdecl _mm_mask_cmp_epi64_mask(__mmask8, __m128i, __m128i, int);
extern __mmask8  __cdecl _mm256_cmp_epi64_mask(__m256i, __m256i, int);
extern __mmask8  __cdecl _mm256_mask_cmp_epi64_mask(__mmask8, __m256i, __m256i, int);
extern __mmask16 __cdecl _mm_cmp_epi8_mask(__m128i, __m128i, const int);
extern __mmask16 __cdecl _mm_mask_cmp_epi8_mask(__mmask16, __m128i, __m128i, const int);
extern __mmask32 __cdecl _mm256_cmp_epi8_mask(__m256i, __m256i, const int);
extern __mmask32 __cdecl _mm256_mask_cmp_epi8_mask(__mmask32, __m256i, __m256i, const int);
extern __mmask8  __cdecl _mm_cmp_epu16_mask(__m128i, __m128i, const int);
extern __mmask8  __cdecl _mm_mask_cmp_epu16_mask(__mmask8, __m128i, __m128i, const int);
extern __mmask16 __cdecl _mm256_cmp_epu16_mask(__m256i, __m256i, const int);
extern __mmask16 __cdecl _mm256_mask_cmp_epu16_mask(__mmask16, __m256i, __m256i, const int);
extern __mmask8  __cdecl _mm_cmp_epu32_mask(__m128i, __m128i, int);
extern __mmask8  __cdecl _mm_mask_cmp_epu32_mask(__mmask8, __m128i, __m128i, int);
extern __mmask8  __cdecl _mm256_cmp_epu32_mask(__m256i, __m256i, int);
extern __mmask8  __cdecl _mm256_mask_cmp_epu32_mask(__mmask8, __m256i, __m256i, int);
extern __mmask8  __cdecl _mm_cmp_epu64_mask(__m128i, __m128i, int);
extern __mmask8  __cdecl _mm_mask_cmp_epu64_mask(__mmask8, __m128i, __m128i, int);
extern __mmask8  __cdecl _mm256_cmp_epu64_mask(__m256i, __m256i, int);
extern __mmask8  __cdecl _mm256_mask_cmp_epu64_mask(__mmask8, __m256i, __m256i, int);
extern __mmask16 __cdecl _mm_cmp_epu8_mask(__m128i, __m128i, const int);
extern __mmask16 __cdecl _mm_mask_cmp_epu8_mask(__mmask16, __m128i, __m128i, const int);
extern __mmask32 __cdecl _mm256_cmp_epu8_mask(__m256i, __m256i, const int);
extern __mmask32 __cdecl _mm256_mask_cmp_epu8_mask(__mmask32, __m256i, __m256i, const int);
extern __mmask8  __cdecl _mm_cmp_pd_mask(__m128d, __m128d, const int);
extern __mmask8  __cdecl _mm_mask_cmp_pd_mask(__mmask8, __m128d, __m128d, const int);
extern __mmask8  __cdecl _mm256_cmp_pd_mask(__m256d, __m256d, const int);
extern __mmask8  __cdecl _mm256_mask_cmp_pd_mask(__mmask8, __m256d, __m256d, const int);
extern __mmask8  __cdecl _mm_cmp_ps_mask(__m128, __m128, const int);
extern __mmask8  __cdecl _mm_mask_cmp_ps_mask(__mmask8, __m128, __m128, const int);
extern __mmask8  __cdecl _mm256_cmp_ps_mask(__m256, __m256, const int);
extern __mmask8  __cdecl _mm256_mask_cmp_ps_mask(__mmask8, __m256, __m256, const int);
extern __m128i   __cdecl _mm_mask_compress_epi8(__m128i, __mmask16, __m128i);
extern __m128i   __cdecl _mm_maskz_compress_epi8(__mmask16, __m128i);
extern __m256i   __cdecl _mm256_mask_compress_epi8(__m256i, __mmask32, __m256i);
extern __m256i   __cdecl _mm256_maskz_compress_epi8(__mmask32, __m256i);
extern __m128i   __cdecl _mm_mask_compress_epi16(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_compress_epi16(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_mask_compress_epi16(__m256i, __mmask16, __m256i);
extern __m256i   __cdecl _mm256_maskz_compress_epi16(__mmask16, __m256i);
extern __m128i   __cdecl _mm_mask_compress_epi32(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_compress_epi32(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_mask_compress_epi32(__m256i, __mmask8, __m256i);
extern __m256i   __cdecl _mm256_maskz_compress_epi32(__mmask8, __m256i);
extern __m128i   __cdecl _mm_mask_compress_epi64(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_compress_epi64(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_mask_compress_epi64(__m256i, __mmask8, __m256i);
extern __m256i   __cdecl _mm256_maskz_compress_epi64(__mmask8, __m256i);
extern __m128d   __cdecl _mm_mask_compress_pd(__m128d, __mmask8, __m128d);
extern __m128d   __cdecl _mm_maskz_compress_pd(__mmask8, __m128d);
extern __m256d   __cdecl _mm256_mask_compress_pd(__m256d, __mmask8, __m256d);
extern __m256d   __cdecl _mm256_maskz_compress_pd(__mmask8, __m256d);
extern __m128    __cdecl _mm_mask_compress_ps(__m128, __mmask8, __m128);
extern __m128    __cdecl _mm_maskz_compress_ps(__mmask8, __m128);
extern __m256    __cdecl _mm256_mask_compress_ps(__m256, __mmask8, __m256);
extern __m256    __cdecl _mm256_maskz_compress_ps(__mmask8, __m256);
extern void      __cdecl _mm_mask_compressstoreu_epi8(void*, __mmask16, __m128i);
extern void      __cdecl _mm256_mask_compressstoreu_epi8(void*, __mmask32, __m256i);
extern void      __cdecl _mm_mask_compressstoreu_epi16(void*, __mmask8, __m128i);
extern void      __cdecl _mm256_mask_compressstoreu_epi16(void*, __mmask16, __m256i);
extern void      __cdecl _mm_mask_compressstoreu_epi32(void*, __mmask8, __m128i);
extern void      __cdecl _mm256_mask_compressstoreu_epi32(void*, __mmask8, __m256i);
extern void      __cdecl _mm_mask_compressstoreu_epi64(void*, __mmask8, __m128i);
extern void      __cdecl _mm256_mask_compressstoreu_epi64(void*, __mmask8, __m256i);
extern void      __cdecl _mm_mask_compressstoreu_pd(void*, __mmask8, __m128d);
extern void      __cdecl _mm256_mask_compressstoreu_pd(void*, __mmask8, __m256d);
extern void      __cdecl _mm_mask_compressstoreu_ps(void*, __mmask8, __m128);
extern void      __cdecl _mm256_mask_compressstoreu_ps(void*, __mmask8, __m256);
extern __m128i   __cdecl _mm_conflict_epi32(__m128i);
extern __m128i   __cdecl _mm_mask_conflict_epi32(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_conflict_epi32(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_conflict_epi32(__m256i);
extern __m256i   __cdecl _mm256_mask_conflict_epi32(__m256i, __mmask8, __m256i);
extern __m256i   __cdecl _mm256_maskz_conflict_epi32(__mmask8, __m256i);
extern __m128i   __cdecl _mm_conflict_epi64(__m128i);
extern __m128i   __cdecl _mm_mask_conflict_epi64(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_conflict_epi64(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_conflict_epi64(__m256i);
extern __m256i   __cdecl _mm256_mask_conflict_epi64(__m256i, __mmask8, __m256i);
extern __m256i   __cdecl _mm256_maskz_conflict_epi64(__mmask8, __m256i);
extern __m128i   __cdecl _mm_mask_cvtps_ph(__m128i, __mmask8, __m128, int);
extern __m128i   __cdecl _mm_maskz_cvtps_ph(__mmask8, __m128, int);
extern __m128i   __cdecl _mm_mask_cvt_roundps_ph(__m128i, __mmask8, __m128, int);
extern __m128i   __cdecl _mm_maskz_cvt_roundps_ph(__mmask8, __m128, int);
extern __m128i   __cdecl _mm256_mask_cvtps_ph(__m128i, __mmask8, __m256, int);
extern __m128i   __cdecl _mm256_maskz_cvtps_ph(__mmask8, __m256, int);
extern __m128i   __cdecl _mm256_mask_cvt_roundps_ph(__m128i, __mmask8, __m256, int);
extern __m128i   __cdecl _mm256_maskz_cvt_roundps_ph(__mmask8, __m256, int);
extern __m128i   __cdecl _mm_mask_cvtepi16_epi32(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_cvtepi16_epi32(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_mask_cvtepi16_epi32(__m256i, __mmask8, __m128i);
extern __m256i   __cdecl _mm256_maskz_cvtepi16_epi32(__mmask8, __m128i);
extern __m128i   __cdecl _mm_mask_cvtepi16_epi64(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_cvtepi16_epi64(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_mask_cvtepi16_epi64(__m256i, __mmask8, __m128i);
extern __m256i   __cdecl _mm256_maskz_cvtepi16_epi64(__mmask8, __m128i);
extern __m128i   __cdecl _mm_cvtepi16_epi8(__m128i);
extern __m128i   __cdecl _mm_mask_cvtepi16_epi8(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_cvtepi16_epi8(__mmask8, __m128i);
extern __m128i   __cdecl _mm256_cvtepi16_epi8(__m256i);
extern __m128i   __cdecl _mm256_mask_cvtepi16_epi8(__m128i, __mmask16, __m256i);
extern __m128i   __cdecl _mm256_maskz_cvtepi16_epi8(__mmask16, __m256i);
extern void      __cdecl _mm_mask_cvtepi16_storeu_epi8(void*, __mmask8, __m128i);
extern void      __cdecl _mm256_mask_cvtepi16_storeu_epi8(void*, __mmask16, __m256i);
extern __m128i   __cdecl _mm_cvtepi32_epi16(__m128i);
extern __m128i   __cdecl _mm_mask_cvtepi32_epi16(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_cvtepi32_epi16(__mmask8, __m128i);
extern __m128i   __cdecl _mm256_cvtepi32_epi16(__m256i);
extern __m128i   __cdecl _mm256_mask_cvtepi32_epi16(__m128i, __mmask8, __m256i);
extern __m128i   __cdecl _mm256_maskz_cvtepi32_epi16(__mmask8, __m256i);
extern __m128i   __cdecl _mm_mask_cvtepi32_epi64(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_cvtepi32_epi64(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_mask_cvtepi32_epi64(__m256i, __mmask8, __m128i);
extern __m256i   __cdecl _mm256_maskz_cvtepi32_epi64(__mmask8, __m128i);
extern __m128i   __cdecl _mm_cvtepi32_epi8(__m128i);
extern __m128i   __cdecl _mm_mask_cvtepi32_epi8(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_cvtepi32_epi8(__mmask8, __m128i);
extern __m128i   __cdecl _mm256_cvtepi32_epi8(__m256i);
extern __m128i   __cdecl _mm256_mask_cvtepi32_epi8(__m128i, __mmask8, __m256i);
extern __m128i   __cdecl _mm256_maskz_cvtepi32_epi8(__mmask8, __m256i);
extern __m128d   __cdecl _mm_mask_cvtepi32_pd(__m128d, __mmask8, __m128i);
extern __m128d   __cdecl _mm_maskz_cvtepi32_pd(__mmask8, __m128i);
extern __m256d   __cdecl _mm256_mask_cvtepi32_pd(__m256d, __mmask8, __m128i);
extern __m256d   __cdecl _mm256_maskz_cvtepi32_pd(__mmask8, __m128i);
extern __m128    __cdecl _mm_mask_cvtepi32_ps(__m128, __mmask8, __m128i);
extern __m128    __cdecl _mm_maskz_cvtepi32_ps(__mmask8, __m128i);
extern __m256    __cdecl _mm256_mask_cvtepi32_ps(__m256, __mmask8, __m256i);
extern __m256    __cdecl _mm256_maskz_cvtepi32_ps(__mmask8, __m256i);
extern void      __cdecl _mm_mask_cvtepi32_storeu_epi16(void*, __mmask8, __m128i);
extern void      __cdecl _mm256_mask_cvtepi32_storeu_epi16(void*, __mmask8, __m256i);
extern void      __cdecl _mm_mask_cvtepi32_storeu_epi8(void*, __mmask8, __m128i);
extern void      __cdecl _mm256_mask_cvtepi32_storeu_epi8(void*, __mmask8, __m256i);
extern __m128i   __cdecl _mm_cvtepi64_epi16(__m128i);
extern __m128i   __cdecl _mm_mask_cvtepi64_epi16(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_cvtepi64_epi16(__mmask8, __m128i);
extern __m128i   __cdecl _mm256_cvtepi64_epi16(__m256i);
extern __m128i   __cdecl _mm256_mask_cvtepi64_epi16(__m128i, __mmask8, __m256i);
extern __m128i   __cdecl _mm256_maskz_cvtepi64_epi16(__mmask8, __m256i);
extern __m128i   __cdecl _mm_cvtepi64_epi32(__m128i);
extern __m128i   __cdecl _mm_mask_cvtepi64_epi32(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_cvtepi64_epi32(__mmask8, __m128i);
extern __m128i   __cdecl _mm256_cvtepi64_epi32(__m256i);
extern __m128i   __cdecl _mm256_mask_cvtepi64_epi32(__m128i, __mmask8, __m256i);
extern __m128i   __cdecl _mm256_maskz_cvtepi64_epi32(__mmask8, __m256i);
extern __m128i   __cdecl _mm_cvtepi64_epi8(__m128i);
extern __m128i   __cdecl _mm_mask_cvtepi64_epi8(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_cvtepi64_epi8(__mmask8, __m128i);
extern __m128i   __cdecl _mm256_cvtepi64_epi8(__m256i);
extern __m128i   __cdecl _mm256_mask_cvtepi64_epi8(__m128i, __mmask8, __m256i);
extern __m128i   __cdecl _mm256_maskz_cvtepi64_epi8(__mmask8, __m256i);
extern __m128d   __cdecl _mm_cvtepi64_pd(__m128i);
extern __m128d   __cdecl _mm_mask_cvtepi64_pd(__m128d, __mmask8, __m128i);
extern __m128d   __cdecl _mm_maskz_cvtepi64_pd(__mmask8, __m128i);
extern __m256d   __cdecl _mm256_cvtepi64_pd(__m256i);
extern __m256d   __cdecl _mm256_mask_cvtepi64_pd(__m256d, __mmask8, __m256i);
extern __m256d   __cdecl _mm256_maskz_cvtepi64_pd(__mmask8, __m256i);
extern __m128    __cdecl _mm_cvtepi64_ps(__m128i);
extern __m128    __cdecl _mm_mask_cvtepi64_ps(__m128, __mmask8, __m128i);
extern __m128    __cdecl _mm_maskz_cvtepi64_ps(__mmask8, __m128i);
extern __m128    __cdecl _mm256_cvtepi64_ps(__m256i);
extern __m128    __cdecl _mm256_mask_cvtepi64_ps(__m128, __mmask8, __m256i);
extern __m128    __cdecl _mm256_maskz_cvtepi64_ps(__mmask8, __m256i);
extern void      __cdecl _mm_mask_cvtepi64_storeu_epi16(void*, __mmask8, __m128i);
extern void      __cdecl _mm256_mask_cvtepi64_storeu_epi16(void*, __mmask8, __m256i);
extern void      __cdecl _mm_mask_cvtepi64_storeu_epi32(void*, __mmask8, __m128i);
extern void      __cdecl _mm256_mask_cvtepi64_storeu_epi32(void*, __mmask8, __m256i);
extern void      __cdecl _mm_mask_cvtepi64_storeu_epi8(void*, __mmask8, __m128i);
extern void      __cdecl _mm256_mask_cvtepi64_storeu_epi8(void*, __mmask8, __m256i);
extern __m128i   __cdecl _mm_mask_cvtepi8_epi16(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_cvtepi8_epi16(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_mask_cvtepi8_epi16(__m256i, __mmask16, __m128i);
extern __m256i   __cdecl _mm256_maskz_cvtepi8_epi16(__mmask16, __m128i);
extern __m128i   __cdecl _mm_mask_cvtepi8_epi32(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_cvtepi8_epi32(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_mask_cvtepi8_epi32(__m256i, __mmask8, __m128i);
extern __m256i   __cdecl _mm256_maskz_cvtepi8_epi32(__mmask8, __m128i);
extern __m128i   __cdecl _mm_mask_cvtepi8_epi64(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_cvtepi8_epi64(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_mask_cvtepi8_epi64(__m256i, __mmask8, __m128i);
extern __m256i   __cdecl _mm256_maskz_cvtepi8_epi64(__mmask8, __m128i);
extern __m128i   __cdecl _mm_mask_cvtepu16_epi32(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_cvtepu16_epi32(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_mask_cvtepu16_epi32(__m256i, __mmask8, __m128i);
extern __m256i   __cdecl _mm256_maskz_cvtepu16_epi32(__mmask8, __m128i);
extern __m128i   __cdecl _mm_mask_cvtepu16_epi64(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_cvtepu16_epi64(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_mask_cvtepu16_epi64(__m256i, __mmask8, __m128i);
extern __m256i   __cdecl _mm256_maskz_cvtepu16_epi64(__mmask8, __m128i);
extern __m128i   __cdecl _mm_mask_cvtepu32_epi64(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_cvtepu32_epi64(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_mask_cvtepu32_epi64(__m256i, __mmask8, __m128i);
extern __m256i   __cdecl _mm256_maskz_cvtepu32_epi64(__mmask8, __m128i);
extern __m128    __cdecl _mm_cvtepu32_ps(__m128i);
extern __m128    __cdecl _mm_mask_cvtepu32_ps(__m128, __mmask8, __m128i);
extern __m128    __cdecl _mm_maskz_cvtepu32_ps(__mmask8, __m128i);
extern __m256    __cdecl _mm256_cvtepu32_ps(__m256i);
extern __m256    __cdecl _mm256_mask_cvtepu32_ps(__m256, __mmask8, __m256i);
extern __m256    __cdecl _mm256_maskz_cvtepu32_ps(__mmask8, __m256i);
extern __m128d   __cdecl _mm_cvtepu32_pd(__m128i);
extern __m128d   __cdecl _mm_mask_cvtepu32_pd(__m128d, __mmask8, __m128i);
extern __m128d   __cdecl _mm_maskz_cvtepu32_pd(__mmask8, __m128i);
extern __m256d   __cdecl _mm256_cvtepu32_pd(__m128i);
extern __m256d   __cdecl _mm256_mask_cvtepu32_pd(__m256d, __mmask8, __m128i);
extern __m256d   __cdecl _mm256_maskz_cvtepu32_pd(__mmask8, __m128i);
extern __m128d   __cdecl _mm_cvtepu64_pd(__m128i);
extern __m128d   __cdecl _mm_mask_cvtepu64_pd(__m128d, __mmask8, __m128i);
extern __m128d   __cdecl _mm_maskz_cvtepu64_pd(__mmask8, __m128i);
extern __m256d   __cdecl _mm256_cvtepu64_pd(__m256i);
extern __m256d   __cdecl _mm256_mask_cvtepu64_pd(__m256d, __mmask8, __m256i);
extern __m256d   __cdecl _mm256_maskz_cvtepu64_pd(__mmask8, __m256i);
extern __m128    __cdecl _mm_cvtepu64_ps(__m128i);
extern __m128    __cdecl _mm_mask_cvtepu64_ps(__m128, __mmask8, __m128i);
extern __m128    __cdecl _mm_maskz_cvtepu64_ps(__mmask8, __m128i);
extern __m128    __cdecl _mm256_cvtepu64_ps(__m256i);
extern __m128    __cdecl _mm256_mask_cvtepu64_ps(__m128, __mmask8, __m256i);
extern __m128    __cdecl _mm256_maskz_cvtepu64_ps(__mmask8, __m256i);
extern __m128i   __cdecl _mm_mask_cvtepu8_epi16(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_cvtepu8_epi16(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_mask_cvtepu8_epi16(__m256i, __mmask16, __m128i);
extern __m256i   __cdecl _mm256_maskz_cvtepu8_epi16(__mmask16, __m128i);
extern __m128i   __cdecl _mm_mask_cvtepu8_epi32(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_cvtepu8_epi32(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_mask_cvtepu8_epi32(__m256i, __mmask8, __m128i);
extern __m256i   __cdecl _mm256_maskz_cvtepu8_epi32(__mmask8, __m128i);
extern __m128i   __cdecl _mm_mask_cvtepu8_epi64(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_cvtepu8_epi64(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_mask_cvtepu8_epi64(__m256i, __mmask8, __m128i);
extern __m256i   __cdecl _mm256_maskz_cvtepu8_epi64(__mmask8, __m128i);
extern __m128i   __cdecl _mm_mask_cvtpd_epi32(__m128i, __mmask8, __m128d);
extern __m128i   __cdecl _mm_maskz_cvtpd_epi32(__mmask8, __m128d);
extern __m128i   __cdecl _mm256_mask_cvtpd_epi32(__m128i, __mmask8, __m256d);
extern __m128i   __cdecl _mm256_maskz_cvtpd_epi32(__mmask8, __m256d);
extern __m128i   __cdecl _mm_cvtpd_epi64(__m128d);
extern __m128i   __cdecl _mm_mask_cvtpd_epi64(__m128i, __mmask8, __m128d);
extern __m128i   __cdecl _mm_maskz_cvtpd_epi64(__mmask8, __m128d);
extern __m256i   __cdecl _mm256_cvtpd_epi64(__m256d);
extern __m256i   __cdecl _mm256_mask_cvtpd_epi64(__m256i, __mmask8, __m256d);
extern __m256i   __cdecl _mm256_maskz_cvtpd_epi64(__mmask8, __m256d);
extern __m128i   __cdecl _mm_cvtpd_epu32(__m128d);
extern __m128i   __cdecl _mm_mask_cvtpd_epu32(__m128i, __mmask8, __m128d);
extern __m128i   __cdecl _mm_maskz_cvtpd_epu32(__mmask8, __m128d);
extern __m128i   __cdecl _mm256_cvtpd_epu32(__m256d);
extern __m128i   __cdecl _mm256_mask_cvtpd_epu32(__m128i, __mmask8, __m256d);
extern __m128i   __cdecl _mm256_maskz_cvtpd_epu32(__mmask8, __m256d);
extern __m128i   __cdecl _mm_cvtpd_epu64(__m128d);
extern __m128i   __cdecl _mm_mask_cvtpd_epu64(__m128i, __mmask8, __m128d);
extern __m128i   __cdecl _mm_maskz_cvtpd_epu64(__mmask8, __m128d);
extern __m256i   __cdecl _mm256_cvtpd_epu64(__m256d);
extern __m256i   __cdecl _mm256_mask_cvtpd_epu64(__m256i, __mmask8, __m256d);
extern __m256i   __cdecl _mm256_maskz_cvtpd_epu64(__mmask8, __m256d);
extern __m128    __cdecl _mm_mask_cvtpd_ps(__m128, __mmask8, __m128d);
extern __m128    __cdecl _mm_maskz_cvtpd_ps(__mmask8, __m128d);
extern __m128    __cdecl _mm256_mask_cvtpd_ps(__m128, __mmask8, __m256d);
extern __m128    __cdecl _mm256_maskz_cvtpd_ps(__mmask8, __m256d);
extern __m128    __cdecl _mm_mask_cvtph_ps(__m128, __mmask8, __m128i);
extern __m128    __cdecl _mm_maskz_cvtph_ps(__mmask8, __m128i);
extern __m256    __cdecl _mm256_mask_cvtph_ps(__m256, __mmask8, __m128i);
extern __m256    __cdecl _mm256_maskz_cvtph_ps(__mmask8, __m128i);
extern __m128i   __cdecl _mm_mask_cvtps_epi32(__m128i, __mmask8, __m128);
extern __m128i   __cdecl _mm_maskz_cvtps_epi32(__mmask8, __m128);
extern __m256i   __cdecl _mm256_mask_cvtps_epi32(__m256i, __mmask8, __m256);
extern __m256i   __cdecl _mm256_maskz_cvtps_epi32(__mmask8, __m256);
extern __m128i   __cdecl _mm_cvtps_epi64(__m128);
extern __m128i   __cdecl _mm_mask_cvtps_epi64(__m128i, __mmask8, __m128);
extern __m128i   __cdecl _mm_maskz_cvtps_epi64(__mmask8, __m128);
extern __m256i   __cdecl _mm256_cvtps_epi64(__m128);
extern __m256i   __cdecl _mm256_mask_cvtps_epi64(__m256i, __mmask8, __m128);
extern __m256i   __cdecl _mm256_maskz_cvtps_epi64(__mmask8, __m128);
extern __m128i   __cdecl _mm_cvtps_epu32(__m128);
extern __m128i   __cdecl _mm_mask_cvtps_epu32(__m128i, __mmask8, __m128);
extern __m128i   __cdecl _mm_maskz_cvtps_epu32(__mmask8, __m128);
extern __m256i   __cdecl _mm256_cvtps_epu32(__m256);
extern __m256i   __cdecl _mm256_mask_cvtps_epu32(__m256i, __mmask8, __m256);
extern __m256i   __cdecl _mm256_maskz_cvtps_epu32(__mmask8, __m256);
extern __m128i   __cdecl _mm_cvtps_epu64(__m128);
extern __m128i   __cdecl _mm_mask_cvtps_epu64(__m128i, __mmask8, __m128);
extern __m128i   __cdecl _mm_maskz_cvtps_epu64(__mmask8, __m128);
extern __m256i   __cdecl _mm256_cvtps_epu64(__m128);
extern __m256i   __cdecl _mm256_mask_cvtps_epu64(__m256i, __mmask8, __m128);
extern __m256i   __cdecl _mm256_maskz_cvtps_epu64(__mmask8, __m128);
extern __m128d   __cdecl _mm_mask_cvtps_pd(__m128d, __mmask8, __m128);
extern __m128d   __cdecl _mm_maskz_cvtps_pd(__mmask8, __m128);
extern __m256d   __cdecl _mm256_mask_cvtps_pd(__m256d, __mmask8, __m128);
extern __m256d   __cdecl _mm256_maskz_cvtps_pd(__mmask8, __m128);
extern __m128i   __cdecl _mm_cvtsepi16_epi8(__m128i);
extern __m128i   __cdecl _mm_mask_cvtsepi16_epi8(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_cvtsepi16_epi8(__mmask8, __m128i);
extern __m128i   __cdecl _mm256_cvtsepi16_epi8(__m256i);
extern __m128i   __cdecl _mm256_mask_cvtsepi16_epi8(__m128i, __mmask16, __m256i);
extern __m128i   __cdecl _mm256_maskz_cvtsepi16_epi8(__mmask16, __m256i);
extern void      __cdecl _mm_mask_cvtsepi16_storeu_epi8(void*, __mmask8, __m128i);
extern void      __cdecl _mm256_mask_cvtsepi16_storeu_epi8(void*, __mmask16, __m256i);
extern __m128i   __cdecl _mm_cvtsepi32_epi16(__m128i);
extern __m128i   __cdecl _mm_mask_cvtsepi32_epi16(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_cvtsepi32_epi16(__mmask8, __m128i);
extern __m128i   __cdecl _mm256_cvtsepi32_epi16(__m256i);
extern __m128i   __cdecl _mm256_mask_cvtsepi32_epi16(__m128i, __mmask8, __m256i);
extern __m128i   __cdecl _mm256_maskz_cvtsepi32_epi16(__mmask8, __m256i);
extern __m128i   __cdecl _mm_cvtsepi32_epi8(__m128i);
extern __m128i   __cdecl _mm_mask_cvtsepi32_epi8(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_cvtsepi32_epi8(__mmask8, __m128i);
extern __m128i   __cdecl _mm256_cvtsepi32_epi8(__m256i);
extern __m128i   __cdecl _mm256_mask_cvtsepi32_epi8(__m128i, __mmask8, __m256i);
extern __m128i   __cdecl _mm256_maskz_cvtsepi32_epi8(__mmask8, __m256i);
extern void      __cdecl _mm_mask_cvtsepi32_storeu_epi16(void*, __mmask8, __m128i);
extern void      __cdecl _mm256_mask_cvtsepi32_storeu_epi16(void*, __mmask8, __m256i);
extern void      __cdecl _mm_mask_cvtsepi32_storeu_epi8(void*, __mmask8, __m128i);
extern void      __cdecl _mm256_mask_cvtsepi32_storeu_epi8(void*, __mmask8, __m256i);
extern __m128i   __cdecl _mm_cvtsepi64_epi16(__m128i);
extern __m128i   __cdecl _mm_mask_cvtsepi64_epi16(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_cvtsepi64_epi16(__mmask8, __m128i);
extern __m128i   __cdecl _mm256_cvtsepi64_epi16(__m256i);
extern __m128i   __cdecl _mm256_mask_cvtsepi64_epi16(__m128i, __mmask8, __m256i);
extern __m128i   __cdecl _mm256_maskz_cvtsepi64_epi16(__mmask8, __m256i);
extern __m128i   __cdecl _mm_cvtsepi64_epi32(__m128i);
extern __m128i   __cdecl _mm_mask_cvtsepi64_epi32(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_cvtsepi64_epi32(__mmask8, __m128i);
extern __m128i   __cdecl _mm256_cvtsepi64_epi32(__m256i);
extern __m128i   __cdecl _mm256_mask_cvtsepi64_epi32(__m128i, __mmask8, __m256i);
extern __m128i   __cdecl _mm256_maskz_cvtsepi64_epi32(__mmask8, __m256i);
extern __m128i   __cdecl _mm_cvtsepi64_epi8(__m128i);
extern __m128i   __cdecl _mm_mask_cvtsepi64_epi8(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_cvtsepi64_epi8(__mmask8, __m128i);
extern __m128i   __cdecl _mm256_cvtsepi64_epi8(__m256i);
extern __m128i   __cdecl _mm256_mask_cvtsepi64_epi8(__m128i, __mmask8, __m256i);
extern __m128i   __cdecl _mm256_maskz_cvtsepi64_epi8(__mmask8, __m256i);
extern void      __cdecl _mm_mask_cvtsepi64_storeu_epi16(void*, __mmask8, __m128i);
extern void      __cdecl _mm256_mask_cvtsepi64_storeu_epi16(void*, __mmask8, __m256i);
extern void      __cdecl _mm_mask_cvtsepi64_storeu_epi32(void*, __mmask8, __m128i);
extern void      __cdecl _mm256_mask_cvtsepi64_storeu_epi32(void*, __mmask8, __m256i);
extern void      __cdecl _mm_mask_cvtsepi64_storeu_epi8(void*, __mmask8, __m128i);
extern void      __cdecl _mm256_mask_cvtsepi64_storeu_epi8(void*, __mmask8, __m256i);
extern __m128i   __cdecl _mm_mask_cvttpd_epi32(__m128i, __mmask8, __m128d);
extern __m128i   __cdecl _mm_maskz_cvttpd_epi32(__mmask8, __m128d);
extern __m128i   __cdecl _mm256_mask_cvttpd_epi32(__m128i, __mmask8, __m256d);
extern __m128i   __cdecl _mm256_maskz_cvttpd_epi32(__mmask8, __m256d);
extern __m128i   __cdecl _mm_cvttpd_epi64(__m128d);
extern __m128i   __cdecl _mm_mask_cvttpd_epi64(__m128i, __mmask8, __m128d);
extern __m128i   __cdecl _mm_maskz_cvttpd_epi64(__mmask8, __m128d);
extern __m256i   __cdecl _mm256_cvttpd_epi64(__m256d);
extern __m256i   __cdecl _mm256_mask_cvttpd_epi64(__m256i, __mmask8, __m256d);
extern __m256i   __cdecl _mm256_maskz_cvttpd_epi64(__mmask8, __m256d);
extern __m128i   __cdecl _mm_cvttpd_epu32(__m128d);
extern __m128i   __cdecl _mm_mask_cvttpd_epu32(__m128i, __mmask8, __m128d);
extern __m128i   __cdecl _mm_maskz_cvttpd_epu32(__mmask8, __m128d);
extern __m128i   __cdecl _mm256_cvttpd_epu32(__m256d);
extern __m128i   __cdecl _mm256_mask_cvttpd_epu32(__m128i, __mmask8, __m256d);
extern __m128i   __cdecl _mm256_maskz_cvttpd_epu32(__mmask8, __m256d);
extern __m128i   __cdecl _mm_cvttpd_epu64(__m128d);
extern __m128i   __cdecl _mm_mask_cvttpd_epu64(__m128i, __mmask8, __m128d);
extern __m128i   __cdecl _mm_maskz_cvttpd_epu64(__mmask8, __m128d);
extern __m256i   __cdecl _mm256_cvttpd_epu64(__m256d);
extern __m256i   __cdecl _mm256_mask_cvttpd_epu64(__m256i, __mmask8, __m256d);
extern __m256i   __cdecl _mm256_maskz_cvttpd_epu64(__mmask8, __m256d);
extern __m128i   __cdecl _mm_mask_cvttps_epi32(__m128i, __mmask8, __m128);
extern __m128i   __cdecl _mm_maskz_cvttps_epi32(__mmask8, __m128);
extern __m256i   __cdecl _mm256_mask_cvttps_epi32(__m256i, __mmask8, __m256);
extern __m256i   __cdecl _mm256_maskz_cvttps_epi32(__mmask8, __m256);
extern __m128i   __cdecl _mm_cvttps_epi64(__m128);
extern __m128i   __cdecl _mm_mask_cvttps_epi64(__m128i, __mmask8, __m128);
extern __m128i   __cdecl _mm_maskz_cvttps_epi64(__mmask8, __m128);
extern __m256i   __cdecl _mm256_cvttps_epi64(__m128);
extern __m256i   __cdecl _mm256_mask_cvttps_epi64(__m256i, __mmask8, __m128);
extern __m256i   __cdecl _mm256_maskz_cvttps_epi64(__mmask8, __m128);
extern __m128i   __cdecl _mm_cvttps_epu32(__m128);
extern __m128i   __cdecl _mm_mask_cvttps_epu32(__m128i, __mmask8, __m128);
extern __m128i   __cdecl _mm_maskz_cvttps_epu32(__mmask8, __m128);
extern __m256i   __cdecl _mm256_cvttps_epu32(__m256);
extern __m256i   __cdecl _mm256_mask_cvttps_epu32(__m256i, __mmask8, __m256);
extern __m256i   __cdecl _mm256_maskz_cvttps_epu32(__mmask8, __m256);
extern __m128i   __cdecl _mm_cvttps_epu64(__m128);
extern __m128i   __cdecl _mm_mask_cvttps_epu64(__m128i, __mmask8, __m128);
extern __m128i   __cdecl _mm_maskz_cvttps_epu64(__mmask8, __m128);
extern __m256i   __cdecl _mm256_cvttps_epu64(__m128);
extern __m256i   __cdecl _mm256_mask_cvttps_epu64(__m256i, __mmask8, __m128);
extern __m256i   __cdecl _mm256_maskz_cvttps_epu64(__mmask8, __m128);
extern __m128i   __cdecl _mm_cvtusepi16_epi8(__m128i);
extern __m128i   __cdecl _mm_mask_cvtusepi16_epi8(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_cvtusepi16_epi8(__mmask8, __m128i);
extern __m128i   __cdecl _mm256_cvtusepi16_epi8(__m256i);
extern __m128i   __cdecl _mm256_mask_cvtusepi16_epi8(__m128i, __mmask16, __m256i);
extern __m128i   __cdecl _mm256_maskz_cvtusepi16_epi8(__mmask16, __m256i);
extern void      __cdecl _mm_mask_cvtusepi16_storeu_epi8(void*, __mmask8, __m128i);
extern void      __cdecl _mm256_mask_cvtusepi16_storeu_epi8(void*, __mmask16, __m256i);
extern __m128i   __cdecl _mm_cvtusepi32_epi16(__m128i);
extern __m128i   __cdecl _mm_mask_cvtusepi32_epi16(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_cvtusepi32_epi16(__mmask8, __m128i);
extern __m128i   __cdecl _mm256_cvtusepi32_epi16(__m256i);
extern __m128i   __cdecl _mm256_mask_cvtusepi32_epi16(__m128i, __mmask8, __m256i);
extern __m128i   __cdecl _mm256_maskz_cvtusepi32_epi16(__mmask8, __m256i);
extern __m128i   __cdecl _mm_cvtusepi32_epi8(__m128i);
extern __m128i   __cdecl _mm_mask_cvtusepi32_epi8(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_cvtusepi32_epi8(__mmask8, __m128i);
extern __m128i   __cdecl _mm256_cvtusepi32_epi8(__m256i);
extern __m128i   __cdecl _mm256_mask_cvtusepi32_epi8(__m128i, __mmask8, __m256i);
extern __m128i   __cdecl _mm256_maskz_cvtusepi32_epi8(__mmask8, __m256i);
extern void      __cdecl _mm_mask_cvtusepi32_storeu_epi16(void*, __mmask8, __m128i);
extern void      __cdecl _mm256_mask_cvtusepi32_storeu_epi16(void*, __mmask8, __m256i);
extern void      __cdecl _mm_mask_cvtusepi32_storeu_epi8(void*, __mmask8, __m128i);
extern void      __cdecl _mm256_mask_cvtusepi32_storeu_epi8(void*, __mmask8, __m256i);
extern __m128i   __cdecl _mm_cvtusepi64_epi16(__m128i);
extern __m128i   __cdecl _mm_mask_cvtusepi64_epi16(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_cvtusepi64_epi16(__mmask8, __m128i);
extern __m128i   __cdecl _mm256_cvtusepi64_epi16(__m256i);
extern __m128i   __cdecl _mm256_mask_cvtusepi64_epi16(__m128i, __mmask8, __m256i);
extern __m128i   __cdecl _mm256_maskz_cvtusepi64_epi16(__mmask8, __m256i);
extern __m128i   __cdecl _mm_cvtusepi64_epi32(__m128i);
extern __m128i   __cdecl _mm_mask_cvtusepi64_epi32(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_cvtusepi64_epi32(__mmask8, __m128i);
extern __m128i   __cdecl _mm256_cvtusepi64_epi32(__m256i);
extern __m128i   __cdecl _mm256_mask_cvtusepi64_epi32(__m128i, __mmask8, __m256i);
extern __m128i   __cdecl _mm256_maskz_cvtusepi64_epi32(__mmask8, __m256i);
extern __m128i   __cdecl _mm_cvtusepi64_epi8(__m128i);
extern __m128i   __cdecl _mm_mask_cvtusepi64_epi8(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_cvtusepi64_epi8(__mmask8, __m128i);
extern __m128i   __cdecl _mm256_cvtusepi64_epi8(__m256i);
extern __m128i   __cdecl _mm256_mask_cvtusepi64_epi8(__m128i, __mmask8, __m256i);
extern __m128i   __cdecl _mm256_maskz_cvtusepi64_epi8(__mmask8, __m256i);
extern void      __cdecl _mm_mask_cvtusepi64_storeu_epi16(void*, __mmask8, __m128i);
extern void      __cdecl _mm256_mask_cvtusepi64_storeu_epi16(void*, __mmask8, __m256i);
extern void      __cdecl _mm_mask_cvtusepi64_storeu_epi32(void*, __mmask8, __m128i);
extern void      __cdecl _mm256_mask_cvtusepi64_storeu_epi32(void*, __mmask8, __m256i);
extern void      __cdecl _mm_mask_cvtusepi64_storeu_epi8(void*, __mmask8, __m128i);
extern void      __cdecl _mm256_mask_cvtusepi64_storeu_epi8(void*, __mmask8, __m256i);
extern __m128i   __cdecl _mm_dbsad_epu8(__m128i, __m128i, int);
extern __m128i   __cdecl _mm_mask_dbsad_epu8(__m128i, __mmask8, __m128i, __m128i, int);
extern __m128i   __cdecl _mm_maskz_dbsad_epu8(__mmask8, __m128i, __m128i, int);
extern __m256i   __cdecl _mm256_dbsad_epu8(__m256i, __m256i, int);
extern __m256i   __cdecl _mm256_mask_dbsad_epu8(__m256i, __mmask16, __m256i, __m256i, int);
extern __m256i   __cdecl _mm256_maskz_dbsad_epu8(__mmask16, __m256i, __m256i, int);
extern __m128d   __cdecl _mm_mask_div_pd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_maskz_div_pd(__mmask8, __m128d, __m128d);
extern __m256d   __cdecl _mm256_mask_div_pd(__m256d, __mmask8, __m256d, __m256d);
extern __m256d   __cdecl _mm256_maskz_div_pd(__mmask8, __m256d, __m256d);
extern __m128    __cdecl _mm_mask_div_ps(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_maskz_div_ps(__mmask8, __m128, __m128);
extern __m256    __cdecl _mm256_mask_div_ps(__m256, __mmask8, __m256, __m256);
extern __m256    __cdecl _mm256_maskz_div_ps(__mmask8, __m256, __m256);
extern __m128i   __cdecl _mm_mask_expand_epi8(__m128i, __mmask16, __m128i);
extern __m128i   __cdecl _mm_maskz_expand_epi8(__mmask16, __m128i);
extern __m256i   __cdecl _mm256_mask_expand_epi8(__m256i, __mmask32, __m256i);
extern __m256i   __cdecl _mm256_maskz_expand_epi8(__mmask32, __m256i);
extern __m128i   __cdecl _mm_mask_expand_epi16(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_expand_epi16(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_mask_expand_epi16(__m256i, __mmask16, __m256i);
extern __m256i   __cdecl _mm256_maskz_expand_epi16(__mmask16, __m256i);
extern __m128i   __cdecl _mm_mask_expand_epi32(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_expand_epi32(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_mask_expand_epi32(__m256i, __mmask8, __m256i);
extern __m256i   __cdecl _mm256_maskz_expand_epi32(__mmask8, __m256i);
extern __m128i   __cdecl _mm_mask_expand_epi64(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_expand_epi64(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_mask_expand_epi64(__m256i, __mmask8, __m256i);
extern __m256i   __cdecl _mm256_maskz_expand_epi64(__mmask8, __m256i);
extern __m128d   __cdecl _mm_mask_expand_pd(__m128d, __mmask8, __m128d);
extern __m128d   __cdecl _mm_maskz_expand_pd(__mmask8, __m128d);
extern __m256d   __cdecl _mm256_mask_expand_pd(__m256d, __mmask8, __m256d);
extern __m256d   __cdecl _mm256_maskz_expand_pd(__mmask8, __m256d);
extern __m128    __cdecl _mm_mask_expand_ps(__m128, __mmask8, __m128);
extern __m128    __cdecl _mm_maskz_expand_ps(__mmask8, __m128);
extern __m256    __cdecl _mm256_mask_expand_ps(__m256, __mmask8, __m256);
extern __m256    __cdecl _mm256_maskz_expand_ps(__mmask8, __m256);
extern __m128i   __cdecl _mm_mask_expandloadu_epi8(__m128i, __mmask16, const void*);
extern __m128i   __cdecl _mm_maskz_expandloadu_epi8(__mmask16, const void*);
extern __m256i   __cdecl _mm256_mask_expandloadu_epi8(__m256i, __mmask32, const void*);
extern __m256i   __cdecl _mm256_maskz_expandloadu_epi8(__mmask32, const void*);
extern __m128i   __cdecl _mm_mask_expandloadu_epi16(__m128i, __mmask8, const void*);
extern __m128i   __cdecl _mm_maskz_expandloadu_epi16(__mmask8, const void*);
extern __m256i   __cdecl _mm256_mask_expandloadu_epi16(__m256i, __mmask16, const void*);
extern __m256i   __cdecl _mm256_maskz_expandloadu_epi16(__mmask16, const void*);
extern __m128i   __cdecl _mm_mask_expandloadu_epi32(__m128i, __mmask8, void const*);
extern __m128i   __cdecl _mm_maskz_expandloadu_epi32(__mmask8, void const*);
extern __m256i   __cdecl _mm256_mask_expandloadu_epi32(__m256i, __mmask8, void const*);
extern __m256i   __cdecl _mm256_maskz_expandloadu_epi32(__mmask8, void const*);
extern __m128i   __cdecl _mm_mask_expandloadu_epi64(__m128i, __mmask8, void const*);
extern __m128i   __cdecl _mm_maskz_expandloadu_epi64(__mmask8, void const*);
extern __m256i   __cdecl _mm256_mask_expandloadu_epi64(__m256i, __mmask8, void const*);
extern __m256i   __cdecl _mm256_maskz_expandloadu_epi64(__mmask8, void const*);
extern __m128d   __cdecl _mm_mask_expandloadu_pd(__m128d, __mmask8, void const*);
extern __m128d   __cdecl _mm_maskz_expandloadu_pd(__mmask8, void const*);
extern __m256d   __cdecl _mm256_mask_expandloadu_pd(__m256d, __mmask8, void const*);
extern __m256d   __cdecl _mm256_maskz_expandloadu_pd(__mmask8, void const*);
extern __m128    __cdecl _mm_mask_expandloadu_ps(__m128, __mmask8, void const*);
extern __m128    __cdecl _mm_maskz_expandloadu_ps(__mmask8, void const*);
extern __m256    __cdecl _mm256_mask_expandloadu_ps(__m256, __mmask8, void const*);
extern __m256    __cdecl _mm256_maskz_expandloadu_ps(__mmask8, void const*);
extern __m128    __cdecl _mm256_extractf32x4_ps(__m256, int);
extern __m128    __cdecl _mm256_mask_extractf32x4_ps(__m128, __mmask8, __m256, int);
extern __m128    __cdecl _mm256_maskz_extractf32x4_ps(__mmask8, __m256, int);
extern __m128d   __cdecl _mm256_extractf64x2_pd(__m256d, int);
extern __m128d   __cdecl _mm256_mask_extractf64x2_pd(__m128d, __mmask8, __m256d, int);
extern __m128d   __cdecl _mm256_maskz_extractf64x2_pd(__mmask8, __m256d, int);
extern __m128i   __cdecl _mm256_extracti32x4_epi32(__m256i, int);
extern __m128i   __cdecl _mm256_mask_extracti32x4_epi32(__m128i, __mmask8, __m256i, int);
extern __m128i   __cdecl _mm256_maskz_extracti32x4_epi32(__mmask8, __m256i, int);
extern __m128i   __cdecl _mm256_extracti64x2_epi64(__m256i, int);
extern __m128i   __cdecl _mm256_mask_extracti64x2_epi64(__m128i, __mmask8, __m256i, int);
extern __m128i   __cdecl _mm256_maskz_extracti64x2_epi64(__mmask8, __m256i, int);
extern __m128d   __cdecl _mm_fixupimm_pd(__m128d, __m128d, __m128i, const int);
extern __m128d   __cdecl _mm_mask_fixupimm_pd(__m128d, __mmask8, __m128d, __m128i, const int);
extern __m128d   __cdecl _mm_maskz_fixupimm_pd(__mmask8, __m128d, __m128d, __m128i, const int);
extern __m256d   __cdecl _mm256_fixupimm_pd(__m256d, __m256d, __m256i, const int);
extern __m256d   __cdecl _mm256_mask_fixupimm_pd(__m256d, __mmask8, __m256d, __m256i, const int);
extern __m256d   __cdecl _mm256_maskz_fixupimm_pd(__mmask8, __m256d, __m256d, __m256i, const int);
extern __m128    __cdecl _mm_fixupimm_ps(__m128, __m128, __m128i, const int);
extern __m128    __cdecl _mm_mask_fixupimm_ps(__m128, __mmask8, __m128, __m128i, const int);
extern __m128    __cdecl _mm_maskz_fixupimm_ps(__mmask8, __m128, __m128, __m128i, const int);
extern __m256    __cdecl _mm256_fixupimm_ps(__m256, __m256, __m256i, const int);
extern __m256    __cdecl _mm256_mask_fixupimm_ps(__m256, __mmask8, __m256, __m256i, const int);
extern __m256    __cdecl _mm256_maskz_fixupimm_ps(__mmask8, __m256, __m256, __m256i, const int);
extern __m128d   __cdecl _mm_mask_fmadd_pd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_mask3_fmadd_pd(__m128d, __m128d, __m128d, __mmask8);
extern __m128d   __cdecl _mm_maskz_fmadd_pd(__mmask8, __m128d, __m128d, __m128d);
extern __m256d   __cdecl _mm256_mask_fmadd_pd(__m256d, __mmask8, __m256d, __m256d);
extern __m256d   __cdecl _mm256_mask3_fmadd_pd(__m256d, __m256d, __m256d, __mmask8);
extern __m256d   __cdecl _mm256_maskz_fmadd_pd(__mmask8, __m256d, __m256d, __m256d);
extern __m128    __cdecl _mm_mask_fmadd_ps(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_mask3_fmadd_ps(__m128, __m128, __m128, __mmask8);
extern __m128    __cdecl _mm_maskz_fmadd_ps(__mmask8, __m128, __m128, __m128);
extern __m256    __cdecl _mm256_mask_fmadd_ps(__m256, __mmask8, __m256, __m256);
extern __m256    __cdecl _mm256_mask3_fmadd_ps(__m256, __m256, __m256, __mmask8);
extern __m256    __cdecl _mm256_maskz_fmadd_ps(__mmask8, __m256, __m256, __m256);
extern __m128d   __cdecl _mm_mask_fmaddsub_pd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_mask3_fmaddsub_pd(__m128d, __m128d, __m128d, __mmask8);
extern __m128d   __cdecl _mm_maskz_fmaddsub_pd(__mmask8, __m128d, __m128d, __m128d);
extern __m256d   __cdecl _mm256_mask_fmaddsub_pd(__m256d, __mmask8, __m256d, __m256d);
extern __m256d   __cdecl _mm256_mask3_fmaddsub_pd(__m256d, __m256d, __m256d, __mmask8);
extern __m256d   __cdecl _mm256_maskz_fmaddsub_pd(__mmask8, __m256d, __m256d, __m256d);
extern __m128    __cdecl _mm_mask_fmaddsub_ps(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_mask3_fmaddsub_ps(__m128, __m128, __m128, __mmask8);
extern __m128    __cdecl _mm_maskz_fmaddsub_ps(__mmask8, __m128, __m128, __m128);
extern __m256    __cdecl _mm256_mask_fmaddsub_ps(__m256, __mmask8, __m256, __m256);
extern __m256    __cdecl _mm256_mask3_fmaddsub_ps(__m256, __m256, __m256, __mmask8);
extern __m256    __cdecl _mm256_maskz_fmaddsub_ps(__mmask8, __m256, __m256, __m256);
extern __m128d   __cdecl _mm_mask_fmsub_pd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_mask3_fmsub_pd(__m128d, __m128d, __m128d, __mmask8);
extern __m128d   __cdecl _mm_maskz_fmsub_pd(__mmask8, __m128d, __m128d, __m128d);
extern __m256d   __cdecl _mm256_mask_fmsub_pd(__m256d, __mmask8, __m256d, __m256d);
extern __m256d   __cdecl _mm256_mask3_fmsub_pd(__m256d, __m256d, __m256d, __mmask8);
extern __m256d   __cdecl _mm256_maskz_fmsub_pd(__mmask8, __m256d, __m256d, __m256d);
extern __m128    __cdecl _mm_mask_fmsub_ps(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_mask3_fmsub_ps(__m128, __m128, __m128, __mmask8);
extern __m128    __cdecl _mm_maskz_fmsub_ps(__mmask8, __m128, __m128, __m128);
extern __m256    __cdecl _mm256_mask_fmsub_ps(__m256, __mmask8, __m256, __m256);
extern __m256    __cdecl _mm256_mask3_fmsub_ps(__m256, __m256, __m256, __mmask8);
extern __m256    __cdecl _mm256_maskz_fmsub_ps(__mmask8, __m256, __m256, __m256);
extern __m128d   __cdecl _mm_mask_fmsubadd_pd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_mask3_fmsubadd_pd(__m128d, __m128d, __m128d, __mmask8);
extern __m128d   __cdecl _mm_maskz_fmsubadd_pd(__mmask8, __m128d, __m128d, __m128d);
extern __m256d   __cdecl _mm256_mask_fmsubadd_pd(__m256d, __mmask8, __m256d, __m256d);
extern __m256d   __cdecl _mm256_mask3_fmsubadd_pd(__m256d, __m256d, __m256d, __mmask8);
extern __m256d   __cdecl _mm256_maskz_fmsubadd_pd(__mmask8, __m256d, __m256d, __m256d);
extern __m128    __cdecl _mm_mask_fmsubadd_ps(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_mask3_fmsubadd_ps(__m128, __m128, __m128, __mmask8);
extern __m128    __cdecl _mm_maskz_fmsubadd_ps(__mmask8, __m128, __m128, __m128);
extern __m256    __cdecl _mm256_mask_fmsubadd_ps(__m256, __mmask8, __m256, __m256);
extern __m256    __cdecl _mm256_mask3_fmsubadd_ps(__m256, __m256, __m256, __mmask8);
extern __m256    __cdecl _mm256_maskz_fmsubadd_ps(__mmask8, __m256, __m256, __m256);
extern __m128d   __cdecl _mm_mask_fnmadd_pd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_mask3_fnmadd_pd(__m128d, __m128d, __m128d, __mmask8);
extern __m128d   __cdecl _mm_maskz_fnmadd_pd(__mmask8, __m128d, __m128d, __m128d);
extern __m256d   __cdecl _mm256_mask_fnmadd_pd(__m256d, __mmask8, __m256d, __m256d);
extern __m256d   __cdecl _mm256_mask3_fnmadd_pd(__m256d, __m256d, __m256d, __mmask8);
extern __m256d   __cdecl _mm256_maskz_fnmadd_pd(__mmask8, __m256d, __m256d, __m256d);
extern __m128    __cdecl _mm_mask_fnmadd_ps(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_mask3_fnmadd_ps(__m128, __m128, __m128, __mmask8);
extern __m128    __cdecl _mm_maskz_fnmadd_ps(__mmask8, __m128, __m128, __m128);
extern __m256    __cdecl _mm256_mask_fnmadd_ps(__m256, __mmask8, __m256, __m256);
extern __m256    __cdecl _mm256_mask3_fnmadd_ps(__m256, __m256, __m256, __mmask8);
extern __m256    __cdecl _mm256_maskz_fnmadd_ps(__mmask8, __m256, __m256, __m256);
extern __m128d   __cdecl _mm_mask_fnmsub_pd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_mask3_fnmsub_pd(__m128d, __m128d, __m128d, __mmask8);
extern __m128d   __cdecl _mm_maskz_fnmsub_pd(__mmask8, __m128d, __m128d, __m128d);
extern __m256d   __cdecl _mm256_mask_fnmsub_pd(__m256d, __mmask8, __m256d, __m256d);
extern __m256d   __cdecl _mm256_mask3_fnmsub_pd(__m256d, __m256d, __m256d, __mmask8);
extern __m256d   __cdecl _mm256_maskz_fnmsub_pd(__mmask8, __m256d, __m256d, __m256d);
extern __m128    __cdecl _mm_mask_fnmsub_ps(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_mask3_fnmsub_ps(__m128, __m128, __m128, __mmask8);
extern __m128    __cdecl _mm_maskz_fnmsub_ps(__mmask8, __m128, __m128, __m128);
extern __m256    __cdecl _mm256_mask_fnmsub_ps(__m256, __mmask8, __m256, __m256);
extern __m256    __cdecl _mm256_mask3_fnmsub_ps(__m256, __m256, __m256, __mmask8);
extern __m256    __cdecl _mm256_maskz_fnmsub_ps(__mmask8, __m256, __m256, __m256);
extern __mmask8  __cdecl _mm_fpclass_pd_mask(__m128d, int);
extern __mmask8  __cdecl _mm_mask_fpclass_pd_mask(__mmask8, __m128d, int);
extern __mmask8  __cdecl _mm256_fpclass_pd_mask(__m256d, int);
extern __mmask8  __cdecl _mm256_mask_fpclass_pd_mask(__mmask8, __m256d, int);
extern __mmask8  __cdecl _mm_fpclass_ps_mask(__m128, int);
extern __mmask8  __cdecl _mm_mask_fpclass_ps_mask(__mmask8, __m128, int);
extern __mmask8  __cdecl _mm256_fpclass_ps_mask(__m256, int);
extern __mmask8  __cdecl _mm256_mask_fpclass_ps_mask(__mmask8, __m256, int);
extern __m128d   __cdecl _mm_getexp_pd(__m128d);
extern __m128d   __cdecl _mm_mask_getexp_pd(__m128d, __mmask8, __m128d);
extern __m128d   __cdecl _mm_maskz_getexp_pd(__mmask8, __m128d);
extern __m256d   __cdecl _mm256_getexp_pd(__m256d);
extern __m256d   __cdecl _mm256_mask_getexp_pd(__m256d, __mmask8, __m256d);
extern __m256d   __cdecl _mm256_maskz_getexp_pd(__mmask8, __m256d);
extern __m128    __cdecl _mm_getexp_ps(__m128);
extern __m128    __cdecl _mm_mask_getexp_ps(__m128, __mmask8, __m128);
extern __m128    __cdecl _mm_maskz_getexp_ps(__mmask8, __m128);
extern __m256    __cdecl _mm256_getexp_ps(__m256);
extern __m256    __cdecl _mm256_mask_getexp_ps(__m256, __mmask8, __m256);
extern __m256    __cdecl _mm256_maskz_getexp_ps(__mmask8, __m256);
extern __m128d   __cdecl _mm_getmant_pd(__m128d, int, int);
extern __m128d   __cdecl _mm_mask_getmant_pd(__m128d, __mmask8, __m128d, int, int);
extern __m128d   __cdecl _mm_maskz_getmant_pd(__mmask8, __m128d, int, int);
extern __m256d   __cdecl _mm256_getmant_pd(__m256d, int, int);
extern __m256d   __cdecl _mm256_mask_getmant_pd(__m256d, __mmask8, __m256d, int, int);
extern __m256d   __cdecl _mm256_maskz_getmant_pd(__mmask8, __m256d, int, int);
extern __m128    __cdecl _mm_getmant_ps(__m128, int, int);
extern __m128    __cdecl _mm_mask_getmant_ps(__m128, __mmask8, __m128, int, int);
extern __m128    __cdecl _mm_maskz_getmant_ps(__mmask8, __m128, int, int);
extern __m256    __cdecl _mm256_getmant_ps(__m256, int, int);
extern __m256    __cdecl _mm256_mask_getmant_ps(__m256, __mmask8, __m256, int, int);
extern __m256    __cdecl _mm256_maskz_getmant_ps(__mmask8, __m256, int, int);
extern __m128i   __cdecl _mm_mmask_i32gather_epi32(__m128i, __mmask8, __m128i, void const*, const int);
extern __m256i   __cdecl _mm256_mmask_i32gather_epi32(__m256i, __mmask8, __m256i, void const*, const int);
extern __m128i   __cdecl _mm_mmask_i32gather_epi64(__m128i, __mmask8, __m128i, void const*, const int);
extern __m256i   __cdecl _mm256_mmask_i32gather_epi64(__m256i, __mmask8, __m128i, void const*, const int);
extern __m128d   __cdecl _mm_mmask_i32gather_pd(__m128d, __mmask8, __m128i, void const*, const int);
extern __m256d   __cdecl _mm256_mmask_i32gather_pd(__m256d, __mmask8, __m128i, void const*, const int);
extern __m128    __cdecl _mm_mmask_i32gather_ps(__m128, __mmask8, __m128i, void const*, const int);
extern __m256    __cdecl _mm256_mmask_i32gather_ps(__m256, __mmask8, __m256i, void const*, const int);
extern void      __cdecl _mm_i32scatter_epi32(void*, __m128i, __m128i, const int);
extern void      __cdecl _mm_mask_i32scatter_epi32(void*, __mmask8, __m128i, __m128i, const int);
extern void      __cdecl _mm256_i32scatter_epi32(void*, __m256i, __m256i, const int);
extern void      __cdecl _mm256_mask_i32scatter_epi32(void*, __mmask8, __m256i, __m256i, const int);
extern void      __cdecl _mm_i32scatter_epi64(void*, __m128i, __m128i, const int);
extern void      __cdecl _mm_mask_i32scatter_epi64(void*, __mmask8, __m128i, __m128i, const int);
extern void      __cdecl _mm256_i32scatter_epi64(void*, __m128i, __m256i, const int);
extern void      __cdecl _mm256_mask_i32scatter_epi64(void*, __mmask8, __m128i, __m256i, const int);
extern void      __cdecl _mm_i32scatter_pd(void*, __m128i, __m128d, const int);
extern void      __cdecl _mm_mask_i32scatter_pd(void*, __mmask8, __m128i, __m128d, const int);
extern void      __cdecl _mm256_i32scatter_pd(void*, __m128i, __m256d, const int);
extern void      __cdecl _mm256_mask_i32scatter_pd(void*, __mmask8, __m128i, __m256d, const int);
extern void      __cdecl _mm_i32scatter_ps(void*, __m128i, __m128, const int);
extern void      __cdecl _mm_mask_i32scatter_ps(void*, __mmask8, __m128i, __m128, const int);
extern void      __cdecl _mm256_i32scatter_ps(void*, __m256i, __m256, const int);
extern void      __cdecl _mm256_mask_i32scatter_ps(void*, __mmask8, __m256i, __m256, const int);
extern __m128i   __cdecl _mm_mmask_i64gather_epi32(__m128i, __mmask8, __m128i, void const*, const int);
extern __m128i   __cdecl _mm256_mmask_i64gather_epi32(__m128i, __mmask8, __m256i, void const*, const int);
extern __m128i   __cdecl _mm_mmask_i64gather_epi64(__m128i, __mmask8, __m128i, void const*, const int);
extern __m256i   __cdecl _mm256_mmask_i64gather_epi64(__m256i, __mmask8, __m256i, void const*, const int);
extern __m128d   __cdecl _mm_mmask_i64gather_pd(__m128d, __mmask8, __m128i, void const*, const int);
extern __m256d   __cdecl _mm256_mmask_i64gather_pd(__m256d, __mmask8, __m256i, void const*, const int);
extern __m128    __cdecl _mm_mmask_i64gather_ps(__m128, __mmask8, __m128i, void const*, const int);
extern __m128    __cdecl _mm256_mmask_i64gather_ps(__m128, __mmask8, __m256i, void const*, const int);
extern void      __cdecl _mm_i64scatter_epi32(void*, __m128i, __m128i, const int);
extern void      __cdecl _mm_mask_i64scatter_epi32(void*, __mmask8, __m128i, __m128i, const int);
extern void      __cdecl _mm256_i64scatter_epi32(void*, __m256i, __m128i, const int);
extern void      __cdecl _mm256_mask_i64scatter_epi32(void*, __mmask8, __m256i, __m128i, const int);
extern void      __cdecl _mm_i64scatter_epi64(void*, __m128i, __m128i, const int);
extern void      __cdecl _mm_mask_i64scatter_epi64(void*, __mmask8, __m128i, __m128i, const int);
extern void      __cdecl _mm256_i64scatter_epi64(void*, __m256i, __m256i, const int);
extern void      __cdecl _mm256_mask_i64scatter_epi64(void*, __mmask8, __m256i, __m256i, const int);
extern void      __cdecl _mm_i64scatter_pd(void*, __m128i, __m128d, const int);
extern void      __cdecl _mm_mask_i64scatter_pd(void*, __mmask8, __m128i, __m128d, const int);
extern void      __cdecl _mm256_i64scatter_pd(void*, __m256i, __m256d, const int);
extern void      __cdecl _mm256_mask_i64scatter_pd(void*, __mmask8, __m256i, __m256d, const int);
extern void      __cdecl _mm_i64scatter_ps(void*, __m128i, __m128, const int);
extern void      __cdecl _mm_mask_i64scatter_ps(void*, __mmask8, __m128i, __m128, const int);
extern void      __cdecl _mm256_i64scatter_ps(void*, __m256i, __m128, const int);
extern void      __cdecl _mm256_mask_i64scatter_ps(void*, __mmask8, __m256i, __m128, const int);
extern __m256    __cdecl _mm256_insertf32x4(__m256, __m128, int);
extern __m256    __cdecl _mm256_mask_insertf32x4(__m256, __mmask8, __m256, __m128, int);
extern __m256    __cdecl _mm256_maskz_insertf32x4(__mmask8, __m256, __m128, int);
extern __m256d   __cdecl _mm256_insertf64x2(__m256d, __m128d, int);
extern __m256d   __cdecl _mm256_mask_insertf64x2(__m256d, __mmask8, __m256d, __m128d, int);
extern __m256d   __cdecl _mm256_maskz_insertf64x2(__mmask8, __m256d, __m128d, int);
extern __m256i   __cdecl _mm256_inserti32x4(__m256i, __m128i, int);
extern __m256i   __cdecl _mm256_mask_inserti32x4(__m256i, __mmask8, __m256i, __m128i, int);
extern __m256i   __cdecl _mm256_maskz_inserti32x4(__mmask8, __m256i, __m128i, int);
extern __m256i   __cdecl _mm256_inserti64x2(__m256i, __m128i, int);
extern __m256i   __cdecl _mm256_mask_inserti64x2(__m256i, __mmask8, __m256i, __m128i, int);
extern __m256i   __cdecl _mm256_maskz_inserti64x2(__mmask8, __m256i, __m128i, int);
extern __m128i   __cdecl _mm_mask_load_epi32(__m128i, __mmask8, void const*);
extern __m128i   __cdecl _mm_maskz_load_epi32(__mmask8, void const*);
extern __m256i   __cdecl _mm256_mask_load_epi32(__m256i, __mmask8, void const*);
extern __m256i   __cdecl _mm256_maskz_load_epi32(__mmask8, void const*);
extern __m128i   __cdecl _mm_mask_load_epi64(__m128i, __mmask8, void const*);
extern __m128i   __cdecl _mm_maskz_load_epi64(__mmask8, void const*);
extern __m256i   __cdecl _mm256_mask_load_epi64(__m256i, __mmask8, void const*);
extern __m256i   __cdecl _mm256_maskz_load_epi64(__mmask8, void const*);
extern __m128d   __cdecl _mm_mask_load_pd(__m128d, __mmask8, void const*);
extern __m128d   __cdecl _mm_maskz_load_pd(__mmask8, void const*);
extern __m256d   __cdecl _mm256_mask_load_pd(__m256d, __mmask8, void const*);
extern __m256d   __cdecl _mm256_maskz_load_pd(__mmask8, void const*);
extern __m128    __cdecl _mm_mask_load_ps(__m128, __mmask8, void const*);
extern __m128    __cdecl _mm_maskz_load_ps(__mmask8, void const*);
extern __m256    __cdecl _mm256_mask_load_ps(__m256, __mmask8, void const*);
extern __m256    __cdecl _mm256_maskz_load_ps(__mmask8, void const*);
extern __m128i   __cdecl _mm_loadu_epi16(void const*);
extern __m128i   __cdecl _mm_mask_loadu_epi16(__m128i, __mmask8, void const*);
extern __m128i   __cdecl _mm_maskz_loadu_epi16(__mmask8, void const*);
extern __m256i   __cdecl _mm256_loadu_epi16(void const*);
extern __m256i   __cdecl _mm256_mask_loadu_epi16(__m256i, __mmask16, void const*);
extern __m256i   __cdecl _mm256_maskz_loadu_epi16(__mmask16, void const*);
extern __m128i   __cdecl _mm_loadu_epi32(void const*);
extern __m128i   __cdecl _mm_mask_loadu_epi32(__m128i, __mmask8, void const*);
extern __m128i   __cdecl _mm_maskz_loadu_epi32(__mmask8, void const*);
extern __m256i   __cdecl _mm256_loadu_epi32(void const*);
extern __m256i   __cdecl _mm256_mask_loadu_epi32(__m256i, __mmask8, void const*);
extern __m256i   __cdecl _mm256_maskz_loadu_epi32(__mmask8, void const*);
extern __m128i   __cdecl _mm_loadu_epi64(void const*);
extern __m128i   __cdecl _mm_mask_loadu_epi64(__m128i, __mmask8, void const*);
extern __m128i   __cdecl _mm_maskz_loadu_epi64(__mmask8, void const*);
extern __m256i   __cdecl _mm256_loadu_epi64(void const*);
extern __m256i   __cdecl _mm256_mask_loadu_epi64(__m256i, __mmask8, void const*);
extern __m256i   __cdecl _mm256_maskz_loadu_epi64(__mmask8, void const*);
extern __m128i   __cdecl _mm_loadu_epi8(void const*);
extern __m128i   __cdecl _mm_mask_loadu_epi8(__m128i, __mmask16, void const*);
extern __m128i   __cdecl _mm_maskz_loadu_epi8(__mmask16, void const*);
extern __m256i   __cdecl _mm256_loadu_epi8(void const*);
extern __m256i   __cdecl _mm256_mask_loadu_epi8(__m256i, __mmask32, void const*);
extern __m256i   __cdecl _mm256_maskz_loadu_epi8(__mmask32, void const*);
extern __m128d   __cdecl _mm_mask_loadu_pd(__m128d, __mmask8, void const*);
extern __m128d   __cdecl _mm_maskz_loadu_pd(__mmask8, void const*);
extern __m256d   __cdecl _mm256_mask_loadu_pd(__m256d, __mmask8, void const*);
extern __m256d   __cdecl _mm256_maskz_loadu_pd(__mmask8, void const*);
extern __m128    __cdecl _mm_mask_loadu_ps(__m128, __mmask8, void const*);
extern __m128    __cdecl _mm_maskz_loadu_ps(__mmask8, void const*);
extern __m256    __cdecl _mm256_mask_loadu_ps(__m256, __mmask8, void const*);
extern __m256    __cdecl _mm256_maskz_loadu_ps(__mmask8, void const*);
extern __m128i   __cdecl _mm_lzcnt_epi32(__m128i);
extern __m128i   __cdecl _mm_mask_lzcnt_epi32(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_lzcnt_epi32(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_lzcnt_epi32(__m256i);
extern __m256i   __cdecl _mm256_mask_lzcnt_epi32(__m256i, __mmask8, __m256i);
extern __m256i   __cdecl _mm256_maskz_lzcnt_epi32(__mmask8, __m256i);
extern __m128i   __cdecl _mm_lzcnt_epi64(__m128i);
extern __m128i   __cdecl _mm_mask_lzcnt_epi64(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_lzcnt_epi64(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_lzcnt_epi64(__m256i);
extern __m256i   __cdecl _mm256_mask_lzcnt_epi64(__m256i, __mmask8, __m256i);
extern __m256i   __cdecl _mm256_maskz_lzcnt_epi64(__mmask8, __m256i);
extern __m128i   __cdecl _mm_mask_madd_epi16(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_madd_epi16(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_madd_epi16(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_madd_epi16(__mmask8, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_maddubs_epi16(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_maddubs_epi16(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_maddubs_epi16(__m256i, __mmask16, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_maddubs_epi16(__mmask16, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_max_epi16(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_max_epi16(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_max_epi16(__m256i, __mmask16, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_max_epi16(__mmask16, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_max_epi32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_max_epi32(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_max_epi32(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_max_epi32(__mmask8, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_max_epi64(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_max_epi64(__mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_max_epi64(__m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_max_epi64(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_max_epi64(__mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_max_epi64(__m256i, __m256i);
extern __m128i   __cdecl _mm_mask_max_epi8(__m128i, __mmask16, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_max_epi8(__mmask16, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_max_epi8(__m256i, __mmask32, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_max_epi8(__mmask32, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_max_epu16(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_max_epu16(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_max_epu16(__m256i, __mmask16, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_max_epu16(__mmask16, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_max_epu32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_max_epu32(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_max_epu32(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_max_epu32(__mmask8, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_max_epu64(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_max_epu64(__mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_max_epu64(__m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_max_epu64(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_max_epu64(__mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_max_epu64(__m256i, __m256i);
extern __m128i   __cdecl _mm_mask_max_epu8(__m128i, __mmask16, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_max_epu8(__mmask16, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_max_epu8(__m256i, __mmask32, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_max_epu8(__mmask32, __m256i, __m256i);
extern __m128d   __cdecl _mm_mask_max_pd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_maskz_max_pd(__mmask8, __m128d, __m128d);
extern __m256d   __cdecl _mm256_mask_max_pd(__m256d, __mmask8, __m256d, __m256d);
extern __m256d   __cdecl _mm256_maskz_max_pd(__mmask8, __m256d, __m256d);
extern __m128    __cdecl _mm_mask_max_ps(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_maskz_max_ps(__mmask8, __m128, __m128);
extern __m256    __cdecl _mm256_mask_max_ps(__m256, __mmask8, __m256, __m256);
extern __m256    __cdecl _mm256_maskz_max_ps(__mmask8, __m256, __m256);
extern __m128i   __cdecl _mm_mask_min_epi16(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_min_epi16(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_min_epi16(__m256i, __mmask16, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_min_epi16(__mmask16, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_min_epi32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_min_epi32(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_min_epi32(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_min_epi32(__mmask8, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_min_epi64(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_min_epi64(__mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_min_epi64(__m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_min_epi64(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_min_epi64(__mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_min_epi64(__m256i, __m256i);
extern __m128i   __cdecl _mm_mask_min_epi8(__m128i, __mmask16, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_min_epi8(__mmask16, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_min_epi8(__m256i, __mmask32, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_min_epi8(__mmask32, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_min_epu16(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_min_epu16(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_min_epu16(__m256i, __mmask16, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_min_epu16(__mmask16, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_min_epu32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_min_epu32(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_min_epu32(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_min_epu32(__mmask8, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_min_epu64(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_min_epu64(__mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_min_epu64(__m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_min_epu64(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_min_epu64(__mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_min_epu64(__m256i, __m256i);
extern __m128i   __cdecl _mm_mask_min_epu8(__m128i, __mmask16, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_min_epu8(__mmask16, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_min_epu8(__m256i, __mmask32, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_min_epu8(__mmask32, __m256i, __m256i);
extern __m128d   __cdecl _mm_mask_min_pd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_maskz_min_pd(__mmask8, __m128d, __m128d);
extern __m256d   __cdecl _mm256_mask_min_pd(__m256d, __mmask8, __m256d, __m256d);
extern __m256d   __cdecl _mm256_maskz_min_pd(__mmask8, __m256d, __m256d);
extern __m128    __cdecl _mm_mask_min_ps(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_maskz_min_ps(__mmask8, __m128, __m128);
extern __m256    __cdecl _mm256_mask_min_ps(__m256, __mmask8, __m256, __m256);
extern __m256    __cdecl _mm256_maskz_min_ps(__mmask8, __m256, __m256);
extern __m128i   __cdecl _mm_mask_mov_epi16(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_mov_epi16(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_mask_mov_epi16(__m256i, __mmask16, __m256i);
extern __m256i   __cdecl _mm256_maskz_mov_epi16(__mmask16, __m256i);
extern __m128i   __cdecl _mm_mask_mov_epi32(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_mov_epi32(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_mask_mov_epi32(__m256i, __mmask8, __m256i);
extern __m256i   __cdecl _mm256_maskz_mov_epi32(__mmask8, __m256i);
extern __m128i   __cdecl _mm_mask_mov_epi64(__m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_mov_epi64(__mmask8, __m128i);
extern __m256i   __cdecl _mm256_mask_mov_epi64(__m256i, __mmask8, __m256i);
extern __m256i   __cdecl _mm256_maskz_mov_epi64(__mmask8, __m256i);
extern __m128i   __cdecl _mm_mask_mov_epi8(__m128i, __mmask16, __m128i);
extern __m128i   __cdecl _mm_maskz_mov_epi8(__mmask16, __m128i);
extern __m256i   __cdecl _mm256_mask_mov_epi8(__m256i, __mmask32, __m256i);
extern __m256i   __cdecl _mm256_maskz_mov_epi8(__mmask32, __m256i);
extern __m128d   __cdecl _mm_mask_mov_pd(__m128d, __mmask8, __m128d);
extern __m128d   __cdecl _mm_maskz_mov_pd(__mmask8, __m128d);
extern __m256d   __cdecl _mm256_mask_mov_pd(__m256d, __mmask8, __m256d);
extern __m256d   __cdecl _mm256_maskz_mov_pd(__mmask8, __m256d);
extern __m128    __cdecl _mm_mask_mov_ps(__m128, __mmask8, __m128);
extern __m128    __cdecl _mm_maskz_mov_ps(__mmask8, __m128);
extern __m256    __cdecl _mm256_mask_mov_ps(__m256, __mmask8, __m256);
extern __m256    __cdecl _mm256_maskz_mov_ps(__mmask8, __m256);
extern __m128d   __cdecl _mm_mask_movedup_pd(__m128d, __mmask8, __m128d);
extern __m128d   __cdecl _mm_maskz_movedup_pd(__mmask8, __m128d);
extern __m256d   __cdecl _mm256_mask_movedup_pd(__m256d, __mmask8, __m256d);
extern __m256d   __cdecl _mm256_maskz_movedup_pd(__mmask8, __m256d);
extern __m128    __cdecl _mm_mask_movehdup_ps(__m128, __mmask8, __m128);
extern __m128    __cdecl _mm_maskz_movehdup_ps(__mmask8, __m128);
extern __m256    __cdecl _mm256_mask_movehdup_ps(__m256, __mmask8, __m256);
extern __m256    __cdecl _mm256_maskz_movehdup_ps(__mmask8, __m256);
extern __m128    __cdecl _mm_mask_moveldup_ps(__m128, __mmask8, __m128);
extern __m128    __cdecl _mm_maskz_moveldup_ps(__mmask8, __m128);
extern __m256    __cdecl _mm256_mask_moveldup_ps(__m256, __mmask8, __m256);
extern __m256    __cdecl _mm256_maskz_moveldup_ps(__mmask8, __m256);
extern __mmask8  __cdecl _mm_movepi16_mask(__m128i);
extern __mmask16 __cdecl _mm256_movepi16_mask(__m256i);
extern __mmask8  __cdecl _mm_movepi32_mask(__m128i);
extern __mmask8  __cdecl _mm256_movepi32_mask(__m256i);
extern __mmask8  __cdecl _mm_movepi64_mask(__m128i);
extern __mmask8  __cdecl _mm256_movepi64_mask(__m256i);
extern __mmask16 __cdecl _mm_movepi8_mask(__m128i);
extern __mmask32 __cdecl _mm256_movepi8_mask(__m256i);
extern __m128i   __cdecl _mm_movm_epi16(__mmask8);
extern __m256i   __cdecl _mm256_movm_epi16(__mmask16);
extern __m128i   __cdecl _mm_movm_epi32(__mmask8);
extern __m256i   __cdecl _mm256_movm_epi32(__mmask8);
extern __m128i   __cdecl _mm_movm_epi64(__mmask8);
extern __m256i   __cdecl _mm256_movm_epi64(__mmask8);
extern __m128i   __cdecl _mm_movm_epi8(__mmask16);
extern __m256i   __cdecl _mm256_movm_epi8(__mmask32);
extern __m128i   __cdecl _mm_mask_mul_epi32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_mul_epi32(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_mul_epi32(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_mul_epi32(__mmask8, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_mul_epu32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_mul_epu32(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_mul_epu32(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_mul_epu32(__mmask8, __m256i, __m256i);
extern __m128d   __cdecl _mm_mask_mul_pd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_maskz_mul_pd(__mmask8, __m128d, __m128d);
extern __m256d   __cdecl _mm256_mask_mul_pd(__m256d, __mmask8, __m256d, __m256d);
extern __m256d   __cdecl _mm256_maskz_mul_pd(__mmask8, __m256d, __m256d);
extern __m128    __cdecl _mm_mask_mul_ps(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_maskz_mul_ps(__mmask8, __m128, __m128);
extern __m256    __cdecl _mm256_mask_mul_ps(__m256, __mmask8, __m256, __m256);
extern __m256    __cdecl _mm256_maskz_mul_ps(__mmask8, __m256, __m256);
extern __m128i   __cdecl _mm_mask_mulhi_epi16(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_mulhi_epi16(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_mulhi_epi16(__m256i, __mmask16, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_mulhi_epi16(__mmask16, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_mulhi_epu16(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_mulhi_epu16(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_mulhi_epu16(__m256i, __mmask16, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_mulhi_epu16(__mmask16, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_mulhrs_epi16(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_mulhrs_epi16(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_mulhrs_epi16(__m256i, __mmask16, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_mulhrs_epi16(__mmask16, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_mullo_epi16(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_mullo_epi16(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_mullo_epi16(__m256i, __mmask16, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_mullo_epi16(__mmask16, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_mullo_epi32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_mullo_epi32(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_mullo_epi32(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_mullo_epi32(__mmask8, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_mullo_epi64(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_mullo_epi64(__mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_mullo_epi64(__m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_mullo_epi64(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_mullo_epi64(__mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_mullo_epi64(__m256i, __m256i);
extern __m128i   __cdecl _mm_or_epi32(__m128i, __m128i);
extern __m128i   __cdecl _mm_mask_or_epi32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_or_epi32(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_or_epi32(__m256i, __m256i);
extern __m256i   __cdecl _mm256_mask_or_epi32(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_or_epi32(__mmask8, __m256i, __m256i);
extern __m128i   __cdecl _mm_or_epi64(__m128i, __m128i);
extern __m128i   __cdecl _mm_mask_or_epi64(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_or_epi64(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_or_epi64(__m256i, __m256i);
extern __m256i   __cdecl _mm256_mask_or_epi64(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_or_epi64(__mmask8, __m256i, __m256i);
extern __m128d   __cdecl _mm_mask_or_pd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_maskz_or_pd(__mmask8, __m128d, __m128d);
extern __m256d   __cdecl _mm256_mask_or_pd(__m256d, __mmask8, __m256d, __m256d);
extern __m256d   __cdecl _mm256_maskz_or_pd(__mmask8, __m256d, __m256d);
extern __m128    __cdecl _mm_mask_or_ps(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_maskz_or_ps(__mmask8, __m128, __m128);
extern __m256    __cdecl _mm256_mask_or_ps(__m256, __mmask8, __m256, __m256);
extern __m256    __cdecl _mm256_maskz_or_ps(__mmask8, __m256, __m256);
extern __m128i   __cdecl _mm_mask_packs_epi16(__m128i, __mmask16, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_packs_epi16(__mmask16, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_packs_epi16(__m256i, __mmask32, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_packs_epi16(__mmask32, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_packs_epi32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_packs_epi32(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_packs_epi32(__m256i, __mmask16, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_packs_epi32(__mmask16, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_packus_epi16(__m128i, __mmask16, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_packus_epi16(__mmask16, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_packus_epi16(__m256i, __mmask32, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_packus_epi16(__mmask32, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_packus_epi32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_packus_epi32(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_packus_epi32(__m256i, __mmask16, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_packus_epi32(__mmask16, __m256i, __m256i);
extern __m128d   __cdecl _mm_mask_permute_pd(__m128d, __mmask8, __m128d, const int);
extern __m128d   __cdecl _mm_maskz_permute_pd(__mmask8, __m128d, const int);
extern __m256d   __cdecl _mm256_mask_permute_pd(__m256d, __mmask8, __m256d, const int);
extern __m256d   __cdecl _mm256_maskz_permute_pd(__mmask8, __m256d, const int);
extern __m128    __cdecl _mm_mask_permute_ps(__m128, __mmask8, __m128, const int);
extern __m128    __cdecl _mm_maskz_permute_ps(__mmask8, __m128, const int);
extern __m256    __cdecl _mm256_mask_permute_ps(__m256, __mmask8, __m256, const int);
extern __m256    __cdecl _mm256_maskz_permute_ps(__mmask8, __m256, const int);
extern __m128d   __cdecl _mm_mask_permutevar_pd(__m128d, __mmask8, __m128d, __m128i);
extern __m128d   __cdecl _mm_maskz_permutevar_pd(__mmask8, __m128d, __m128i);
extern __m256d   __cdecl _mm256_mask_permutevar_pd(__m256d, __mmask8, __m256d, __m256i);
extern __m256d   __cdecl _mm256_maskz_permutevar_pd(__mmask8, __m256d, __m256i);
extern __m128    __cdecl _mm_mask_permutevar_ps(__m128, __mmask8, __m128, __m128i);
extern __m128    __cdecl _mm_maskz_permutevar_ps(__mmask8, __m128, __m128i);
extern __m256    __cdecl _mm256_mask_permutevar_ps(__m256, __mmask8, __m256, __m256i);
extern __m256    __cdecl _mm256_maskz_permutevar_ps(__mmask8, __m256, __m256i);
extern __m256i   __cdecl _mm256_mask_permutex_epi64(__m256i, __mmask8, __m256i, const int);
extern __m256i   __cdecl _mm256_maskz_permutex_epi64(__mmask8, __m256i, const int);
extern __m256i   __cdecl _mm256_permutex_epi64(__m256i, const int);
extern __m256d   __cdecl _mm256_mask_permutex_pd(__m256d, __mmask8, __m256d, const int);
extern __m256d   __cdecl _mm256_maskz_permutex_pd(__mmask8, __m256d, const int);
extern __m256d   __cdecl _mm256_permutex_pd(__m256d, const int);
extern __m128i   __cdecl _mm_mask_permutex2var_epi16(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_mask2_permutex2var_epi16(__m128i, __m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_permutex2var_epi16(__mmask8, __m128i, __m128i, __m128i);
extern __m128i   __cdecl _mm_permutex2var_epi16(__m128i, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_permutex2var_epi16(__m256i, __mmask16, __m256i, __m256i);
extern __m256i   __cdecl _mm256_mask2_permutex2var_epi16(__m256i, __m256i, __mmask16, __m256i);
extern __m256i   __cdecl _mm256_maskz_permutex2var_epi16(__mmask16, __m256i, __m256i, __m256i);
extern __m256i   __cdecl _mm256_permutex2var_epi16(__m256i, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_permutex2var_epi32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_mask2_permutex2var_epi32(__m128i, __m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_permutex2var_epi32(__mmask8, __m128i, __m128i, __m128i);
extern __m128i   __cdecl _mm_permutex2var_epi32(__m128i, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_permutex2var_epi32(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_mask2_permutex2var_epi32(__m256i, __m256i, __mmask8, __m256i);
extern __m256i   __cdecl _mm256_maskz_permutex2var_epi32(__mmask8, __m256i, __m256i, __m256i);
extern __m256i   __cdecl _mm256_permutex2var_epi32(__m256i, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_permutex2var_epi64(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_mask2_permutex2var_epi64(__m128i, __m128i, __mmask8, __m128i);
extern __m128i   __cdecl _mm_maskz_permutex2var_epi64(__mmask8, __m128i, __m128i, __m128i);
extern __m128i   __cdecl _mm_permutex2var_epi64(__m128i, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_permutex2var_epi64(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_mask2_permutex2var_epi64(__m256i, __m256i, __mmask8, __m256i);
extern __m256i   __cdecl _mm256_maskz_permutex2var_epi64(__mmask8, __m256i, __m256i, __m256i);
extern __m256i   __cdecl _mm256_permutex2var_epi64(__m256i, __m256i, __m256i);
extern __m128d   __cdecl _mm_mask_permutex2var_pd(__m128d, __mmask8, __m128i, __m128d);
extern __m128d   __cdecl _mm_mask2_permutex2var_pd(__m128d, __m128i, __mmask8, __m128d);
extern __m128d   __cdecl _mm_maskz_permutex2var_pd(__mmask8, __m128d, __m128i, __m128d);
extern __m128d   __cdecl _mm_permutex2var_pd(__m128d, __m128i, __m128d);
extern __m256d   __cdecl _mm256_mask_permutex2var_pd(__m256d, __mmask8, __m256i, __m256d);
extern __m256d   __cdecl _mm256_mask2_permutex2var_pd(__m256d, __m256i, __mmask8, __m256d);
extern __m256d   __cdecl _mm256_maskz_permutex2var_pd(__mmask8, __m256d, __m256i, __m256d);
extern __m256d   __cdecl _mm256_permutex2var_pd(__m256d, __m256i, __m256d);
extern __m128    __cdecl _mm_mask_permutex2var_ps(__m128, __mmask8, __m128i, __m128);
extern __m128    __cdecl _mm_mask2_permutex2var_ps(__m128, __m128i, __mmask8, __m128);
extern __m128    __cdecl _mm_maskz_permutex2var_ps(__mmask8, __m128, __m128i, __m128);
extern __m128    __cdecl _mm_permutex2var_ps(__m128, __m128i, __m128);
extern __m256    __cdecl _mm256_mask_permutex2var_ps(__m256, __mmask8, __m256i, __m256);
extern __m256    __cdecl _mm256_mask2_permutex2var_ps(__m256, __m256i, __mmask8, __m256);
extern __m256    __cdecl _mm256_maskz_permutex2var_ps(__mmask8, __m256, __m256i, __m256);
extern __m256    __cdecl _mm256_permutex2var_ps(__m256, __m256i, __m256);
extern __m128i   __cdecl _mm_mask_permutexvar_epi16(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_permutexvar_epi16(__mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_permutexvar_epi16(__m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_permutexvar_epi16(__m256i, __mmask16, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_permutexvar_epi16(__mmask16, __m256i, __m256i);
extern __m256i   __cdecl _mm256_permutexvar_epi16(__m256i, __m256i);
extern __m256i   __cdecl _mm256_mask_permutexvar_epi32(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_permutexvar_epi32(__mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_permutexvar_epi32(__m256i, __m256i);
extern __m256i   __cdecl _mm256_mask_permutexvar_epi64(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_permutexvar_epi64(__mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_permutexvar_epi64(__m256i, __m256i);
extern __m256d   __cdecl _mm256_mask_permutexvar_pd(__m256d, __mmask8, __m256i, __m256d);
extern __m256d   __cdecl _mm256_maskz_permutexvar_pd(__mmask8, __m256i, __m256d);
extern __m256d   __cdecl _mm256_permutexvar_pd(__m256i, __m256d);
extern __m256    __cdecl _mm256_mask_permutexvar_ps(__m256, __mmask8, __m256i, __m256);
extern __m256    __cdecl _mm256_maskz_permutexvar_ps(__mmask8, __m256i, __m256);
extern __m256    __cdecl _mm256_permutexvar_ps(__m256i, __m256);
extern __m128d   __cdecl _mm_mask_range_pd(__m128d, __mmask8, __m128d, __m128d, int);
extern __m128d   __cdecl _mm_maskz_range_pd(__mmask8, __m128d, __m128d, int);
extern __m128d   __cdecl _mm_range_pd(__m128d, __m128d, int);
extern __m256d   __cdecl _mm256_mask_range_pd(__m256d, __mmask8, __m256d, __m256d, int);
extern __m256d   __cdecl _mm256_maskz_range_pd(__mmask8, __m256d, __m256d, int);
extern __m256d   __cdecl _mm256_range_pd(__m256d, __m256d, int);
extern __m128    __cdecl _mm_mask_range_ps(__m128, __mmask8, __m128, __m128, int);
extern __m128    __cdecl _mm_maskz_range_ps(__mmask8, __m128, __m128, int);
extern __m128    __cdecl _mm_range_ps(__m128, __m128, int);
extern __m256    __cdecl _mm256_mask_range_ps(__m256, __mmask8, __m256, __m256, int);
extern __m256    __cdecl _mm256_maskz_range_ps(__mmask8, __m256, __m256, int);
extern __m256    __cdecl _mm256_range_ps(__m256, __m256, int);
extern __m128d   __cdecl _mm_mask_rcp14_pd(__m128d, __mmask8, __m128d);
extern __m128d   __cdecl _mm_maskz_rcp14_pd(__mmask8, __m128d);
extern __m128d   __cdecl _mm_rcp14_pd(__m128d);
extern __m256d   __cdecl _mm256_mask_rcp14_pd(__m256d, __mmask8, __m256d);
extern __m256d   __cdecl _mm256_maskz_rcp14_pd(__mmask8, __m256d);
extern __m256d   __cdecl _mm256_rcp14_pd(__m256d);
extern __m128    __cdecl _mm_mask_rcp14_ps(__m128, __mmask8, __m128);
extern __m128    __cdecl _mm_maskz_rcp14_ps(__mmask8, __m128);
extern __m128    __cdecl _mm_rcp14_ps(__m128);
extern __m256    __cdecl _mm256_mask_rcp14_ps(__m256, __mmask8, __m256);
extern __m256    __cdecl _mm256_maskz_rcp14_ps(__mmask8, __m256);
extern __m256    __cdecl _mm256_rcp14_ps(__m256);
extern __m128d   __cdecl _mm_mask_reduce_pd(__m128d, __mmask8, __m128d, int);
extern __m128d   __cdecl _mm_maskz_reduce_pd(__mmask8, __m128d, int);
extern __m128d   __cdecl _mm_reduce_pd(__m128d, int);
extern __m256d   __cdecl _mm256_mask_reduce_pd(__m256d, __mmask8, __m256d, int);
extern __m256d   __cdecl _mm256_maskz_reduce_pd(__mmask8, __m256d, int);
extern __m256d   __cdecl _mm256_reduce_pd(__m256d, int);
extern __m128    __cdecl _mm_mask_reduce_ps(__m128, __mmask8, __m128, int);
extern __m128    __cdecl _mm_maskz_reduce_ps(__mmask8, __m128, int);
extern __m128    __cdecl _mm_reduce_ps(__m128, int);
extern __m256    __cdecl _mm256_mask_reduce_ps(__m256, __mmask8, __m256, int);
extern __m256    __cdecl _mm256_maskz_reduce_ps(__mmask8, __m256, int);
extern __m256    __cdecl _mm256_reduce_ps(__m256, int);
extern __m128i   __cdecl _mm_mask_rol_epi32(__m128i, __mmask8, __m128i, const int);
extern __m128i   __cdecl _mm_maskz_rol_epi32(__mmask8, __m128i, const int);
extern __m128i   __cdecl _mm_rol_epi32(__m128i, int);
extern __m256i   __cdecl _mm256_mask_rol_epi32(__m256i, __mmask8, __m256i, const int);
extern __m256i   __cdecl _mm256_maskz_rol_epi32(__mmask8, __m256i, const int);
extern __m256i   __cdecl _mm256_rol_epi32(__m256i, const int);
extern __m128i   __cdecl _mm_mask_rol_epi64(__m128i, __mmask8, __m128i, const int);
extern __m128i   __cdecl _mm_maskz_rol_epi64(__mmask8, __m128i, const int);
extern __m128i   __cdecl _mm_rol_epi64(__m128i, const int);
extern __m256i   __cdecl _mm256_mask_rol_epi64(__m256i, __mmask8, __m256i, const int);
extern __m256i   __cdecl _mm256_maskz_rol_epi64(__mmask8, __m256i, const int);
extern __m256i   __cdecl _mm256_rol_epi64(__m256i, const int);
extern __m128i   __cdecl _mm_mask_rolv_epi32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_rolv_epi32(__mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_rolv_epi32(__m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_rolv_epi32(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_rolv_epi32(__mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_rolv_epi32(__m256i, __m256i);
extern __m128i   __cdecl _mm_mask_rolv_epi64(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_rolv_epi64(__mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_rolv_epi64(__m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_rolv_epi64(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_rolv_epi64(__mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_rolv_epi64(__m256i, __m256i);
extern __m128i   __cdecl _mm_mask_ror_epi32(__m128i, __mmask8, __m128i, const int);
extern __m128i   __cdecl _mm_maskz_ror_epi32(__mmask8, __m128i, const int);
extern __m128i   __cdecl _mm_ror_epi32(__m128i, const int);
extern __m256i   __cdecl _mm256_mask_ror_epi32(__m256i, __mmask8, __m256i, const int);
extern __m256i   __cdecl _mm256_maskz_ror_epi32(__mmask8, __m256i, const int);
extern __m256i   __cdecl _mm256_ror_epi32(__m256i, const int);
extern __m128i   __cdecl _mm_mask_ror_epi64(__m128i, __mmask8, __m128i, const int);
extern __m128i   __cdecl _mm_maskz_ror_epi64(__mmask8, __m128i, const int);
extern __m128i   __cdecl _mm_ror_epi64(__m128i, const int);
extern __m256i   __cdecl _mm256_mask_ror_epi64(__m256i, __mmask8, __m256i, const int);
extern __m256i   __cdecl _mm256_maskz_ror_epi64(__mmask8, __m256i, const int);
extern __m256i   __cdecl _mm256_ror_epi64(__m256i, const int);
extern __m128i   __cdecl _mm_mask_rorv_epi32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_rorv_epi32(__mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_rorv_epi32(__m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_rorv_epi32(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_rorv_epi32(__mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_rorv_epi32(__m256i, __m256i);
extern __m128i   __cdecl _mm_mask_rorv_epi64(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_rorv_epi64(__mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_rorv_epi64(__m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_rorv_epi64(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_rorv_epi64(__mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_rorv_epi64(__m256i, __m256i);
extern __m128d   __cdecl _mm_mask_roundscale_pd(__m128d, __mmask8, __m128d, int);
extern __m128d   __cdecl _mm_maskz_roundscale_pd(__mmask8, __m128d, int);
extern __m128d   __cdecl _mm_roundscale_pd(__m128d, int);
extern __m256d   __cdecl _mm256_mask_roundscale_pd(__m256d, __mmask8, __m256d, int);
extern __m256d   __cdecl _mm256_maskz_roundscale_pd(__mmask8, __m256d, int);
extern __m256d   __cdecl _mm256_roundscale_pd(__m256d, int);
extern __m128    __cdecl _mm_mask_roundscale_ps(__m128, __mmask8, __m128, int);
extern __m128    __cdecl _mm_maskz_roundscale_ps(__mmask8, __m128, int);
extern __m128    __cdecl _mm_roundscale_ps(__m128, int);
extern __m256    __cdecl _mm256_mask_roundscale_ps(__m256, __mmask8, __m256, int);
extern __m256    __cdecl _mm256_maskz_roundscale_ps(__mmask8, __m256, int);
extern __m256    __cdecl _mm256_roundscale_ps(__m256, int);
extern __m128d   __cdecl _mm_mask_rsqrt14_pd(__m128d, __mmask8, __m128d);
extern __m128d   __cdecl _mm_maskz_rsqrt14_pd(__mmask8, __m128d);
extern __m256d   __cdecl _mm256_mask_rsqrt14_pd(__m256d, __mmask8, __m256d);
extern __m256d   __cdecl _mm256_maskz_rsqrt14_pd(__mmask8, __m256d);
extern __m128    __cdecl _mm_mask_rsqrt14_ps(__m128, __mmask8, __m128);
extern __m128    __cdecl _mm_maskz_rsqrt14_ps(__mmask8, __m128);
extern __m256    __cdecl _mm256_mask_rsqrt14_ps(__m256, __mmask8, __m256);
extern __m256    __cdecl _mm256_maskz_rsqrt14_ps(__mmask8, __m256);
extern __m128d   __cdecl _mm_mask_scalef_pd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_maskz_scalef_pd(__mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_scalef_pd(__m128d, __m128d);
extern __m256d   __cdecl _mm256_mask_scalef_pd(__m256d, __mmask8, __m256d, __m256d);
extern __m256d   __cdecl _mm256_maskz_scalef_pd(__mmask8, __m256d, __m256d);
extern __m256d   __cdecl _mm256_scalef_pd(__m256d, __m256d);
extern __m128    __cdecl _mm_mask_scalef_ps(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_maskz_scalef_ps(__mmask8, __m128, __m128);
extern __m128    __cdecl _mm_scalef_ps(__m128, __m128);
extern __m256    __cdecl _mm256_mask_scalef_ps(__m256, __mmask8, __m256, __m256);
extern __m256    __cdecl _mm256_maskz_scalef_ps(__mmask8, __m256, __m256);
extern __m256    __cdecl _mm256_scalef_ps(__m256, __m256);
extern __m128i   __cdecl _mm_mask_set1_epi16(__m128i, __mmask8, short);
extern __m128i   __cdecl _mm_maskz_set1_epi16(__mmask8, short);
extern __m256i   __cdecl _mm256_mask_set1_epi16(__m256i, __mmask16, short);
extern __m256i   __cdecl _mm256_maskz_set1_epi16(__mmask16, short);
extern __m128i   __cdecl _mm_mask_set1_epi32(__m128i, __mmask8, int);
extern __m128i   __cdecl _mm_maskz_set1_epi32(__mmask8, int);
extern __m256i   __cdecl _mm256_mask_set1_epi32(__m256i, __mmask8, int);
extern __m256i   __cdecl _mm256_maskz_set1_epi32(__mmask8, int);
extern __m128i   __cdecl _mm_mask_set1_epi64(__m128i, __mmask8, __int64);
extern __m128i   __cdecl _mm_maskz_set1_epi64(__mmask8, __int64);
extern __m256i   __cdecl _mm256_mask_set1_epi64(__m256i, __mmask8, __int64);
extern __m256i   __cdecl _mm256_maskz_set1_epi64(__mmask8, __int64);
extern __m128i   __cdecl _mm_mask_set1_epi8(__m128i, __mmask16, char);
extern __m128i   __cdecl _mm_maskz_set1_epi8(__mmask16, char);
extern __m256i   __cdecl _mm256_mask_set1_epi8(__m256i, __mmask32, char);
extern __m256i   __cdecl _mm256_maskz_set1_epi8(__mmask32, char);
extern __m128i   __cdecl _mm_mask_shuffle_epi32(__m128i, __mmask8, __m128i, int);
extern __m128i   __cdecl _mm_maskz_shuffle_epi32(__mmask8, __m128i, int);
extern __m256i   __cdecl _mm256_mask_shuffle_epi32(__m256i, __mmask8, __m256i, int);
extern __m256i   __cdecl _mm256_maskz_shuffle_epi32(__mmask8, __m256i, int);
extern __m128i   __cdecl _mm_mask_shuffle_epi8(__m128i, __mmask16, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_shuffle_epi8(__mmask16, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_shuffle_epi8(__m256i, __mmask32, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_shuffle_epi8(__mmask32, __m256i, __m256i);
extern __m256    __cdecl _mm256_mask_shuffle_f32x4(__m256, __mmask8, __m256, __m256, const int);
extern __m256    __cdecl _mm256_maskz_shuffle_f32x4(__mmask8, __m256, __m256, const int);
extern __m256    __cdecl _mm256_shuffle_f32x4(__m256, __m256, const int);
extern __m256d   __cdecl _mm256_mask_shuffle_f64x2(__m256d, __mmask8, __m256d, __m256d, const int);
extern __m256d   __cdecl _mm256_maskz_shuffle_f64x2(__mmask8, __m256d, __m256d, const int);
extern __m256d   __cdecl _mm256_shuffle_f64x2(__m256d, __m256d, const int);
extern __m256i   __cdecl _mm256_mask_shuffle_i32x4(__m256i, __mmask8, __m256i, __m256i, const int);
extern __m256i   __cdecl _mm256_maskz_shuffle_i32x4(__mmask8, __m256i, __m256i, const int);
extern __m256i   __cdecl _mm256_shuffle_i32x4(__m256i, __m256i, const int);
extern __m256i   __cdecl _mm256_mask_shuffle_i64x2(__m256i, __mmask8, __m256i, __m256i, const int);
extern __m256i   __cdecl _mm256_maskz_shuffle_i64x2(__mmask8, __m256i, __m256i, const int);
extern __m256i   __cdecl _mm256_shuffle_i64x2(__m256i, __m256i, const int);
extern __m128d   __cdecl _mm_mask_shuffle_pd(__m128d, __mmask8, __m128d, __m128d, const int);
extern __m128d   __cdecl _mm_maskz_shuffle_pd(__mmask8, __m128d, __m128d, const int);
extern __m256d   __cdecl _mm256_mask_shuffle_pd(__m256d, __mmask8, __m256d, __m256d, const int);
extern __m256d   __cdecl _mm256_maskz_shuffle_pd(__mmask8, __m256d, __m256d, const int);
extern __m128    __cdecl _mm_mask_shuffle_ps(__m128, __mmask8, __m128, __m128, const int);
extern __m128    __cdecl _mm_maskz_shuffle_ps(__mmask8, __m128, __m128, const int);
extern __m256    __cdecl _mm256_mask_shuffle_ps(__m256, __mmask8, __m256, __m256, const int);
extern __m256    __cdecl _mm256_maskz_shuffle_ps(__mmask8, __m256, __m256, const int);
extern __m128i   __cdecl _mm_mask_shufflehi_epi16(__m128i, __mmask8, __m128i, int);
extern __m128i   __cdecl _mm_maskz_shufflehi_epi16(__mmask8, __m128i, int);
extern __m256i   __cdecl _mm256_mask_shufflehi_epi16(__m256i, __mmask16, __m256i, int);
extern __m256i   __cdecl _mm256_maskz_shufflehi_epi16(__mmask16, __m256i, int);
extern __m128i   __cdecl _mm_mask_shufflelo_epi16(__m128i, __mmask8, __m128i, int);
extern __m128i   __cdecl _mm_maskz_shufflelo_epi16(__mmask8, __m128i, int);
extern __m256i   __cdecl _mm256_mask_shufflelo_epi16(__m256i, __mmask16, __m256i, int);
extern __m256i   __cdecl _mm256_maskz_shufflelo_epi16(__mmask16, __m256i, int);
extern __m128i   __cdecl _mm_mask_sll_epi16(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_sll_epi16(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_sll_epi16(__m256i, __mmask16, __m256i, __m128i);
extern __m256i   __cdecl _mm256_maskz_sll_epi16(__mmask16, __m256i, __m128i);
extern __m128i   __cdecl _mm_mask_sll_epi32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_sll_epi32(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_sll_epi32(__m256i, __mmask8, __m256i, __m128i);
extern __m256i   __cdecl _mm256_maskz_sll_epi32(__mmask8, __m256i, __m128i);
extern __m128i   __cdecl _mm_mask_sll_epi64(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_sll_epi64(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_sll_epi64(__m256i, __mmask8, __m256i, __m128i);
extern __m256i   __cdecl _mm256_maskz_sll_epi64(__mmask8, __m256i, __m128i);
extern __m128i   __cdecl _mm_mask_slli_epi16(__m128i, __mmask8, __m128i, unsigned int);
extern __m128i   __cdecl _mm_maskz_slli_epi16(__mmask8, __m128i, unsigned int);
extern __m256i   __cdecl _mm256_mask_slli_epi16(__m256i, __mmask16, __m256i, unsigned int);
extern __m256i   __cdecl _mm256_maskz_slli_epi16(__mmask16, __m256i, unsigned int);
extern __m128i   __cdecl _mm_mask_slli_epi32(__m128i, __mmask8, __m128i, unsigned int);
extern __m128i   __cdecl _mm_maskz_slli_epi32(__mmask8, __m128i, unsigned int);
extern __m256i   __cdecl _mm256_mask_slli_epi32(__m256i, __mmask8, __m256i, unsigned int);
extern __m256i   __cdecl _mm256_maskz_slli_epi32(__mmask8, __m256i, unsigned int);
extern __m128i   __cdecl _mm_mask_slli_epi64(__m128i, __mmask8, __m128i, unsigned int);
extern __m128i   __cdecl _mm_maskz_slli_epi64(__mmask8, __m128i, unsigned int);
extern __m256i   __cdecl _mm256_mask_slli_epi64(__m256i, __mmask8, __m256i, unsigned int);
extern __m256i   __cdecl _mm256_maskz_slli_epi64(__mmask8, __m256i, unsigned int);
extern __m128i   __cdecl _mm_mask_sllv_epi16(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_sllv_epi16(__mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_sllv_epi16(__m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_sllv_epi16(__m256i, __mmask16, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_sllv_epi16(__mmask16, __m256i, __m256i);
extern __m256i   __cdecl _mm256_sllv_epi16(__m256i, __m256i);
extern __m128i   __cdecl _mm_mask_sllv_epi32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_sllv_epi32(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_sllv_epi32(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_sllv_epi32(__mmask8, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_sllv_epi64(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_sllv_epi64(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_sllv_epi64(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_sllv_epi64(__mmask8, __m256i, __m256i);
extern __m128d   __cdecl _mm_mask_sqrt_pd(__m128d, __mmask8, __m128d);
extern __m128d   __cdecl _mm_maskz_sqrt_pd(__mmask8, __m128d);
extern __m256d   __cdecl _mm256_mask_sqrt_pd(__m256d, __mmask8, __m256d);
extern __m256d   __cdecl _mm256_maskz_sqrt_pd(__mmask8, __m256d);
extern __m128    __cdecl _mm_mask_sqrt_ps(__m128, __mmask8, __m128);
extern __m128    __cdecl _mm_maskz_sqrt_ps(__mmask8, __m128);
extern __m256    __cdecl _mm256_mask_sqrt_ps(__m256, __mmask8, __m256);
extern __m256    __cdecl _mm256_maskz_sqrt_ps(__mmask8, __m256);
extern __m128i   __cdecl _mm_mask_sra_epi16(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_sra_epi16(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_sra_epi16(__m256i, __mmask16, __m256i, __m128i);
extern __m256i   __cdecl _mm256_maskz_sra_epi16(__mmask16, __m256i, __m128i);
extern __m128i   __cdecl _mm_mask_sra_epi32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_sra_epi32(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_sra_epi32(__m256i, __mmask8, __m256i, __m128i);
extern __m256i   __cdecl _mm256_maskz_sra_epi32(__mmask8, __m256i, __m128i);
extern __m128i   __cdecl _mm_mask_sra_epi64(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_sra_epi64(__mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_sra_epi64(__m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_sra_epi64(__m256i, __mmask8, __m256i, __m128i);
extern __m256i   __cdecl _mm256_maskz_sra_epi64(__mmask8, __m256i, __m128i);
extern __m256i   __cdecl _mm256_sra_epi64(__m256i, __m128i);
extern __m128i   __cdecl _mm_mask_srai_epi16(__m128i, __mmask8, __m128i, unsigned int);
extern __m128i   __cdecl _mm_maskz_srai_epi16(__mmask8, __m128i, unsigned int);
extern __m256i   __cdecl _mm256_mask_srai_epi16(__m256i, __mmask16, __m256i, unsigned int);
extern __m256i   __cdecl _mm256_maskz_srai_epi16(__mmask16, __m256i, unsigned int);
extern __m128i   __cdecl _mm_mask_srai_epi32(__m128i, __mmask8, __m128i, unsigned int);
extern __m128i   __cdecl _mm_maskz_srai_epi32(__mmask8, __m128i, unsigned int);
extern __m256i   __cdecl _mm256_mask_srai_epi32(__m256i, __mmask8, __m256i, unsigned int);
extern __m256i   __cdecl _mm256_maskz_srai_epi32(__mmask8, __m256i, unsigned int);
extern __m128i   __cdecl _mm_mask_srai_epi64(__m128i, __mmask8, __m128i, unsigned int);
extern __m128i   __cdecl _mm_maskz_srai_epi64(__mmask8, __m128i, unsigned int);
extern __m128i   __cdecl _mm_srai_epi64(__m128i, unsigned int);
extern __m256i   __cdecl _mm256_mask_srai_epi64(__m256i, __mmask8, __m256i, unsigned int);
extern __m256i   __cdecl _mm256_maskz_srai_epi64(__mmask8, __m256i, unsigned int);
extern __m256i   __cdecl _mm256_srai_epi64(__m256i, unsigned int);
extern __m128i   __cdecl _mm_mask_srav_epi16(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_srav_epi16(__mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_srav_epi16(__m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_srav_epi16(__m256i, __mmask16, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_srav_epi16(__mmask16, __m256i, __m256i);
extern __m256i   __cdecl _mm256_srav_epi16(__m256i, __m256i);
extern __m128i   __cdecl _mm_mask_srav_epi32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_srav_epi32(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_srav_epi32(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_srav_epi32(__mmask8, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_srav_epi64(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_srav_epi64(__mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_srav_epi64(__m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_srav_epi64(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_srav_epi64(__mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_srav_epi64(__m256i, __m256i);
extern __m128i   __cdecl _mm_mask_srl_epi16(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_srl_epi16(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_srl_epi16(__m256i, __mmask16, __m256i, __m128i);
extern __m256i   __cdecl _mm256_maskz_srl_epi16(__mmask16, __m256i, __m128i);
extern __m128i   __cdecl _mm_mask_srl_epi32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_srl_epi32(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_srl_epi32(__m256i, __mmask8, __m256i, __m128i);
extern __m256i   __cdecl _mm256_maskz_srl_epi32(__mmask8, __m256i, __m128i);
extern __m128i   __cdecl _mm_mask_srl_epi64(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_srl_epi64(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_srl_epi64(__m256i, __mmask8, __m256i, __m128i);
extern __m256i   __cdecl _mm256_maskz_srl_epi64(__mmask8, __m256i, __m128i);
extern __m128i   __cdecl _mm_mask_srli_epi16(__m128i, __mmask8, __m128i, int);
extern __m128i   __cdecl _mm_maskz_srli_epi16(__mmask8, __m128i, int);
extern __m256i   __cdecl _mm256_mask_srli_epi16(__m256i, __mmask16, __m256i, int);
extern __m256i   __cdecl _mm256_maskz_srli_epi16(__mmask16, __m256i, int);
extern __m128i   __cdecl _mm_mask_srli_epi32(__m128i, __mmask8, __m128i, unsigned int);
extern __m128i   __cdecl _mm_maskz_srli_epi32(__mmask8, __m128i, unsigned int);
extern __m256i   __cdecl _mm256_mask_srli_epi32(__m256i, __mmask8, __m256i, unsigned int);
extern __m256i   __cdecl _mm256_maskz_srli_epi32(__mmask8, __m256i, unsigned int);
extern __m128i   __cdecl _mm_mask_srli_epi64(__m128i, __mmask8, __m128i, unsigned int);
extern __m128i   __cdecl _mm_maskz_srli_epi64(__mmask8, __m128i, unsigned int);
extern __m256i   __cdecl _mm256_mask_srli_epi64(__m256i, __mmask8, __m256i, unsigned int);
extern __m256i   __cdecl _mm256_maskz_srli_epi64(__mmask8, __m256i, unsigned int);
extern __m128i   __cdecl _mm_mask_srlv_epi16(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_srlv_epi16(__mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_srlv_epi16(__m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_srlv_epi16(__m256i, __mmask16, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_srlv_epi16(__mmask16, __m256i, __m256i);
extern __m256i   __cdecl _mm256_srlv_epi16(__m256i, __m256i);
extern __m128i   __cdecl _mm_mask_srlv_epi32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_srlv_epi32(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_srlv_epi32(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_srlv_epi32(__mmask8, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_srlv_epi64(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_srlv_epi64(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_srlv_epi64(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_srlv_epi64(__mmask8, __m256i, __m256i);
extern void      __cdecl _mm_mask_store_epi32(void*, __mmask8, __m128i);
extern void      __cdecl _mm256_mask_store_epi32(void*, __mmask8, __m256i);
extern void      __cdecl _mm_mask_store_epi64(void*, __mmask8, __m128i);
extern void      __cdecl _mm256_mask_store_epi64(void*, __mmask8, __m256i);
extern void      __cdecl _mm_mask_store_pd(void*, __mmask8, __m128d);
extern void      __cdecl _mm256_mask_store_pd(void*, __mmask8, __m256d);
extern void      __cdecl _mm_mask_store_ps(void*, __mmask8, __m128);
extern void      __cdecl _mm256_mask_store_ps(void*, __mmask8, __m256);
extern void      __cdecl _mm_storeu_epi16(void*, __m128i);
extern void      __cdecl _mm256_storeu_epi16(void*, __m256i);
extern void      __cdecl _mm_mask_storeu_epi16(void*, __mmask8, __m128i);
extern void      __cdecl _mm256_mask_storeu_epi16(void*, __mmask16, __m256i);
extern void      __cdecl _mm_storeu_epi32(void*, __m128i);
extern void      __cdecl _mm256_storeu_epi32(void*, __m256i);
extern void      __cdecl _mm_mask_storeu_epi32(void*, __mmask8, __m128i);
extern void      __cdecl _mm256_mask_storeu_epi32(void*, __mmask8, __m256i);
extern void      __cdecl _mm_storeu_epi64(void*, __m128i);
extern void      __cdecl _mm256_storeu_epi64(void*, __m256i);
extern void      __cdecl _mm_mask_storeu_epi64(void*, __mmask8, __m128i);
extern void      __cdecl _mm256_mask_storeu_epi64(void*, __mmask8, __m256i);
extern void      __cdecl _mm_storeu_epi8(void*, __m128i);
extern void      __cdecl _mm256_storeu_epi8(void*, __m256i);
extern void      __cdecl _mm_mask_storeu_epi8(void*, __mmask16, __m128i);
extern void      __cdecl _mm256_mask_storeu_epi8(void*, __mmask32, __m256i);
extern void      __cdecl _mm_mask_storeu_pd(void*, __mmask8, __m128d);
extern void      __cdecl _mm256_mask_storeu_pd(void*, __mmask8, __m256d);
extern void      __cdecl _mm_mask_storeu_ps(void*, __mmask8, __m128);
extern void      __cdecl _mm256_mask_storeu_ps(void*, __mmask8, __m256);
extern __m128i   __cdecl _mm_mask_sub_epi16(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_sub_epi16(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_sub_epi16(__m256i, __mmask16, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_sub_epi16(__mmask16, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_sub_epi32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_sub_epi32(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_sub_epi32(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_sub_epi32(__mmask8, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_sub_epi64(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_sub_epi64(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_sub_epi64(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_sub_epi64(__mmask8, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_sub_epi8(__m128i, __mmask16, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_sub_epi8(__mmask16, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_sub_epi8(__m256i, __mmask32, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_sub_epi8(__mmask32, __m256i, __m256i);
extern __m128d   __cdecl _mm_mask_sub_pd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_maskz_sub_pd(__mmask8, __m128d, __m128d);
extern __m256d   __cdecl _mm256_mask_sub_pd(__m256d, __mmask8, __m256d, __m256d);
extern __m256d   __cdecl _mm256_maskz_sub_pd(__mmask8, __m256d, __m256d);
extern __m128    __cdecl _mm_mask_sub_ps(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_maskz_sub_ps(__mmask8, __m128, __m128);
extern __m256    __cdecl _mm256_mask_sub_ps(__m256, __mmask8, __m256, __m256);
extern __m256    __cdecl _mm256_maskz_sub_ps(__mmask8, __m256, __m256);
extern __m128i   __cdecl _mm_mask_subs_epi16(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_subs_epi16(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_subs_epi16(__m256i, __mmask16, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_subs_epi16(__mmask16, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_subs_epi8(__m128i, __mmask16, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_subs_epi8(__mmask16, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_subs_epi8(__m256i, __mmask32, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_subs_epi8(__mmask32, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_subs_epu16(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_subs_epu16(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_subs_epu16(__m256i, __mmask16, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_subs_epu16(__mmask16, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_subs_epu8(__m128i, __mmask16, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_subs_epu8(__mmask16, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_subs_epu8(__m256i, __mmask32, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_subs_epu8(__mmask32, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_ternarylogic_epi32(__m128i, __mmask8, __m128i, __m128i, int);
extern __m128i   __cdecl _mm_maskz_ternarylogic_epi32(__mmask8, __m128i, __m128i, __m128i, int);
extern __m128i   __cdecl _mm_ternarylogic_epi32(__m128i, __m128i, __m128i, int);
extern __m256i   __cdecl _mm256_mask_ternarylogic_epi32(__m256i, __mmask8, __m256i, __m256i, int);
extern __m256i   __cdecl _mm256_maskz_ternarylogic_epi32(__mmask8, __m256i, __m256i, __m256i, int);
extern __m256i   __cdecl _mm256_ternarylogic_epi32(__m256i, __m256i, __m256i, int);
extern __m128i   __cdecl _mm_mask_ternarylogic_epi64(__m128i, __mmask8, __m128i, __m128i, int);
extern __m128i   __cdecl _mm_maskz_ternarylogic_epi64(__mmask8, __m128i, __m128i, __m128i, int);
extern __m128i   __cdecl _mm_ternarylogic_epi64(__m128i, __m128i, __m128i, int);
extern __m256i   __cdecl _mm256_mask_ternarylogic_epi64(__m256i, __mmask8, __m256i, __m256i, int);
extern __m256i   __cdecl _mm256_maskz_ternarylogic_epi64(__mmask8, __m256i, __m256i, __m256i, int);
extern __m256i   __cdecl _mm256_ternarylogic_epi64(__m256i, __m256i, __m256i, int);
extern __mmask8  __cdecl _mm_mask_test_epi16_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_test_epi16_mask(__m128i, __m128i);
extern __mmask16 __cdecl _mm256_mask_test_epi16_mask(__mmask16, __m256i, __m256i);
extern __mmask16 __cdecl _mm256_test_epi16_mask(__m256i, __m256i);
extern __mmask8  __cdecl _mm_mask_test_epi32_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_test_epi32_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm256_mask_test_epi32_mask(__mmask8, __m256i, __m256i);
extern __mmask8  __cdecl _mm256_test_epi32_mask(__m256i, __m256i);
extern __mmask8  __cdecl _mm_mask_test_epi64_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_test_epi64_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm256_mask_test_epi64_mask(__mmask8, __m256i, __m256i);
extern __mmask8  __cdecl _mm256_test_epi64_mask(__m256i, __m256i);
extern __mmask16 __cdecl _mm_mask_test_epi8_mask(__mmask16, __m128i, __m128i);
extern __mmask16 __cdecl _mm_test_epi8_mask(__m128i, __m128i);
extern __mmask32 __cdecl _mm256_mask_test_epi8_mask(__mmask32, __m256i, __m256i);
extern __mmask32 __cdecl _mm256_test_epi8_mask(__m256i, __m256i);
extern __mmask8  __cdecl _mm_mask_testn_epi16_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_testn_epi16_mask(__m128i, __m128i);
extern __mmask16 __cdecl _mm256_mask_testn_epi16_mask(__mmask16, __m256i, __m256i);
extern __mmask16 __cdecl _mm256_testn_epi16_mask(__m256i, __m256i);
extern __mmask8  __cdecl _mm_mask_testn_epi32_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_testn_epi32_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm256_mask_testn_epi32_mask(__mmask8, __m256i, __m256i);
extern __mmask8  __cdecl _mm256_testn_epi32_mask(__m256i, __m256i);
extern __mmask8  __cdecl _mm_mask_testn_epi64_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_testn_epi64_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm256_mask_testn_epi64_mask(__mmask8, __m256i, __m256i);
extern __mmask8  __cdecl _mm256_testn_epi64_mask(__m256i, __m256i);
extern __mmask16 __cdecl _mm_mask_testn_epi8_mask(__mmask16, __m128i, __m128i);
extern __mmask16 __cdecl _mm_testn_epi8_mask(__m128i, __m128i);
extern __mmask32 __cdecl _mm256_mask_testn_epi8_mask(__mmask32, __m256i, __m256i);
extern __mmask32 __cdecl _mm256_testn_epi8_mask(__m256i, __m256i);
extern __m128i   __cdecl _mm_mask_unpackhi_epi16(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_unpackhi_epi16(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_unpackhi_epi16(__m256i, __mmask16, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_unpackhi_epi16(__mmask16, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_unpackhi_epi32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_unpackhi_epi32(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_unpackhi_epi32(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_unpackhi_epi32(__mmask8, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_unpackhi_epi64(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_unpackhi_epi64(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_unpackhi_epi64(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_unpackhi_epi64(__mmask8, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_unpackhi_epi8(__m128i, __mmask16, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_unpackhi_epi8(__mmask16, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_unpackhi_epi8(__m256i, __mmask32, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_unpackhi_epi8(__mmask32, __m256i, __m256i);
extern __m128d   __cdecl _mm_mask_unpackhi_pd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_maskz_unpackhi_pd(__mmask8, __m128d, __m128d);
extern __m256d   __cdecl _mm256_mask_unpackhi_pd(__m256d, __mmask8, __m256d, __m256d);
extern __m256d   __cdecl _mm256_maskz_unpackhi_pd(__mmask8, __m256d, __m256d);
extern __m128    __cdecl _mm_mask_unpackhi_ps(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_maskz_unpackhi_ps(__mmask8, __m128, __m128);
extern __m256    __cdecl _mm256_mask_unpackhi_ps(__m256, __mmask8, __m256, __m256);
extern __m256    __cdecl _mm256_maskz_unpackhi_ps(__mmask8, __m256, __m256);
extern __m128i   __cdecl _mm_mask_unpacklo_epi16(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_unpacklo_epi16(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_unpacklo_epi16(__m256i, __mmask16, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_unpacklo_epi16(__mmask16, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_unpacklo_epi32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_unpacklo_epi32(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_unpacklo_epi32(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_unpacklo_epi32(__mmask8, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_unpacklo_epi64(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_unpacklo_epi64(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_unpacklo_epi64(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_unpacklo_epi64(__mmask8, __m256i, __m256i);
extern __m128i   __cdecl _mm_mask_unpacklo_epi8(__m128i, __mmask16, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_unpacklo_epi8(__mmask16, __m128i, __m128i);
extern __m256i   __cdecl _mm256_mask_unpacklo_epi8(__m256i, __mmask32, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_unpacklo_epi8(__mmask32, __m256i, __m256i);
extern __m128d   __cdecl _mm_mask_unpacklo_pd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_maskz_unpacklo_pd(__mmask8, __m128d, __m128d);
extern __m256d   __cdecl _mm256_mask_unpacklo_pd(__m256d, __mmask8, __m256d, __m256d);
extern __m256d   __cdecl _mm256_maskz_unpacklo_pd(__mmask8, __m256d, __m256d);
extern __m128    __cdecl _mm_mask_unpacklo_ps(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_maskz_unpacklo_ps(__mmask8, __m128, __m128);
extern __m256    __cdecl _mm256_mask_unpacklo_ps(__m256, __mmask8, __m256, __m256);
extern __m256    __cdecl _mm256_maskz_unpacklo_ps(__mmask8, __m256, __m256);
extern __m128i   __cdecl _mm_xor_epi32(__m128i, __m128i);
extern __m128i   __cdecl _mm_mask_xor_epi32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_xor_epi32(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_xor_epi32(__m256i, __m256i);
extern __m256i   __cdecl _mm256_mask_xor_epi32(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_xor_epi32(__mmask8, __m256i, __m256i);
extern __m128i   __cdecl _mm_xor_epi64(__m128i, __m128i);
extern __m128i   __cdecl _mm_mask_xor_epi64(__m128i, __mmask8, __m128i, __m128i);
extern __m128i   __cdecl _mm_maskz_xor_epi64(__mmask8, __m128i, __m128i);
extern __m256i   __cdecl _mm256_xor_epi64(__m256i, __m256i);
extern __m256i   __cdecl _mm256_mask_xor_epi64(__m256i, __mmask8, __m256i, __m256i);
extern __m256i   __cdecl _mm256_maskz_xor_epi64(__mmask8, __m256i, __m256i);
extern __m128d   __cdecl _mm_mask_xor_pd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_maskz_xor_pd(__mmask8, __m128d, __m128d);
extern __m256d   __cdecl _mm256_mask_xor_pd(__m256d, __mmask8, __m256d, __m256d);
extern __m256d   __cdecl _mm256_maskz_xor_pd(__mmask8, __m256d, __m256d);
extern __m128    __cdecl _mm_mask_xor_ps(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_maskz_xor_ps(__mmask8, __m128, __m128);
extern __m256    __cdecl _mm256_mask_xor_ps(__m256, __mmask8, __m256, __m256);
extern __m256    __cdecl _mm256_maskz_xor_ps(__mmask8, __m256, __m256);

extern __mmask16  __cdecl _mm_cmpeq_epi8_mask(__m128i, __m128i);
extern __mmask16  __cdecl _mm_cmpge_epi8_mask(__m128i, __m128i);
extern __mmask16  __cdecl _mm_cmpgt_epi8_mask(__m128i, __m128i);
extern __mmask16  __cdecl _mm_cmple_epi8_mask(__m128i, __m128i);
extern __mmask16  __cdecl _mm_cmplt_epi8_mask(__m128i, __m128i);
extern __mmask16  __cdecl _mm_cmpneq_epi8_mask(__m128i, __m128i);
extern __mmask16  __cdecl _mm_cmpeq_epu8_mask(__m128i, __m128i);
extern __mmask16  __cdecl _mm_cmpge_epu8_mask(__m128i, __m128i);
extern __mmask16  __cdecl _mm_cmpgt_epu8_mask(__m128i, __m128i);
extern __mmask16  __cdecl _mm_cmple_epu8_mask(__m128i, __m128i);
extern __mmask16  __cdecl _mm_cmplt_epu8_mask(__m128i, __m128i);
extern __mmask16  __cdecl _mm_cmpneq_epu8_mask(__m128i, __m128i);

extern __mmask16  __cdecl _mm_mask_cmpeq_epi8_mask(__mmask16, __m128i, __m128i);
extern __mmask16  __cdecl _mm_mask_cmpge_epi8_mask(__mmask16, __m128i, __m128i);
extern __mmask16  __cdecl _mm_mask_cmpgt_epi8_mask(__mmask16, __m128i, __m128i);
extern __mmask16  __cdecl _mm_mask_cmple_epi8_mask(__mmask16, __m128i, __m128i);
extern __mmask16  __cdecl _mm_mask_cmplt_epi8_mask(__mmask16, __m128i, __m128i);
extern __mmask16  __cdecl _mm_mask_cmpneq_epi8_mask(__mmask16, __m128i, __m128i);
extern __mmask16  __cdecl _mm_mask_cmpeq_epu8_mask(__mmask16, __m128i, __m128i);
extern __mmask16  __cdecl _mm_mask_cmpge_epu8_mask(__mmask16, __m128i, __m128i);
extern __mmask16  __cdecl _mm_mask_cmpgt_epu8_mask(__mmask16, __m128i, __m128i);
extern __mmask16  __cdecl _mm_mask_cmple_epu8_mask(__mmask16, __m128i, __m128i);
extern __mmask16  __cdecl _mm_mask_cmplt_epu8_mask(__mmask16, __m128i, __m128i);
extern __mmask16  __cdecl _mm_mask_cmpneq_epu8_mask(__mmask16, __m128i, __m128i);

extern __mmask8  __cdecl _mm_cmpeq_epi16_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmpge_epi16_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmpgt_epi16_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmple_epi16_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmplt_epi16_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmpneq_epi16_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmpeq_epu16_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmpge_epu16_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmpgt_epu16_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmple_epu16_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmplt_epu16_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmpneq_epu16_mask(__m128i, __m128i);

extern __mmask8  __cdecl _mm_mask_cmpeq_epi16_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmpge_epi16_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmpgt_epi16_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmple_epi16_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmplt_epi16_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmpneq_epi16_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmpeq_epu16_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmpge_epu16_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmpgt_epu16_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmple_epu16_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmplt_epu16_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmpneq_epu16_mask(__mmask8, __m128i, __m128i);

extern __mmask8  __cdecl _mm_cmpeq_epi32_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmpge_epi32_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmpgt_epi32_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmple_epi32_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmplt_epi32_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmpneq_epi32_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmpeq_epu32_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmpge_epu32_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmpgt_epu32_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmple_epu32_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmplt_epu32_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmpneq_epu32_mask(__m128i, __m128i);

extern __mmask8  __cdecl _mm_mask_cmpeq_epi32_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmpge_epi32_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmpgt_epi32_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmple_epi32_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmplt_epi32_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmpneq_epi32_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmpeq_epu32_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmpge_epu32_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmpgt_epu32_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmple_epu32_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmplt_epu32_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmpneq_epu32_mask(__mmask8, __m128i, __m128i);

extern __mmask8  __cdecl _mm_cmpeq_epi64_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmpge_epi64_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmpgt_epi64_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmple_epi64_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmplt_epi64_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmpneq_epi64_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmpeq_epu64_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmpge_epu64_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmpgt_epu64_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmple_epu64_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmplt_epu64_mask(__m128i, __m128i);
extern __mmask8  __cdecl _mm_cmpneq_epu64_mask(__m128i, __m128i);

extern __mmask8  __cdecl _mm_mask_cmpeq_epi64_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmpge_epi64_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmpgt_epi64_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmple_epi64_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmplt_epi64_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmpneq_epi64_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmpeq_epu64_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmpge_epu64_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmpgt_epu64_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmple_epu64_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmplt_epu64_mask(__mmask8, __m128i, __m128i);
extern __mmask8  __cdecl _mm_mask_cmpneq_epu64_mask(__mmask8, __m128i, __m128i);

extern __mmask32  __cdecl _mm256_cmpeq_epi8_mask(__m256i, __m256i);
extern __mmask32  __cdecl _mm256_cmpge_epi8_mask(__m256i, __m256i);
extern __mmask32  __cdecl _mm256_cmpgt_epi8_mask(__m256i, __m256i);
extern __mmask32  __cdecl _mm256_cmple_epi8_mask(__m256i, __m256i);
extern __mmask32  __cdecl _mm256_cmplt_epi8_mask(__m256i, __m256i);
extern __mmask32  __cdecl _mm256_cmpneq_epi8_mask(__m256i, __m256i);
extern __mmask32  __cdecl _mm256_cmpeq_epu8_mask(__m256i, __m256i);
extern __mmask32  __cdecl _mm256_cmpge_epu8_mask(__m256i, __m256i);
extern __mmask32  __cdecl _mm256_cmpgt_epu8_mask(__m256i, __m256i);
extern __mmask32  __cdecl _mm256_cmple_epu8_mask(__m256i, __m256i);
extern __mmask32  __cdecl _mm256_cmplt_epu8_mask(__m256i, __m256i);
extern __mmask32  __cdecl _mm256_cmpneq_epu8_mask(__m256i, __m256i);

extern __mmask32  __cdecl _mm256_mask_cmpeq_epi8_mask(__mmask32, __m256i, __m256i);
extern __mmask32  __cdecl _mm256_mask_cmpge_epi8_mask(__mmask32, __m256i, __m256i);
extern __mmask32  __cdecl _mm256_mask_cmpgt_epi8_mask(__mmask32, __m256i, __m256i);
extern __mmask32  __cdecl _mm256_mask_cmple_epi8_mask(__mmask32, __m256i, __m256i);
extern __mmask32  __cdecl _mm256_mask_cmplt_epi8_mask(__mmask32, __m256i, __m256i);
extern __mmask32  __cdecl _mm256_mask_cmpneq_epi8_mask(__mmask32, __m256i, __m256i);
extern __mmask32  __cdecl _mm256_mask_cmpeq_epu8_mask(__mmask32, __m256i, __m256i);
extern __mmask32  __cdecl _mm256_mask_cmpge_epu8_mask(__mmask32, __m256i, __m256i);
extern __mmask32  __cdecl _mm256_mask_cmpgt_epu8_mask(__mmask32, __m256i, __m256i);
extern __mmask32  __cdecl _mm256_mask_cmple_epu8_mask(__mmask32, __m256i, __m256i);
extern __mmask32  __cdecl _mm256_mask_cmplt_epu8_mask(__mmask32, __m256i, __m256i);
extern __mmask32  __cdecl _mm256_mask_cmpneq_epu8_mask(__mmask32, __m256i, __m256i);

extern __mmask16  __cdecl _mm256_cmpeq_epi16_mask(__m256i, __m256i);
extern __mmask16  __cdecl _mm256_cmpge_epi16_mask(__m256i, __m256i);
extern __mmask16  __cdecl _mm256_cmpgt_epi16_mask(__m256i, __m256i);
extern __mmask16  __cdecl _mm256_cmple_epi16_mask(__m256i, __m256i);
extern __mmask16  __cdecl _mm256_cmplt_epi16_mask(__m256i, __m256i);
extern __mmask16  __cdecl _mm256_cmpneq_epi16_mask(__m256i, __m256i);
extern __mmask16  __cdecl _mm256_cmpeq_epu16_mask(__m256i, __m256i);
extern __mmask16  __cdecl _mm256_cmpge_epu16_mask(__m256i, __m256i);
extern __mmask16  __cdecl _mm256_cmpgt_epu16_mask(__m256i, __m256i);
extern __mmask16  __cdecl _mm256_cmple_epu16_mask(__m256i, __m256i);
extern __mmask16  __cdecl _mm256_cmplt_epu16_mask(__m256i, __m256i);
extern __mmask16  __cdecl _mm256_cmpneq_epu16_mask(__m256i, __m256i);

extern __mmask16  __cdecl _mm256_mask_cmpeq_epi16_mask(__mmask16, __m256i, __m256i);
extern __mmask16  __cdecl _mm256_mask_cmpge_epi16_mask(__mmask16, __m256i, __m256i);
extern __mmask16  __cdecl _mm256_mask_cmpgt_epi16_mask(__mmask16, __m256i, __m256i);
extern __mmask16  __cdecl _mm256_mask_cmple_epi16_mask(__mmask16, __m256i, __m256i);
extern __mmask16  __cdecl _mm256_mask_cmplt_epi16_mask(__mmask16, __m256i, __m256i);
extern __mmask16  __cdecl _mm256_mask_cmpneq_epi16_mask(__mmask16, __m256i, __m256i);
extern __mmask16  __cdecl _mm256_mask_cmpeq_epu16_mask(__mmask16, __m256i, __m256i);
extern __mmask16  __cdecl _mm256_mask_cmpge_epu16_mask(__mmask16, __m256i, __m256i);
extern __mmask16  __cdecl _mm256_mask_cmpgt_epu16_mask(__mmask16, __m256i, __m256i);
extern __mmask16  __cdecl _mm256_mask_cmple_epu16_mask(__mmask16, __m256i, __m256i);
extern __mmask16  __cdecl _mm256_mask_cmplt_epu16_mask(__mmask16, __m256i, __m256i);
extern __mmask16  __cdecl _mm256_mask_cmpneq_epu16_mask(__mmask16, __m256i, __m256i);

extern __mmask8  __cdecl _mm256_cmpeq_epi32_mask(__m256i, __m256i);
extern __mmask8  __cdecl _mm256_cmpge_epi32_mask(__m256i, __m256i);
extern __mmask8  __cdecl _mm256_cmpgt_epi32_mask(__m256i, __m256i);
extern __mmask8  __cdecl _mm256_cmple_epi32_mask(__m256i, __m256i);
extern __mmask8  __cdecl _mm256_cmplt_epi32_mask(__m256i, __m256i);
extern __mmask8  __cdecl _mm256_cmpneq_epi32_mask(__m256i, __m256i);
extern __mmask8  __cdecl _mm256_cmpeq_epu32_mask(__m256i, __m256i);
extern __mmask8  __cdecl _mm256_cmpge_epu32_mask(__m256i, __m256i);
extern __mmask8  __cdecl _mm256_cmpgt_epu32_mask(__m256i, __m256i);
extern __mmask8  __cdecl _mm256_cmple_epu32_mask(__m256i, __m256i);
extern __mmask8  __cdecl _mm256_cmplt_epu32_mask(__m256i, __m256i);
extern __mmask8  __cdecl _mm256_cmpneq_epu32_mask(__m256i, __m256i);

extern __mmask8  __cdecl _mm256_mask_cmpeq_epi32_mask(__mmask8, __m256i, __m256i);
extern __mmask8  __cdecl _mm256_mask_cmpge_epi32_mask(__mmask8, __m256i, __m256i);
extern __mmask8  __cdecl _mm256_mask_cmpgt_epi32_mask(__mmask8, __m256i, __m256i);
extern __mmask8  __cdecl _mm256_mask_cmple_epi32_mask(__mmask8, __m256i, __m256i);
extern __mmask8  __cdecl _mm256_mask_cmplt_epi32_mask(__mmask8, __m256i, __m256i);
extern __mmask8  __cdecl _mm256_mask_cmpneq_epi32_mask(__mmask8, __m256i, __m256i);
extern __mmask8  __cdecl _mm256_mask_cmpeq_epu32_mask(__mmask8, __m256i, __m256i);
extern __mmask8  __cdecl _mm256_mask_cmpge_epu32_mask(__mmask8, __m256i, __m256i);
extern __mmask8  __cdecl _mm256_mask_cmpgt_epu32_mask(__mmask8, __m256i, __m256i);
extern __mmask8  __cdecl _mm256_mask_cmple_epu32_mask(__mmask8, __m256i, __m256i);
extern __mmask8  __cdecl _mm256_mask_cmplt_epu32_mask(__mmask8, __m256i, __m256i);
extern __mmask8  __cdecl _mm256_mask_cmpneq_epu32_mask(__mmask8, __m256i, __m256i);

extern __mmask8  __cdecl _mm256_cmpeq_epi64_mask(__m256i, __m256i);
extern __mmask8  __cdecl _mm256_cmpge_epi64_mask(__m256i, __m256i);
extern __mmask8  __cdecl _mm256_cmpgt_epi64_mask(__m256i, __m256i);
extern __mmask8  __cdecl _mm256_cmple_epi64_mask(__m256i, __m256i);
extern __mmask8  __cdecl _mm256_cmplt_epi64_mask(__m256i, __m256i);
extern __mmask8  __cdecl _mm256_cmpneq_epi64_mask(__m256i, __m256i);
extern __mmask8  __cdecl _mm256_cmpeq_epu64_mask(__m256i, __m256i);
extern __mmask8  __cdecl _mm256_cmpge_epu64_mask(__m256i, __m256i);
extern __mmask8  __cdecl _mm256_cmpgt_epu64_mask(__m256i, __m256i);
extern __mmask8  __cdecl _mm256_cmple_epu64_mask(__m256i, __m256i);
extern __mmask8  __cdecl _mm256_cmplt_epu64_mask(__m256i, __m256i);
extern __mmask8  __cdecl _mm256_cmpneq_epu64_mask(__m256i, __m256i);

extern __mmask8  __cdecl _mm256_mask_cmpeq_epi64_mask(__mmask8, __m256i, __m256i);
extern __mmask8  __cdecl _mm256_mask_cmpge_epi64_mask(__mmask8, __m256i, __m256i);
extern __mmask8  __cdecl _mm256_mask_cmpgt_epi64_mask(__mmask8, __m256i, __m256i);
extern __mmask8  __cdecl _mm256_mask_cmple_epi64_mask(__mmask8, __m256i, __m256i);
extern __mmask8  __cdecl _mm256_mask_cmplt_epi64_mask(__mmask8, __m256i, __m256i);
extern __mmask8  __cdecl _mm256_mask_cmpneq_epi64_mask(__mmask8, __m256i, __m256i);
extern __mmask8  __cdecl _mm256_mask_cmpeq_epu64_mask(__mmask8, __m256i, __m256i);
extern __mmask8  __cdecl _mm256_mask_cmpge_epu64_mask(__mmask8, __m256i, __m256i);
extern __mmask8  __cdecl _mm256_mask_cmpgt_epu64_mask(__mmask8, __m256i, __m256i);
extern __mmask8  __cdecl _mm256_mask_cmple_epu64_mask(__mmask8, __m256i, __m256i);
extern __mmask8  __cdecl _mm256_mask_cmplt_epu64_mask(__mmask8, __m256i, __m256i);
extern __mmask8  __cdecl _mm256_mask_cmpneq_epu64_mask(__mmask8, __m256i, __m256i);


extern __m128d   __cdecl _mm_add_round_sd(__m128d, __m128d, int);
extern __m128d   __cdecl _mm_mask_add_round_sd(__m128d, __mmask8, __m128d, __m128d, int);
extern __m128d   __cdecl _mm_maskz_add_round_sd(__mmask8, __m128d, __m128d, int);
extern __m128    __cdecl _mm_add_round_ss(__m128, __m128, int);
extern __m128    __cdecl _mm_mask_add_round_ss(__m128, __mmask8, __m128, __m128, int);
extern __m128    __cdecl _mm_maskz_add_round_ss(__mmask8, __m128, __m128, int);
extern __m128d   __cdecl _mm_mask_add_sd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_maskz_add_sd(__mmask8, __m128d, __m128d);
extern __m128    __cdecl _mm_mask_add_ss(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_maskz_add_ss(__mmask8, __m128, __m128);
extern __mmask8  __cdecl _mm_cmp_round_sd_mask(__m128d, __m128d, const int, const int);
extern __mmask8  __cdecl _mm_mask_cmp_round_sd_mask(__mmask8, __m128d, __m128d, const int, const int);
extern __mmask8  __cdecl _mm_cmp_round_ss_mask(__m128, __m128, const int, const int);
extern __mmask8  __cdecl _mm_mask_cmp_round_ss_mask(__mmask8, __m128, __m128, const int, const int);
extern __mmask8  __cdecl _mm_cmp_sd_mask(__m128d, __m128d, const int);
extern __mmask8  __cdecl _mm_mask_cmp_sd_mask(__mmask8, __m128d, __m128d, const int);
extern __mmask8  __cdecl _mm_cmp_ss_mask(__m128, __m128, const int);
extern __mmask8  __cdecl _mm_mask_cmp_ss_mask(__mmask8, __m128, __m128, const int);
extern int       __cdecl _mm_comi_round_sd(__m128d, __m128d, const int, const int);
extern int       __cdecl _mm_comi_round_ss(__m128, __m128, const int, const int);
extern __m128    __cdecl _mm_cvt_roundi32_ss(__m128, int, int);
extern int       __cdecl _mm_cvt_roundsd_i32(__m128d, int);
extern int       __cdecl _mm_cvt_roundsd_si32(__m128d, int);
extern __m128    __cdecl _mm_cvt_roundsd_ss(__m128, __m128d, int);
extern __m128    __cdecl _mm_mask_cvt_roundsd_ss(__m128, __mmask8, __m128, __m128d, int);
extern __m128    __cdecl _mm_maskz_cvt_roundsd_ss(__mmask8, __m128, __m128d, int);
extern unsigned int __cdecl _mm_cvt_roundsd_u32(__m128d, int);
extern __m128    __cdecl _mm_cvt_roundsi32_ss(__m128, int, int);
extern int       __cdecl _mm_cvt_roundss_i32(__m128, int);
extern __m128d   __cdecl _mm_cvt_roundss_sd(__m128d, __m128, int);
extern __m128d   __cdecl _mm_mask_cvt_roundss_sd(__m128d, __mmask8, __m128d, __m128, int);
extern __m128d   __cdecl _mm_maskz_cvt_roundss_sd(__mmask8, __m128d, __m128, int);
extern int       __cdecl _mm_cvt_roundss_si32(__m128, int);
extern unsigned int __cdecl _mm_cvt_roundss_u32(__m128, int);
extern __m128    __cdecl _mm_cvt_roundu32_ss(__m128, unsigned int, int);
extern __m128d   __cdecl _mm_cvti32_sd(__m128d, int);
extern __m128    __cdecl _mm_cvti32_ss(__m128, int);
extern int       __cdecl _mm_cvtsd_i32(__m128d);
extern __m128    __cdecl _mm_mask_cvtsd_ss(__m128, __mmask8, __m128, __m128d);
extern __m128    __cdecl _mm_maskz_cvtsd_ss(__mmask8, __m128, __m128d);
extern unsigned int __cdecl _mm_cvtsd_u32(__m128d);
extern int       __cdecl _mm_cvtss_i32(__m128);
extern __m128d   __cdecl _mm_mask_cvtss_sd(__m128d, __mmask8, __m128d, __m128);
extern __m128d   __cdecl _mm_maskz_cvtss_sd(__mmask8, __m128d, __m128);
extern unsigned int __cdecl _mm_cvtss_u32(__m128);
extern int       __cdecl _mm_cvtt_roundsd_i32(__m128d, int);
extern int       __cdecl _mm_cvtt_roundsd_si32(__m128d, int);
extern unsigned int __cdecl _mm_cvtt_roundsd_u32(__m128d, int);
extern int       __cdecl _mm_cvtt_roundss_i32(__m128, int);
extern int       __cdecl _mm_cvtt_roundss_si32(__m128, int);
extern unsigned int __cdecl _mm_cvtt_roundss_u32(__m128, int);
extern int       __cdecl _mm_cvttsd_i32(__m128d);
extern unsigned int __cdecl _mm_cvttsd_u32(__m128d);
extern int       __cdecl _mm_cvttss_i32(__m128);
extern unsigned int __cdecl _mm_cvttss_u32(__m128);
extern __m128d   __cdecl _mm_cvtu32_sd(__m128d, unsigned int);
extern __m128    __cdecl _mm_cvtu32_ss(__m128, unsigned int);
extern __m128d   __cdecl _mm_div_round_sd(__m128d, __m128d, int);
extern __m128d   __cdecl _mm_mask_div_round_sd(__m128d, __mmask8, __m128d, __m128d, int);
extern __m128d   __cdecl _mm_maskz_div_round_sd(__mmask8, __m128d, __m128d, int);
extern __m128    __cdecl _mm_div_round_ss(__m128, __m128, int);
extern __m128    __cdecl _mm_mask_div_round_ss(__m128, __mmask8, __m128, __m128, int);
extern __m128    __cdecl _mm_maskz_div_round_ss(__mmask8, __m128, __m128, int);
extern __m128d   __cdecl _mm_mask_div_sd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_maskz_div_sd(__mmask8, __m128d, __m128d);
extern __m128    __cdecl _mm_mask_div_ss(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_maskz_div_ss(__mmask8, __m128, __m128);
extern __m128d   __cdecl _mm_fixupimm_round_sd(__m128d, __m128d, __m128i, const int, int);
extern __m128d   __cdecl _mm_mask_fixupimm_round_sd(__m128d, __mmask8, __m128d, __m128i, const int, const int);
extern __m128d   __cdecl _mm_maskz_fixupimm_round_sd(__mmask8, __m128d, __m128d, __m128i, const int, const int);
extern __m128    __cdecl _mm_fixupimm_round_ss(__m128, __m128, __m128i, const int, const int);
extern __m128    __cdecl _mm_mask_fixupimm_round_ss(__m128, __mmask8, __m128, __m128i, const int, const int);
extern __m128    __cdecl _mm_maskz_fixupimm_round_ss(__mmask8, __m128, __m128, __m128i, const int, const int);
extern __m128d   __cdecl _mm_fixupimm_sd(__m128d, __m128d, __m128i, const int);
extern __m128d   __cdecl _mm_mask_fixupimm_sd(__m128d, __mmask8, __m128d, __m128i, const int);
extern __m128d   __cdecl _mm_maskz_fixupimm_sd(__mmask8, __m128d, __m128d, __m128i, const int);
extern __m128    __cdecl _mm_fixupimm_ss(__m128, __m128, __m128i, const int);
extern __m128    __cdecl _mm_mask_fixupimm_ss(__m128, __mmask8, __m128, __m128i, const int);
extern __m128    __cdecl _mm_maskz_fixupimm_ss(__mmask8, __m128, __m128, __m128i, const int);
extern __m128d   __cdecl _mm_fmadd_round_sd(__m128d, __m128d, __m128d, int);
extern __m128d   __cdecl _mm_mask_fmadd_round_sd(__m128d, __mmask8, __m128d, __m128d, int);
extern __m128d   __cdecl _mm_mask3_fmadd_round_sd(__m128d, __m128d, __m128d, __mmask8, int);
extern __m128d   __cdecl _mm_maskz_fmadd_round_sd(__mmask8, __m128d, __m128d, __m128d, int);
extern __m128    __cdecl _mm_fmadd_round_ss(__m128, __m128, __m128, int);
extern __m128    __cdecl _mm_mask_fmadd_round_ss(__m128, __mmask8, __m128, __m128, int);
extern __m128    __cdecl _mm_mask3_fmadd_round_ss(__m128, __m128, __m128, __mmask8, int);
extern __m128    __cdecl _mm_maskz_fmadd_round_ss(__mmask8, __m128, __m128, __m128, int);
extern __m128d   __cdecl _mm_mask_fmadd_sd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_mask3_fmadd_sd(__m128d, __m128d, __m128d, __mmask8);
extern __m128d   __cdecl _mm_maskz_fmadd_sd(__mmask8, __m128d, __m128d, __m128d);
extern __m128    __cdecl _mm_mask_fmadd_ss(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_mask3_fmadd_ss(__m128, __m128, __m128, __mmask8);
extern __m128    __cdecl _mm_maskz_fmadd_ss(__mmask8, __m128, __m128, __m128);
extern __m128d   __cdecl _mm_fmsub_round_sd(__m128d, __m128d, __m128d, int);
extern __m128d   __cdecl _mm_mask_fmsub_round_sd(__m128d, __mmask8, __m128d, __m128d, int);
extern __m128d   __cdecl _mm_mask3_fmsub_round_sd(__m128d, __m128d, __m128d, __mmask8, int);
extern __m128d   __cdecl _mm_maskz_fmsub_round_sd(__mmask8, __m128d, __m128d, __m128d, int);
extern __m128    __cdecl _mm_fmsub_round_ss(__m128, __m128, __m128, int);
extern __m128    __cdecl _mm_mask_fmsub_round_ss(__m128, __mmask8, __m128, __m128, int);
extern __m128    __cdecl _mm_mask3_fmsub_round_ss(__m128, __m128, __m128, __mmask8, int);
extern __m128    __cdecl _mm_maskz_fmsub_round_ss(__mmask8, __m128, __m128, __m128, int);
extern __m128d   __cdecl _mm_mask_fmsub_sd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_mask3_fmsub_sd(__m128d, __m128d, __m128d, __mmask8);
extern __m128d   __cdecl _mm_maskz_fmsub_sd(__mmask8, __m128d, __m128d, __m128d);
extern __m128    __cdecl _mm_mask_fmsub_ss(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_mask3_fmsub_ss(__m128, __m128, __m128, __mmask8);
extern __m128    __cdecl _mm_maskz_fmsub_ss(__mmask8, __m128, __m128, __m128);
extern __m128d   __cdecl _mm_fnmadd_round_sd(__m128d, __m128d, __m128d, int);
extern __m128d   __cdecl _mm_mask_fnmadd_round_sd(__m128d, __mmask8, __m128d, __m128d, int);
extern __m128d   __cdecl _mm_mask3_fnmadd_round_sd(__m128d, __m128d, __m128d, __mmask8, int);
extern __m128d   __cdecl _mm_maskz_fnmadd_round_sd(__mmask8, __m128d, __m128d, __m128d, int);
extern __m128    __cdecl _mm_fnmadd_round_ss(__m128, __m128, __m128, int);
extern __m128    __cdecl _mm_mask_fnmadd_round_ss(__m128, __mmask8, __m128, __m128, int);
extern __m128    __cdecl _mm_mask3_fnmadd_round_ss(__m128, __m128, __m128, __mmask8, int);
extern __m128    __cdecl _mm_maskz_fnmadd_round_ss(__mmask8, __m128, __m128, __m128, int);
extern __m128d   __cdecl _mm_mask_fnmadd_sd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_mask3_fnmadd_sd(__m128d, __m128d, __m128d, __mmask8);
extern __m128d   __cdecl _mm_maskz_fnmadd_sd(__mmask8, __m128d, __m128d, __m128d);
extern __m128    __cdecl _mm_mask_fnmadd_ss(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_mask3_fnmadd_ss(__m128, __m128, __m128, __mmask8);
extern __m128    __cdecl _mm_maskz_fnmadd_ss(__mmask8, __m128, __m128, __m128);
extern __m128d   __cdecl _mm_fnmsub_round_sd(__m128d, __m128d, __m128d, int);
extern __m128d   __cdecl _mm_mask_fnmsub_round_sd(__m128d, __mmask8, __m128d, __m128d, int);
extern __m128d   __cdecl _mm_mask3_fnmsub_round_sd(__m128d, __m128d, __m128d, __mmask8, int);
extern __m128d   __cdecl _mm_maskz_fnmsub_round_sd(__mmask8, __m128d, __m128d, __m128d, int);
extern __m128    __cdecl _mm_fnmsub_round_ss(__m128, __m128, __m128, int);
extern __m128    __cdecl _mm_mask_fnmsub_round_ss(__m128, __mmask8, __m128, __m128, int);
extern __m128    __cdecl _mm_mask3_fnmsub_round_ss(__m128, __m128, __m128, __mmask8, int);
extern __m128    __cdecl _mm_maskz_fnmsub_round_ss(__mmask8, __m128, __m128, __m128, int);
extern __m128d   __cdecl _mm_mask_fnmsub_sd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_mask3_fnmsub_sd(__m128d, __m128d, __m128d, __mmask8);
extern __m128d   __cdecl _mm_maskz_fnmsub_sd(__mmask8, __m128d, __m128d, __m128d);
extern __m128    __cdecl _mm_mask_fnmsub_ss(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_mask3_fnmsub_ss(__m128, __m128, __m128, __mmask8);
extern __m128    __cdecl _mm_maskz_fnmsub_ss(__mmask8, __m128, __m128, __m128);
extern __mmask8  __cdecl _mm_fpclass_sd_mask(__m128d, int);
extern __mmask8  __cdecl _mm_mask_fpclass_sd_mask(__mmask8, __m128d, int);
extern __mmask8  __cdecl _mm_fpclass_ss_mask(__m128, int);
extern __mmask8  __cdecl _mm_mask_fpclass_ss_mask(__mmask8, __m128, int);
extern __m128d   __cdecl _mm_getexp_round_sd(__m128d, __m128d, const int);
extern __m128d   __cdecl _mm_mask_getexp_round_sd(__m128d, __mmask8, __m128d, __m128d, const int);
extern __m128d   __cdecl _mm_maskz_getexp_round_sd(__mmask8, __m128d, __m128d, const int);
extern __m128    __cdecl _mm_getexp_round_ss(__m128, __m128, const int);
extern __m128    __cdecl _mm_mask_getexp_round_ss(__m128, __mmask8, __m128, __m128, const int);
extern __m128    __cdecl _mm_maskz_getexp_round_ss(__mmask8, __m128, __m128, const int);
extern __m128d   __cdecl _mm_getexp_sd(__m128d, __m128d);
extern __m128d   __cdecl _mm_mask_getexp_sd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_maskz_getexp_sd(__mmask8, __m128d, __m128d);
extern __m128    __cdecl _mm_getexp_ss(__m128, __m128);
extern __m128    __cdecl _mm_mask_getexp_ss(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_maskz_getexp_ss(__mmask8, __m128, __m128);
extern __m128d   __cdecl _mm_getmant_round_sd(__m128d, __m128d, int, int, int);
extern __m128d   __cdecl _mm_mask_getmant_round_sd(__m128d, __mmask8, __m128d, __m128d, int, int, int);
extern __m128d   __cdecl _mm_maskz_getmant_round_sd(__mmask8, __m128d, __m128d, int, int, int);
extern __m128    __cdecl _mm_getmant_round_ss(__m128, __m128, int, int, int);
extern __m128    __cdecl _mm_mask_getmant_round_ss(__m128, __mmask8, __m128, __m128, int, int, int);
extern __m128    __cdecl _mm_maskz_getmant_round_ss(__mmask8, __m128, __m128, int, int, int);
extern __m128d   __cdecl _mm_getmant_sd(__m128d, __m128d, int, int);
extern __m128d   __cdecl _mm_mask_getmant_sd(__m128d, __mmask8, __m128d, __m128d, int, int);
extern __m128d   __cdecl _mm_maskz_getmant_sd(__mmask8, __m128d, __m128d, int, int);
extern __m128    __cdecl _mm_getmant_ss(__m128, __m128, int, int);
extern __m128    __cdecl _mm_mask_getmant_ss(__m128, __mmask8, __m128, __m128, int, int);
extern __m128    __cdecl _mm_maskz_getmant_ss(__mmask8, __m128, __m128, int, int);
extern __m128d   __cdecl _mm_mask_load_sd(__m128d, __mmask8, const double*);
extern __m128d   __cdecl _mm_maskz_load_sd(__mmask8, const double*);
extern __m128    __cdecl _mm_mask_load_ss(__m128, __mmask8, const float*);
extern __m128    __cdecl _mm_maskz_load_ss(__mmask8, const float*);
extern __m128d   __cdecl _mm_mask_max_round_sd(__m128d, __mmask8, __m128d, __m128d, int);
extern __m128d   __cdecl _mm_maskz_max_round_sd(__mmask8, __m128d, __m128d, int);
extern __m128d   __cdecl _mm_max_round_sd(__m128d, __m128d, int);
extern __m128    __cdecl _mm_mask_max_round_ss(__m128, __mmask8, __m128, __m128, int);
extern __m128    __cdecl _mm_maskz_max_round_ss(__mmask8, __m128, __m128, int);
extern __m128    __cdecl _mm_max_round_ss(__m128, __m128, int);
extern __m128d   __cdecl _mm_mask_max_sd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_maskz_max_sd(__mmask8, __m128d, __m128d);
extern __m128    __cdecl _mm_mask_max_ss(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_maskz_max_ss(__mmask8, __m128, __m128);
extern __m128d   __cdecl _mm_mask_min_round_sd(__m128d, __mmask8, __m128d, __m128d, int);
extern __m128d   __cdecl _mm_maskz_min_round_sd(__mmask8, __m128d, __m128d, int);
extern __m128d   __cdecl _mm_min_round_sd(__m128d, __m128d, int);
extern __m128    __cdecl _mm_mask_min_round_ss(__m128, __mmask8, __m128, __m128, int);
extern __m128    __cdecl _mm_maskz_min_round_ss(__mmask8, __m128, __m128, int);
extern __m128    __cdecl _mm_min_round_ss(__m128, __m128, int);
extern __m128d   __cdecl _mm_mask_min_sd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_maskz_min_sd(__mmask8, __m128d, __m128d);
extern __m128    __cdecl _mm_mask_min_ss(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_maskz_min_ss(__mmask8, __m128, __m128);
extern __m128d   __cdecl _mm_mask_move_sd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_maskz_move_sd(__mmask8, __m128d, __m128d);
extern __m128    __cdecl _mm_mask_move_ss(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_maskz_move_ss(__mmask8, __m128, __m128);
extern __m128d   __cdecl _mm_mask_mul_round_sd(__m128d, __mmask8, __m128d, __m128d, int);
extern __m128d   __cdecl _mm_maskz_mul_round_sd(__mmask8, __m128d, __m128d, int);
extern __m128d   __cdecl _mm_mul_round_sd(__m128d, __m128d, int);
extern __m128    __cdecl _mm_mask_mul_round_ss(__m128, __mmask8, __m128, __m128, int);
extern __m128    __cdecl _mm_maskz_mul_round_ss(__mmask8, __m128, __m128, int);
extern __m128    __cdecl _mm_mul_round_ss(__m128, __m128, int);
extern __m128d   __cdecl _mm_mask_mul_sd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_maskz_mul_sd(__mmask8, __m128d, __m128d);
extern __m128    __cdecl _mm_mask_mul_ss(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_maskz_mul_ss(__mmask8, __m128, __m128);
extern __m128d   __cdecl _mm_range_sd(__m128d, __m128d, const int);
extern __m128d   __cdecl _mm_mask_range_sd(__m128d, __mmask8, __m128d, __m128d, const int);
extern __m128d   __cdecl _mm_maskz_range_sd(__mmask8, __m128d, __m128d, const int);
extern __m128d   __cdecl _mm_range_round_sd(__m128d, __m128d, const int, int);
extern __m128d   __cdecl _mm_mask_range_round_sd(__m128d, __mmask8, __m128d, __m128d, const int, int);
extern __m128d   __cdecl _mm_maskz_range_round_sd(__mmask8, __m128d, __m128d, const int, int);
extern __m128    __cdecl _mm_range_ss(__m128, __m128, const int);
extern __m128    __cdecl _mm_mask_range_ss(__m128, __mmask8, __m128, __m128, const int);
extern __m128    __cdecl _mm_maskz_range_ss(__mmask8, __m128, __m128, const int);
extern __m128    __cdecl _mm_range_round_ss(__m128, __m128, const int, int);
extern __m128    __cdecl _mm_mask_range_round_ss(__m128, __mmask8, __m128, __m128, const int, int);
extern __m128    __cdecl _mm_maskz_range_round_ss(__mmask8, __m128, __m128, const int, int);
extern __m128d   __cdecl _mm_mask_rcp14_sd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_maskz_rcp14_sd(__mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_rcp14_sd(__m128d, __m128d);
extern __m128    __cdecl _mm_mask_rcp14_ss(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_maskz_rcp14_ss(__mmask8, __m128, __m128);
extern __m128    __cdecl _mm_rcp14_ss(__m128, __m128);
extern __m128d   __cdecl _mm_mask_rcp28_round_sd(__m128d, __mmask8, __m128d, __m128d, int);
extern __m128d   __cdecl _mm_maskz_rcp28_round_sd(__mmask8, __m128d, __m128d, int);
extern __m128d   __cdecl _mm_rcp28_round_sd(__m128d, __m128d, int);
extern __m128    __cdecl _mm_mask_rcp28_round_ss(__m128, __mmask8, __m128, __m128, int);
extern __m128    __cdecl _mm_maskz_rcp28_round_ss(__mmask8, __m128, __m128, int);
extern __m128    __cdecl _mm_rcp28_round_ss(__m128, __m128, int);
extern __m128d   __cdecl _mm_mask_rcp28_sd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_maskz_rcp28_sd(__mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_rcp28_sd(__m128d, __m128d);
extern __m128    __cdecl _mm_mask_rcp28_ss(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_maskz_rcp28_ss(__mmask8, __m128, __m128);
extern __m128    __cdecl _mm_rcp28_ss(__m128, __m128);
extern __m128d   __cdecl _mm_mask_reduce_round_sd(__m128d, __mmask8, __m128d, __m128d, const int, int);
extern __m128d   __cdecl _mm_maskz_reduce_round_sd(__mmask8, __m128d, __m128d, const int, int);
extern __m128d   __cdecl _mm_reduce_round_sd(__m128d, __m128d, const int, int);
extern __m128    __cdecl _mm_mask_reduce_round_ss(__m128, __mmask8, __m128, __m128, const int, int);
extern __m128    __cdecl _mm_maskz_reduce_round_ss(__mmask8, __m128, __m128, const int, int);
extern __m128    __cdecl _mm_reduce_round_ss(__m128, __m128, const int, int);
extern __m128d   __cdecl _mm_mask_reduce_sd(__m128d, __mmask8, __m128d, __m128d, const int);
extern __m128d   __cdecl _mm_maskz_reduce_sd(__mmask8, __m128d, __m128d, const int);
extern __m128d   __cdecl _mm_reduce_sd(__m128d, __m128d, const int);
extern __m128    __cdecl _mm_mask_reduce_ss(__m128, __mmask8, __m128, __m128, const int);
extern __m128    __cdecl _mm_maskz_reduce_ss(__mmask8, __m128, __m128, const int);
extern __m128    __cdecl _mm_reduce_ss(__m128, __m128, const int);
extern __m128d   __cdecl _mm_mask_roundscale_round_sd(__m128d, __mmask8, __m128d, __m128d, const int, const int);
extern __m128d   __cdecl _mm_maskz_roundscale_round_sd(__mmask8, __m128d, __m128d, const int, const int);
extern __m128d   __cdecl _mm_roundscale_round_sd(__m128d, __m128d, const int, const int);
extern __m128    __cdecl _mm_mask_roundscale_round_ss(__m128, __mmask8, __m128, __m128, const int, const int);
extern __m128    __cdecl _mm_maskz_roundscale_round_ss(__mmask8, __m128, __m128, const int, const int);
extern __m128    __cdecl _mm_roundscale_round_ss(__m128, __m128, const int, const int);
extern __m128d   __cdecl _mm_mask_roundscale_sd(__m128d, __mmask8, __m128d, __m128d, const int);
extern __m128d   __cdecl _mm_maskz_roundscale_sd(__mmask8, __m128d, __m128d, const int);
extern __m128d   __cdecl _mm_roundscale_sd(__m128d, __m128d, const int);
extern __m128    __cdecl _mm_mask_roundscale_ss(__m128, __mmask8, __m128, __m128, const int);
extern __m128    __cdecl _mm_maskz_roundscale_ss(__mmask8, __m128, __m128, const int);
extern __m128    __cdecl _mm_roundscale_ss(__m128, __m128, const int);
extern __m128d   __cdecl _mm_mask_rsqrt14_sd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_maskz_rsqrt14_sd(__mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_rsqrt14_sd(__m128d, __m128d);
extern __m128    __cdecl _mm_mask_rsqrt14_ss(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_maskz_rsqrt14_ss(__mmask8, __m128, __m128);
extern __m128    __cdecl _mm_rsqrt14_ss(__m128, __m128);
extern __m128d   __cdecl _mm_mask_rsqrt28_round_sd(__m128d, __mmask8, __m128d, __m128d, int);
extern __m128d   __cdecl _mm_maskz_rsqrt28_round_sd(__mmask8, __m128d, __m128d, int);
extern __m128d   __cdecl _mm_rsqrt28_round_sd(__m128d, __m128d, int);
extern __m128    __cdecl _mm_mask_rsqrt28_round_ss(__m128, __mmask8, __m128, __m128, int);
extern __m128    __cdecl _mm_maskz_rsqrt28_round_ss(__mmask8, __m128, __m128, int);
extern __m128    __cdecl _mm_rsqrt28_round_ss(__m128, __m128, int);
extern __m128d   __cdecl _mm_mask_rsqrt28_sd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_maskz_rsqrt28_sd(__mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_rsqrt28_sd(__m128d, __m128d);
extern __m128    __cdecl _mm_mask_rsqrt28_ss(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_maskz_rsqrt28_ss(__mmask8, __m128, __m128);
extern __m128    __cdecl _mm_rsqrt28_ss(__m128, __m128);
extern __m128d   __cdecl _mm_mask_scalef_round_sd(__m128d, __mmask8, __m128d, __m128d, int);
extern __m128d   __cdecl _mm_maskz_scalef_round_sd(__mmask8, __m128d, __m128d, int);
extern __m128d   __cdecl _mm_scalef_round_sd(__m128d, __m128d, int);
extern __m128    __cdecl _mm_mask_scalef_round_ss(__m128, __mmask8, __m128, __m128, int);
extern __m128    __cdecl _mm_maskz_scalef_round_ss(__mmask8, __m128, __m128, int);
extern __m128    __cdecl _mm_scalef_round_ss(__m128, __m128, int);
extern __m128d   __cdecl _mm_mask_scalef_sd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_maskz_scalef_sd(__mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_scalef_sd(__m128d, __m128d);
extern __m128    __cdecl _mm_mask_scalef_ss(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_maskz_scalef_ss(__mmask8, __m128, __m128);
extern __m128    __cdecl _mm_scalef_ss(__m128, __m128);
extern __m128d   __cdecl _mm_mask_sqrt_round_sd(__m128d, __mmask8, __m128d, __m128d, int);
extern __m128d   __cdecl _mm_maskz_sqrt_round_sd(__mmask8, __m128d, __m128d, int);
extern __m128d   __cdecl _mm_sqrt_round_sd(__m128d, __m128d, int);
extern __m128    __cdecl _mm_mask_sqrt_round_ss(__m128, __mmask8, __m128, __m128, int);
extern __m128    __cdecl _mm_maskz_sqrt_round_ss(__mmask8, __m128, __m128, int);
extern __m128    __cdecl _mm_sqrt_round_ss(__m128, __m128, int);
extern __m128d   __cdecl _mm_mask_sqrt_sd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_maskz_sqrt_sd(__mmask8, __m128d, __m128d);
extern __m128    __cdecl _mm_mask_sqrt_ss(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_maskz_sqrt_ss(__mmask8, __m128, __m128);
extern void      __cdecl _mm_mask_store_sd(double*, __mmask8, __m128d);
extern void      __cdecl _mm_mask_store_ss(float*, __mmask8, __m128);
extern __m128d   __cdecl _mm_mask_sub_round_sd(__m128d, __mmask8, __m128d, __m128d, int);
extern __m128d   __cdecl _mm_maskz_sub_round_sd(__mmask8, __m128d, __m128d, int);
extern __m128d   __cdecl _mm_sub_round_sd(__m128d, __m128d, int);
extern __m128    __cdecl _mm_mask_sub_round_ss(__m128, __mmask8, __m128, __m128, int);
extern __m128    __cdecl _mm_maskz_sub_round_ss(__mmask8, __m128, __m128, int);
extern __m128    __cdecl _mm_sub_round_ss(__m128, __m128, int);
extern __m128d   __cdecl _mm_mask_sub_sd(__m128d, __mmask8, __m128d, __m128d);
extern __m128d   __cdecl _mm_maskz_sub_sd(__mmask8, __m128d, __m128d);
extern __m128    __cdecl _mm_mask_sub_ss(__m128, __mmask8, __m128, __m128);
extern __m128    __cdecl _mm_maskz_sub_ss(__mmask8, __m128, __m128);


#line 4344 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\zmmintrin.h"


extern __m512d   __cdecl _mm512_zextpd128_pd512(__m128d);
extern __m512d   __cdecl _mm512_zextpd256_pd512(__m256d);
extern __m512    __cdecl _mm512_zextps128_ps512(__m128);
extern __m512    __cdecl _mm512_zextps256_ps512(__m256);
extern __m512i   __cdecl _mm512_zextsi128_si512(__m128i);
extern __m512i   __cdecl _mm512_zextsi256_si512(__m256i);


#line 4380 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\zmmintrin.h"


extern __m128i __cdecl _mm_madd52hi_epu64(__m128i, __m128i, __m128i);
extern __m128i __cdecl _mm_mask_madd52hi_epu64(__m128i, __mmask8, __m128i, __m128i);
extern __m128i __cdecl _mm_maskz_madd52hi_epu64(__mmask8, __m128i, __m128i, __m128i);
extern __m256i __cdecl _mm256_madd52hi_epu64(__m256i, __m256i, __m256i);
extern __m256i __cdecl _mm256_mask_madd52hi_epu64(__m256i, __mmask8, __m256i, __m256i);
extern __m256i __cdecl _mm256_maskz_madd52hi_epu64(__mmask8, __m256i, __m256i, __m256i);
extern __m512i __cdecl _mm512_madd52hi_epu64(__m512i, __m512i, __m512i);
extern __m512i __cdecl _mm512_mask_madd52hi_epu64(__m512i, __mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_madd52hi_epu64(__mmask8, __m512i, __m512i, __m512i);

extern __m128i __cdecl _mm_madd52lo_epu64(__m128i, __m128i, __m128i);
extern __m128i __cdecl _mm_mask_madd52lo_epu64(__m128i, __mmask8, __m128i, __m128i);
extern __m128i __cdecl _mm_maskz_madd52lo_epu64(__mmask8, __m128i, __m128i, __m128i);
extern __m256i __cdecl _mm256_madd52lo_epu64(__m256i, __m256i, __m256i);
extern __m256i __cdecl _mm256_mask_madd52lo_epu64(__m256i, __mmask8, __m256i, __m256i);
extern __m256i __cdecl _mm256_maskz_madd52lo_epu64(__mmask8, __m256i, __m256i, __m256i);
extern __m512i __cdecl _mm512_madd52lo_epu64(__m512i, __m512i, __m512i);
extern __m512i __cdecl _mm512_mask_madd52lo_epu64(__m512i, __mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_madd52lo_epu64(__mmask8, __m512i, __m512i, __m512i);


extern __m128i __cdecl _mm_permutexvar_epi8(__m128i, __m128i);
extern __m128i __cdecl _mm_mask_permutexvar_epi8(__m128i, __mmask16, __m128i, __m128i);
extern __m128i __cdecl _mm_maskz_permutexvar_epi8(__mmask16, __m128i, __m128i);
extern __m256i __cdecl _mm256_permutexvar_epi8(__m256i, __m256i);
extern __m256i __cdecl _mm256_mask_permutexvar_epi8(__m256i, __mmask32, __m256i, __m256i);
extern __m256i __cdecl _mm256_maskz_permutexvar_epi8(__mmask32, __m256i, __m256i);
extern __m512i __cdecl _mm512_permutexvar_epi8(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_permutexvar_epi8(__m512i, __mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_permutexvar_epi8(__mmask64, __m512i, __m512i);

extern __m128i __cdecl _mm_permutex2var_epi8(__m128i, __m128i , __m128i);
extern __m128i __cdecl _mm_mask_permutex2var_epi8(__m128i, __mmask16, __m128i , __m128i);
extern __m128i __cdecl _mm_mask2_permutex2var_epi8(__m128i, __m128i , __mmask16, __m128i);
extern __m128i __cdecl _mm_maskz_permutex2var_epi8(__mmask16, __m128i, __m128i , __m128i);
extern __m256i __cdecl _mm256_permutex2var_epi8(__m256i, __m256i, __m256i);
extern __m256i __cdecl _mm256_mask_permutex2var_epi8(__m256i, __mmask32, __m256i, __m256i);
extern __m256i __cdecl _mm256_mask2_permutex2var_epi8(__m256i, __m256i, __mmask32, __m256i);
extern __m256i __cdecl _mm256_maskz_permutex2var_epi8(__mmask32, __m256i, __m256i, __m256i);
extern __m512i __cdecl _mm512_permutex2var_epi8(__m512i, __m512i, __m512i);
extern __m512i __cdecl _mm512_mask_permutex2var_epi8(__m512i, __mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_mask2_permutex2var_epi8(__m512i, __m512i, __mmask64, __m512i);
extern __m512i __cdecl _mm512_maskz_permutex2var_epi8(__mmask64, __m512i, __m512i, __m512i);

extern __m128i __cdecl _mm_multishift_epi64_epi8(__m128i, __m128i);
extern __m128i __cdecl _mm_mask_multishift_epi64_epi8(__m128i, __mmask16, __m128i, __m128i);
extern __m128i __cdecl _mm_maskz_multishift_epi64_epi8(__mmask16, __m128i, __m128i);
extern __m256i __cdecl _mm256_multishift_epi64_epi8(__m256i, __m256i);
extern __m256i __cdecl _mm256_mask_multishift_epi64_epi8(__m256i, __mmask32, __m256i, __m256i);
extern __m256i __cdecl _mm256_maskz_multishift_epi64_epi8(__mmask32, __m256i, __m256i);
extern __m512i __cdecl _mm512_multishift_epi64_epi8(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_multishift_epi64_epi8(__m512i, __mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_multishift_epi64_epi8(__mmask64, __m512i, __m512i);


extern __m128i __cdecl _mm_dpbusd_epi32(__m128i, __m128i, __m128i);
extern __m128i __cdecl _mm_mask_dpbusd_epi32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i __cdecl _mm_maskz_dpbusd_epi32(__mmask8, __m128i, __m128i, __m128i);
extern __m256i __cdecl _mm256_dpbusd_epi32(__m256i, __m256i, __m256i);
extern __m256i __cdecl _mm256_mask_dpbusd_epi32(__m256i, __mmask8, __m256i, __m256i);
extern __m256i __cdecl _mm256_maskz_dpbusd_epi32(__mmask8, __m256i, __m256i, __m256i);
extern __m512i __cdecl _mm512_dpbusd_epi32(__m512i, __m512i, __m512i);
extern __m512i __cdecl _mm512_mask_dpbusd_epi32(__m512i, __mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_dpbusd_epi32(__mmask16, __m512i, __m512i, __m512i);

extern __m128i __cdecl _mm_dpbusds_epi32(__m128i, __m128i, __m128i);
extern __m128i __cdecl _mm_mask_dpbusds_epi32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i __cdecl _mm_maskz_dpbusds_epi32(__mmask8, __m128i, __m128i, __m128i);
extern __m256i __cdecl _mm256_dpbusds_epi32(__m256i, __m256i, __m256i);
extern __m256i __cdecl _mm256_mask_dpbusds_epi32(__m256i, __mmask8, __m256i, __m256i);
extern __m256i __cdecl _mm256_maskz_dpbusds_epi32(__mmask8, __m256i, __m256i, __m256i);
extern __m512i __cdecl _mm512_dpbusds_epi32(__m512i, __m512i, __m512i);
extern __m512i __cdecl _mm512_mask_dpbusds_epi32(__m512i, __mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_dpbusds_epi32(__mmask16, __m512i, __m512i, __m512i);

extern __m128i __cdecl _mm_dpwssd_epi32(__m128i, __m128i, __m128i);
extern __m128i __cdecl _mm_mask_dpwssd_epi32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i __cdecl _mm_maskz_dpwssd_epi32(__mmask8, __m128i, __m128i, __m128i);
extern __m256i __cdecl _mm256_dpwssd_epi32(__m256i, __m256i, __m256i);
extern __m256i __cdecl _mm256_mask_dpwssd_epi32(__m256i, __mmask8, __m256i, __m256i);
extern __m256i __cdecl _mm256_maskz_dpwssd_epi32(__mmask8, __m256i, __m256i, __m256i);
extern __m512i __cdecl _mm512_dpwssd_epi32(__m512i, __m512i, __m512i);
extern __m512i __cdecl _mm512_mask_dpwssd_epi32(__m512i, __mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_dpwssd_epi32(__mmask16, __m512i, __m512i, __m512i);

extern __m128i __cdecl _mm_dpwssds_epi32(__m128i, __m128i, __m128i);
extern __m128i __cdecl _mm_mask_dpwssds_epi32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i __cdecl _mm_maskz_dpwssds_epi32(__mmask8, __m128i, __m128i, __m128i);
extern __m256i __cdecl _mm256_dpwssds_epi32(__m256i, __m256i, __m256i);
extern __m256i __cdecl _mm256_mask_dpwssds_epi32(__m256i, __mmask8, __m256i, __m256i);
extern __m256i __cdecl _mm256_maskz_dpwssds_epi32(__mmask8, __m256i, __m256i, __m256i);
extern __m512i __cdecl _mm512_dpwssds_epi32(__m512i, __m512i, __m512i);
extern __m512i __cdecl _mm512_mask_dpwssds_epi32(__m512i, __mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_dpwssds_epi32(__mmask16, __m512i, __m512i, __m512i);


extern __m256i __cdecl _mm256_aesenc_epi128(__m256i, __m256i);
extern __m512i __cdecl _mm512_aesenc_epi128(__m512i, __m512i);
extern __m256i __cdecl _mm256_aesenclast_epi128(__m256i, __m256i);
extern __m512i __cdecl _mm512_aesenclast_epi128(__m512i, __m512i);
extern __m256i __cdecl _mm256_aesdec_epi128(__m256i, __m256i);
extern __m512i __cdecl _mm512_aesdec_epi128(__m512i, __m512i);
extern __m256i __cdecl _mm256_aesdeclast_epi128(__m256i, __m256i);
extern __m512i __cdecl _mm512_aesdeclast_epi128(__m512i, __m512i);


extern __m256i __cdecl _mm256_clmulepi64_epi128(__m256i, __m256i, const int);
extern __m512i __cdecl _mm512_clmulepi64_epi128(__m512i, __m512i, const int);


extern __m128i __cdecl _mm_popcnt_epi32(__m128i);
extern __m128i __cdecl _mm_mask_popcnt_epi32(__m128i, __mmask8, __m128i);
extern __m128i __cdecl _mm_maskz_popcnt_epi32(__mmask8, __m128i);
extern __m256i __cdecl _mm256_popcnt_epi32(__m256i);
extern __m256i __cdecl _mm256_mask_popcnt_epi32(__m256i, __mmask8, __m256i);
extern __m256i __cdecl _mm256_maskz_popcnt_epi32(__mmask8, __m256i);
extern __m512i __cdecl _mm512_popcnt_epi32(__m512i);
extern __m512i __cdecl _mm512_mask_popcnt_epi32(__m512i, __mmask16, __m512i);
extern __m512i __cdecl _mm512_maskz_popcnt_epi32(__mmask16, __m512i);

extern __m128i __cdecl _mm_popcnt_epi64(__m128i);
extern __m128i __cdecl _mm_mask_popcnt_epi64(__m128i, __mmask8, __m128i);
extern __m128i __cdecl _mm_maskz_popcnt_epi64(__mmask8, __m128i);
extern __m256i __cdecl _mm256_popcnt_epi64(__m256i);
extern __m256i __cdecl _mm256_mask_popcnt_epi64(__m256i, __mmask8, __m256i);
extern __m256i __cdecl _mm256_maskz_popcnt_epi64(__mmask8, __m256i);
extern __m512i __cdecl _mm512_popcnt_epi64(__m512i);
extern __m512i __cdecl _mm512_mask_popcnt_epi64(__m512i, __mmask8, __m512i);
extern __m512i __cdecl _mm512_maskz_popcnt_epi64(__mmask8, __m512i);


extern __m128i __cdecl _mm_popcnt_epi8(__m128i);
extern __m128i __cdecl _mm_mask_popcnt_epi8(__m128i, __mmask16, __m128i);
extern __m128i __cdecl _mm_maskz_popcnt_epi8(__mmask16, __m128i);
extern __m256i __cdecl _mm256_popcnt_epi8(__m256i);
extern __m256i __cdecl _mm256_mask_popcnt_epi8(__m256i, __mmask32, __m256i);
extern __m256i __cdecl _mm256_maskz_popcnt_epi8(__mmask32, __m256i);
extern __m512i __cdecl _mm512_popcnt_epi8(__m512i);
extern __m512i __cdecl _mm512_mask_popcnt_epi8(__m512i, __mmask64, __m512i);
extern __m512i __cdecl _mm512_maskz_popcnt_epi8(__mmask64, __m512i);

extern __m128i __cdecl _mm_popcnt_epi16(__m128i);
extern __m128i __cdecl _mm_mask_popcnt_epi16(__m128i, __mmask8, __m128i);
extern __m128i __cdecl _mm_maskz_popcnt_epi16(__mmask8, __m128i);
extern __m256i __cdecl _mm256_popcnt_epi16(__m256i);
extern __m256i __cdecl _mm256_mask_popcnt_epi16(__m256i, __mmask16, __m256i);
extern __m256i __cdecl _mm256_maskz_popcnt_epi16(__mmask16, __m256i);
extern __m512i __cdecl _mm512_popcnt_epi16(__m512i);
extern __m512i __cdecl _mm512_mask_popcnt_epi16(__m512i, __mmask32, __m512i);
extern __m512i __cdecl _mm512_maskz_popcnt_epi16(__mmask32, __m512i);

extern __mmask16 __cdecl _mm_bitshuffle_epi64_mask(__m128i, __m128i);
extern __mmask16 __cdecl _mm_mask_bitshuffle_epi64_mask(__mmask16, __m128i, __m128i);
extern __mmask32 __cdecl _mm256_bitshuffle_epi64_mask(__m256i, __m256i);
extern __mmask32 __cdecl _mm256_mask_bitshuffle_epi64_mask(__mmask32, __m256i, __m256i);
extern __mmask64 __cdecl _mm512_bitshuffle_epi64_mask(__m512i, __m512i);
extern __mmask64 __cdecl _mm512_mask_bitshuffle_epi64_mask(__mmask64, __m512i, __m512i);


extern __m128i __cdecl _mm_gf2p8affineinv_epi64_epi8(__m128i, __m128i, int);
extern __m128i __cdecl _mm_mask_gf2p8affineinv_epi64_epi8(__m128i, __mmask16, __m128i, __m128i, int);
extern __m128i __cdecl _mm_maskz_gf2p8affineinv_epi64_epi8(__mmask16, __m128i, __m128i, int);
extern __m256i __cdecl _mm256_gf2p8affineinv_epi64_epi8(__m256i, __m256i, int);
extern __m256i __cdecl _mm256_mask_gf2p8affineinv_epi64_epi8(__m256i, __mmask32, __m256i, __m256i, int);
extern __m256i __cdecl _mm256_maskz_gf2p8affineinv_epi64_epi8(__mmask32, __m256i, __m256i, int);
extern __m512i __cdecl _mm512_gf2p8affineinv_epi64_epi8(__m512i, __m512i, int);
extern __m512i __cdecl _mm512_mask_gf2p8affineinv_epi64_epi8(__m512i, __mmask64, __m512i, __m512i, int);
extern __m512i __cdecl _mm512_maskz_gf2p8affineinv_epi64_epi8(__mmask64, __m512i, __m512i, int);
extern __m128i __cdecl _mm_gf2p8affine_epi64_epi8(__m128i, __m128i, int);
extern __m128i __cdecl _mm_mask_gf2p8affine_epi64_epi8(__m128i, __mmask16, __m128i, __m128i, int);
extern __m128i __cdecl _mm_maskz_gf2p8affine_epi64_epi8(__mmask16, __m128i, __m128i, int);
extern __m256i __cdecl _mm256_gf2p8affine_epi64_epi8(__m256i, __m256i, int);
extern __m256i __cdecl _mm256_mask_gf2p8affine_epi64_epi8(__m256i, __mmask32, __m256i, __m256i, int);
extern __m256i __cdecl _mm256_maskz_gf2p8affine_epi64_epi8(__mmask32, __m256i, __m256i, int);
extern __m512i __cdecl _mm512_gf2p8affine_epi64_epi8(__m512i, __m512i, int);
extern __m512i __cdecl _mm512_mask_gf2p8affine_epi64_epi8(__m512i, __mmask64, __m512i, __m512i, int);
extern __m512i __cdecl _mm512_maskz_gf2p8affine_epi64_epi8(__mmask64, __m512i, __m512i, int);
extern __m128i __cdecl _mm_gf2p8mul_epi8(__m128i, __m128i);
extern __m128i __cdecl _mm_mask_gf2p8mul_epi8(__m128i, __mmask16, __m128i, __m128i);
extern __m128i __cdecl _mm_maskz_gf2p8mul_epi8(__mmask16, __m128i, __m128i);
extern __m256i __cdecl _mm256_gf2p8mul_epi8(__m256i, __m256i);
extern __m256i __cdecl _mm256_mask_gf2p8mul_epi8(__m256i, __mmask32, __m256i, __m256i);
extern __m256i __cdecl _mm256_maskz_gf2p8mul_epi8(__mmask32, __m256i, __m256i);
extern __m512i __cdecl _mm512_gf2p8mul_epi8(__m512i, __m512i);
extern __m512i __cdecl _mm512_mask_gf2p8mul_epi8(__m512i, __mmask64, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_gf2p8mul_epi8(__mmask64, __m512i, __m512i);


extern __m128i __cdecl _mm_shldi_epi16(__m128i, __m128i, int);
extern __m128i __cdecl _mm_mask_shldi_epi16(__m128i, __mmask8, __m128i, __m128i, int);
extern __m128i __cdecl _mm_maskz_shldi_epi16(__mmask8, __m128i, __m128i, int);
extern __m256i __cdecl _mm256_shldi_epi16(__m256i, __m256i, int);
extern __m256i __cdecl _mm256_mask_shldi_epi16(__m256i, __mmask16, __m256i, __m256i, int);
extern __m256i __cdecl _mm256_maskz_shldi_epi16(__mmask16, __m256i, __m256i, int);
extern __m512i __cdecl _mm512_shldi_epi16(__m512i, __m512i, int);
extern __m512i __cdecl _mm512_mask_shldi_epi16(__m512i, __mmask32, __m512i, __m512i, int);
extern __m512i __cdecl _mm512_maskz_shldi_epi16(__mmask32, __m512i, __m512i, int);
extern __m128i __cdecl _mm_shldi_epi32(__m128i, __m128i, int);
extern __m128i __cdecl _mm_mask_shldi_epi32(__m128i, __mmask8, __m128i, __m128i, int);
extern __m128i __cdecl _mm_maskz_shldi_epi32(__mmask8, __m128i, __m128i, int);
extern __m256i __cdecl _mm256_shldi_epi32(__m256i, __m256i, int);
extern __m256i __cdecl _mm256_mask_shldi_epi32(__m256i, __mmask8, __m256i, __m256i, int);
extern __m256i __cdecl _mm256_maskz_shldi_epi32(__mmask8, __m256i, __m256i, int);
extern __m512i __cdecl _mm512_shldi_epi32(__m512i, __m512i, int);
extern __m512i __cdecl _mm512_mask_shldi_epi32(__m512i, __mmask16, __m512i, __m512i, int);
extern __m512i __cdecl _mm512_maskz_shldi_epi32(__mmask16, __m512i, __m512i, int);
extern __m128i __cdecl _mm_shldi_epi64(__m128i, __m128i, int);
extern __m128i __cdecl _mm_mask_shldi_epi64(__m128i, __mmask8, __m128i, __m128i, int);
extern __m128i __cdecl _mm_maskz_shldi_epi64(__mmask8, __m128i, __m128i, int);
extern __m256i __cdecl _mm256_shldi_epi64(__m256i, __m256i, int);
extern __m256i __cdecl _mm256_mask_shldi_epi64(__m256i, __mmask8, __m256i, __m256i, int);
extern __m256i __cdecl _mm256_maskz_shldi_epi64(__mmask8, __m256i, __m256i, int);
extern __m512i __cdecl _mm512_shldi_epi64(__m512i, __m512i, int);
extern __m512i __cdecl _mm512_mask_shldi_epi64(__m512i, __mmask8, __m512i, __m512i, int);
extern __m512i __cdecl _mm512_maskz_shldi_epi64(__mmask8, __m512i, __m512i, int);
extern __m128i __cdecl _mm_shldv_epi16(__m128i, __m128i, __m128i);
extern __m128i __cdecl _mm_mask_shldv_epi16(__m128i, __mmask8, __m128i, __m128i);
extern __m128i __cdecl _mm_maskz_shldv_epi16(__mmask8, __m128i, __m128i, __m128i);
extern __m256i __cdecl _mm256_shldv_epi16(__m256i, __m256i, __m256i);
extern __m256i __cdecl _mm256_mask_shldv_epi16(__m256i, __mmask16, __m256i, __m256i);
extern __m256i __cdecl _mm256_maskz_shldv_epi16(__mmask16, __m256i, __m256i, __m256i);
extern __m512i __cdecl _mm512_shldv_epi16(__m512i, __m512i, __m512i);
extern __m512i __cdecl _mm512_mask_shldv_epi16(__m512i, __mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_shldv_epi16(__mmask32, __m512i, __m512i, __m512i);
extern __m128i __cdecl _mm_shldv_epi32(__m128i, __m128i, __m128i);
extern __m128i __cdecl _mm_mask_shldv_epi32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i __cdecl _mm_maskz_shldv_epi32(__mmask8, __m128i, __m128i, __m128i);
extern __m256i __cdecl _mm256_shldv_epi32(__m256i, __m256i, __m256i);
extern __m256i __cdecl _mm256_mask_shldv_epi32(__m256i, __mmask8, __m256i, __m256i);
extern __m256i __cdecl _mm256_maskz_shldv_epi32(__mmask8, __m256i, __m256i, __m256i);
extern __m512i __cdecl _mm512_shldv_epi32(__m512i, __m512i, __m512i);
extern __m512i __cdecl _mm512_mask_shldv_epi32(__m512i, __mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_shldv_epi32(__mmask16, __m512i, __m512i, __m512i);
extern __m128i __cdecl _mm_shldv_epi64(__m128i, __m128i, __m128i);
extern __m128i __cdecl _mm_mask_shldv_epi64(__m128i, __mmask8, __m128i, __m128i);
extern __m128i __cdecl _mm_maskz_shldv_epi64(__mmask8, __m128i, __m128i, __m128i);
extern __m256i __cdecl _mm256_shldv_epi64(__m256i, __m256i, __m256i);
extern __m256i __cdecl _mm256_mask_shldv_epi64(__m256i, __mmask8, __m256i, __m256i);
extern __m256i __cdecl _mm256_maskz_shldv_epi64(__mmask8, __m256i, __m256i, __m256i);
extern __m512i __cdecl _mm512_shldv_epi64(__m512i, __m512i, __m512i);
extern __m512i __cdecl _mm512_mask_shldv_epi64(__m512i, __mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_shldv_epi64(__mmask8, __m512i, __m512i, __m512i);


extern __m128i __cdecl _mm_shrdi_epi16(__m128i, __m128i, int);
extern __m128i __cdecl _mm_mask_shrdi_epi16(__m128i, __mmask8, __m128i, __m128i, int);
extern __m128i __cdecl _mm_maskz_shrdi_epi16(__mmask8, __m128i, __m128i, int);
extern __m256i __cdecl _mm256_shrdi_epi16(__m256i, __m256i, int);
extern __m256i __cdecl _mm256_mask_shrdi_epi16(__m256i, __mmask16, __m256i, __m256i, int);
extern __m256i __cdecl _mm256_maskz_shrdi_epi16(__mmask16, __m256i, __m256i, int);
extern __m512i __cdecl _mm512_shrdi_epi16(__m512i, __m512i, int);
extern __m512i __cdecl _mm512_mask_shrdi_epi16(__m512i, __mmask32, __m512i, __m512i, int);
extern __m512i __cdecl _mm512_maskz_shrdi_epi16(__mmask32, __m512i, __m512i, int);
extern __m128i __cdecl _mm_shrdi_epi32(__m128i, __m128i, int);
extern __m128i __cdecl _mm_mask_shrdi_epi32(__m128i, __mmask8, __m128i, __m128i, int);
extern __m128i __cdecl _mm_maskz_shrdi_epi32(__mmask8, __m128i, __m128i, int);
extern __m256i __cdecl _mm256_shrdi_epi32(__m256i, __m256i, int);
extern __m256i __cdecl _mm256_mask_shrdi_epi32(__m256i, __mmask8, __m256i, __m256i, int);
extern __m256i __cdecl _mm256_maskz_shrdi_epi32(__mmask8, __m256i, __m256i, int);
extern __m512i __cdecl _mm512_shrdi_epi32(__m512i, __m512i, int);
extern __m512i __cdecl _mm512_mask_shrdi_epi32(__m512i, __mmask16, __m512i, __m512i, int);
extern __m512i __cdecl _mm512_maskz_shrdi_epi32(__mmask16, __m512i, __m512i, int);
extern __m128i __cdecl _mm_shrdi_epi64(__m128i, __m128i, int);
extern __m128i __cdecl _mm_mask_shrdi_epi64(__m128i, __mmask8, __m128i, __m128i, int);
extern __m128i __cdecl _mm_maskz_shrdi_epi64(__mmask8, __m128i, __m128i, int);
extern __m256i __cdecl _mm256_shrdi_epi64(__m256i, __m256i, int);
extern __m256i __cdecl _mm256_mask_shrdi_epi64(__m256i, __mmask8, __m256i, __m256i, int);
extern __m256i __cdecl _mm256_maskz_shrdi_epi64(__mmask8, __m256i, __m256i, int);
extern __m512i __cdecl _mm512_shrdi_epi64(__m512i, __m512i, int);
extern __m512i __cdecl _mm512_mask_shrdi_epi64(__m512i, __mmask8, __m512i, __m512i, int);
extern __m512i __cdecl _mm512_maskz_shrdi_epi64(__mmask8, __m512i, __m512i, int);
extern __m128i __cdecl _mm_shrdv_epi16(__m128i, __m128i, __m128i);
extern __m128i __cdecl _mm_mask_shrdv_epi16(__m128i, __mmask8, __m128i, __m128i);
extern __m128i __cdecl _mm_maskz_shrdv_epi16(__mmask8, __m128i, __m128i, __m128i);
extern __m256i __cdecl _mm256_shrdv_epi16(__m256i, __m256i, __m256i);
extern __m256i __cdecl _mm256_mask_shrdv_epi16(__m256i, __mmask16, __m256i, __m256i);
extern __m256i __cdecl _mm256_maskz_shrdv_epi16(__mmask16, __m256i, __m256i, __m256i);
extern __m512i __cdecl _mm512_shrdv_epi16(__m512i, __m512i, __m512i);
extern __m512i __cdecl _mm512_mask_shrdv_epi16(__m512i, __mmask32, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_shrdv_epi16(__mmask32, __m512i, __m512i, __m512i);
extern __m128i __cdecl _mm_shrdv_epi32(__m128i, __m128i, __m128i);
extern __m128i __cdecl _mm_mask_shrdv_epi32(__m128i, __mmask8, __m128i, __m128i);
extern __m128i __cdecl _mm_maskz_shrdv_epi32(__mmask8, __m128i, __m128i, __m128i);
extern __m256i __cdecl _mm256_shrdv_epi32(__m256i, __m256i, __m256i);
extern __m256i __cdecl _mm256_mask_shrdv_epi32(__m256i, __mmask8, __m256i, __m256i);
extern __m256i __cdecl _mm256_maskz_shrdv_epi32(__mmask8, __m256i, __m256i, __m256i);
extern __m512i __cdecl _mm512_shrdv_epi32(__m512i, __m512i, __m512i);
extern __m512i __cdecl _mm512_mask_shrdv_epi32(__m512i, __mmask16, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_shrdv_epi32(__mmask16, __m512i, __m512i, __m512i);
extern __m128i __cdecl _mm_shrdv_epi64(__m128i, __m128i, __m128i);
extern __m128i __cdecl _mm_mask_shrdv_epi64(__m128i, __mmask8, __m128i, __m128i);
extern __m128i __cdecl _mm_maskz_shrdv_epi64(__mmask8, __m128i, __m128i, __m128i);
extern __m256i __cdecl _mm256_shrdv_epi64(__m256i, __m256i, __m256i);
extern __m256i __cdecl _mm256_mask_shrdv_epi64(__m256i, __mmask8, __m256i, __m256i);
extern __m256i __cdecl _mm256_maskz_shrdv_epi64(__mmask8, __m256i, __m256i, __m256i);
extern __m512i __cdecl _mm512_shrdv_epi64(__m512i, __m512i, __m512i);
extern __m512i __cdecl _mm512_mask_shrdv_epi64(__m512i, __mmask8, __m512i, __m512i);
extern __m512i __cdecl _mm512_maskz_shrdv_epi64(__mmask8, __m512i, __m512i, __m512i);


extern __m512i _mm512_div_epi8(__m512i, __m512i);
extern __m512i _mm512_div_epi16(__m512i, __m512i);
extern __m512i _mm512_div_epi32(__m512i, __m512i);
extern __m512i _mm512_div_epi64(__m512i, __m512i);
extern __m512i _mm512_div_epu8(__m512i, __m512i);
extern __m512i _mm512_div_epu16(__m512i, __m512i);
extern __m512i _mm512_div_epu32(__m512i, __m512i);
extern __m512i _mm512_div_epu64(__m512i, __m512i);
extern __m512i _mm512_mask_div_epi32(__m512i , __mmask16, __m512i, __m512i);
extern __m512i _mm512_mask_div_epu32(__m512i , __mmask16, __m512i, __m512i);
extern __m512i _mm512_rem_epi8(__m512i, __m512i);
extern __m512i _mm512_rem_epi16(__m512i, __m512i);
extern __m512i _mm512_rem_epi32(__m512i, __m512i);
extern __m512i _mm512_rem_epi64(__m512i, __m512i);
extern __m512i _mm512_rem_epu8(__m512i, __m512i);
extern __m512i _mm512_rem_epu16(__m512i, __m512i);
extern __m512i _mm512_rem_epu32(__m512i, __m512i);
extern __m512i _mm512_rem_epu64(__m512i, __m512i);
extern __m512i _mm512_mask_rem_epi32(__m512i , __mmask16, __m512i, __m512i);
extern __m512i _mm512_mask_rem_epu32(__m512i , __mmask16, __m512i, __m512i);


extern __m512  _mm512_sin_ps(__m512);
extern __m512  _mm512_mask_sin_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_sin_pd(__m512d);
extern __m512d _mm512_mask_sin_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_cos_ps(__m512);
extern __m512  _mm512_mask_cos_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_cos_pd(__m512d);
extern __m512d _mm512_mask_cos_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_sincos_ps(__m512  * , __m512);
extern __m512  _mm512_mask_sincos_ps(__m512  * , __m512  , __m512  , __mmask16, __m512);
extern __m512d _mm512_sincos_pd(__m512d * , __m512d);
extern __m512d _mm512_mask_sincos_pd(__m512d * , __m512d , __m512d , __mmask8, __m512d);
extern __m512  _mm512_tan_ps(__m512);
extern __m512  _mm512_mask_tan_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_tan_pd(__m512d);
extern __m512d _mm512_mask_tan_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_asin_ps(__m512);
extern __m512  _mm512_mask_asin_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_asin_pd(__m512d);
extern __m512d _mm512_mask_asin_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_acos_ps(__m512);
extern __m512  _mm512_mask_acos_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_acos_pd(__m512d);
extern __m512d _mm512_mask_acos_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_atan_ps(__m512);
extern __m512  _mm512_mask_atan_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_atan_pd(__m512d);
extern __m512d _mm512_mask_atan_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_atan2_ps(__m512, __m512);
extern __m512  _mm512_mask_atan2_ps(__m512  , __mmask16, __m512, __m512);
extern __m512d _mm512_atan2_pd(__m512d, __m512d);
extern __m512d _mm512_mask_atan2_pd(__m512d , __mmask8, __m512d, __m512d);
extern __m512  _mm512_sind_ps(__m512);
extern __m512  _mm512_mask_sind_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_sind_pd(__m512d);
extern __m512d _mm512_mask_sind_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_cosd_ps(__m512);
extern __m512  _mm512_mask_cosd_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_cosd_pd(__m512d);
extern __m512d _mm512_mask_cosd_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_tand_ps(__m512);
extern __m512  _mm512_mask_tand_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_tand_pd(__m512d);
extern __m512d _mm512_mask_tand_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_sinh_ps(__m512);
extern __m512  _mm512_mask_sinh_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_sinh_pd(__m512d);
extern __m512d _mm512_mask_sinh_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_cosh_ps(__m512);
extern __m512  _mm512_mask_cosh_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_cosh_pd(__m512d);
extern __m512d _mm512_mask_cosh_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_tanh_ps(__m512);
extern __m512  _mm512_mask_tanh_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_tanh_pd(__m512d);
extern __m512d _mm512_mask_tanh_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_asinh_ps(__m512);
extern __m512  _mm512_mask_asinh_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_asinh_pd(__m512d);
extern __m512d _mm512_mask_asinh_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_acosh_ps(__m512);
extern __m512  _mm512_mask_acosh_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_acosh_pd(__m512d);
extern __m512d _mm512_mask_acosh_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_atanh_ps(__m512);
extern __m512  _mm512_mask_atanh_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_atanh_pd(__m512d);
extern __m512d _mm512_mask_atanh_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_log_ps(__m512);
extern __m512  _mm512_mask_log_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_log_pd(__m512d);
extern __m512d _mm512_mask_log_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_log1p_ps(__m512);
extern __m512  _mm512_mask_log1p_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_log1p_pd(__m512d);
extern __m512d _mm512_mask_log1p_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_log10_ps(__m512);
extern __m512  _mm512_mask_log10_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_log10_pd(__m512d);
extern __m512d _mm512_mask_log10_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_log2_ps(__m512);
extern __m512  _mm512_mask_log2_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_log2_pd(__m512d);
extern __m512d _mm512_mask_log2_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_logb_ps(__m512);
extern __m512  _mm512_mask_logb_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_logb_pd(__m512d);
extern __m512d _mm512_mask_logb_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_exp_ps(__m512);
extern __m512  _mm512_mask_exp_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_exp_pd(__m512d);
extern __m512d _mm512_mask_exp_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_exp10_ps(__m512);
extern __m512  _mm512_mask_exp10_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_exp10_pd(__m512d);
extern __m512d _mm512_mask_exp10_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_exp2_ps(__m512);
extern __m512  _mm512_mask_exp2_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_exp2_pd(__m512d);
extern __m512d _mm512_mask_exp2_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_expm1_ps(__m512);
extern __m512  _mm512_mask_expm1_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_expm1_pd(__m512d);
extern __m512d _mm512_mask_expm1_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_pow_ps(__m512, __m512);
extern __m512  _mm512_mask_pow_ps(__m512  , __mmask16, __m512, __m512);
extern __m512d _mm512_pow_pd(__m512d, __m512d);
extern __m512d _mm512_mask_pow_pd(__m512d , __mmask8, __m512d, __m512d);
extern __m512  _mm512_trunc_ps(__m512);
extern __m512  _mm512_mask_trunc_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_trunc_pd(__m512d);
extern __m512d _mm512_mask_trunc_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_floor_ps(__m512);
extern __m512  _mm512_mask_floor_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_floor_pd(__m512d);
extern __m512d _mm512_mask_floor_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_ceil_ps(__m512);
extern __m512  _mm512_mask_ceil_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_ceil_pd(__m512d);
extern __m512d _mm512_mask_ceil_pd(__m512d , __mmask8, __m512d);
extern __m512 _mm512_svml_round_ps(__m512);
extern __m512 _mm512_mask_svml_round_ps(__m512 , __mmask16, __m512);
extern __m512d _mm512_svml_round_pd(__m512d);
extern __m512d _mm512_mask_svml_round_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_fmod_ps(__m512, __m512);
extern __m512  _mm512_mask_fmod_ps(__m512  , __mmask16, __m512, __m512);
extern __m512d _mm512_fmod_pd(__m512d, __m512d);
extern __m512d _mm512_mask_fmod_pd(__m512d , __mmask8, __m512d, __m512d);
extern __m512  _mm512_rint_ps(__m512);
extern __m512  _mm512_mask_rint_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_rint_pd(__m512d);
extern __m512d _mm512_mask_rint_pd(__m512d , __mmask8, __m512d);


extern __m512  _mm512_invsqrt_ps(__m512);
extern __m512  _mm512_mask_invsqrt_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_invsqrt_pd(__m512d);
extern __m512d _mm512_mask_invsqrt_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_cbrt_ps(__m512);
extern __m512  _mm512_mask_cbrt_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_cbrt_pd(__m512d);
extern __m512d _mm512_mask_cbrt_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_invcbrt_ps(__m512);
extern __m512  _mm512_mask_invcbrt_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_invcbrt_pd(__m512d);
extern __m512d _mm512_mask_invcbrt_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_hypot_ps(__m512, __m512);
extern __m512  _mm512_mask_hypot_ps(__m512  , __mmask16, __m512, __m512);
extern __m512d _mm512_hypot_pd(__m512d, __m512d);
extern __m512d _mm512_mask_hypot_pd(__m512d , __mmask8, __m512d, __m512d);
extern __m512  _mm512_cdfnorm_ps(__m512);
extern __m512  _mm512_mask_cdfnorm_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_cdfnorm_pd(__m512d);
extern __m512d _mm512_mask_cdfnorm_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_cdfnorminv_ps(__m512);
extern __m512  _mm512_mask_cdfnorminv_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_cdfnorminv_pd(__m512d);
extern __m512d _mm512_mask_cdfnorminv_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_erf_ps(__m512);
extern __m512  _mm512_mask_erf_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_erf_pd(__m512d);
extern __m512d _mm512_mask_erf_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_erfc_ps(__m512);
extern __m512  _mm512_mask_erfc_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_erfc_pd(__m512d);
extern __m512d _mm512_mask_erfc_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_erfcinv_ps(__m512);
extern __m512  _mm512_mask_erfcinv_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_erfcinv_pd(__m512d);
extern __m512d _mm512_mask_erfcinv_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_erfinv_ps(__m512);
extern __m512  _mm512_mask_erfinv_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_erfinv_pd(__m512d);
extern __m512d _mm512_mask_erfinv_pd(__m512d , __mmask8, __m512d);
extern __m512  _mm512_nearbyint_ps(__m512);
extern __m512  _mm512_mask_nearbyint_ps(__m512  , __mmask16, __m512);
extern __m512d _mm512_nearbyint_pd(__m512d);
extern __m512d _mm512_mask_nearbyint_pd(__m512d , __mmask8, __m512d);


typedef __m128i __m128bh;
typedef __m256i __m256bh;
typedef __m512i __m512bh;

extern __m128bh _mm_cvtneps_pbh(__m128);
extern __m128bh _mm_mask_cvtneps_pbh(__m128bh, __mmask8, __m128);
extern __m128bh _mm_maskz_cvtneps_pbh(__mmask8, __m128);
extern __m128bh _mm_cvtne2ps_pbh(__m128, __m128);
extern __m128bh _mm_mask_cvtne2ps_pbh(__m128bh, __mmask8, __m128, __m128);
extern __m128bh _mm_maskz_cvtne2ps_pbh(__mmask8, __m128, __m128);
extern __m128   _mm_dpbf16_ps(__m128, __m128bh, __m128bh);
extern __m128   _mm_mask_dpbf16_ps(__m128, __mmask8, __m128bh, __m128bh);
extern __m128   _mm_maskz_dpbf16_ps(__mmask8, __m128, __m128bh, __m128bh);
extern __m128bh _mm256_cvtneps_pbh(__m256);
extern __m128bh _mm256_mask_cvtneps_pbh(__m128bh, __mmask8, __m256);
extern __m128bh _mm256_maskz_cvtneps_pbh(__mmask8, __m256);
extern __m256bh _mm256_cvtne2ps_pbh(__m256, __m256);
extern __m256bh _mm256_mask_cvtne2ps_pbh(__m256bh, __mmask16, __m256, __m256);
extern __m256bh _mm256_maskz_cvtne2ps_pbh(__mmask16, __m256, __m256);
extern __m256   _mm256_dpbf16_ps(__m256, __m256bh, __m256bh);
extern __m256   _mm256_mask_dpbf16_ps(__m256, __mmask8, __m256bh, __m256bh);
extern __m256   _mm256_maskz_dpbf16_ps(__mmask8, __m256, __m256bh, __m256bh);
extern __m256bh _mm512_cvtneps_pbh(__m512);
extern __m256bh _mm512_mask_cvtneps_pbh(__m256bh, __mmask16, __m512);
extern __m256bh _mm512_maskz_cvtneps_pbh(__mmask16, __m512);
extern __m512bh _mm512_cvtne2ps_pbh(__m512, __m512);
extern __m512bh _mm512_mask_cvtne2ps_pbh(__m512bh, __mmask32, __m512, __m512);
extern __m512bh _mm512_maskz_cvtne2ps_pbh(__mmask32, __m512, __m512);
extern __m512   _mm512_dpbf16_ps(__m512, __m512bh, __m512bh);
extern __m512   _mm512_mask_dpbf16_ps(__m512, __mmask16, __m512bh, __m512bh);
extern __m512   _mm512_maskz_dpbf16_ps(__mmask16, __m512, __m512bh, __m512bh);


extern __mmask8  __cdecl _kadd_mask8(__mmask8, __mmask8);
extern __mmask16 __cdecl _kadd_mask16(__mmask16, __mmask16);
extern __mmask32 __cdecl _kadd_mask32(__mmask32, __mmask32);
extern __mmask64 __cdecl _kadd_mask64(__mmask64, __mmask64);
extern __mmask8  __cdecl _kand_mask8(__mmask8, __mmask8);
extern __mmask16 __cdecl _kand_mask16(__mmask16, __mmask16);
extern __mmask32 __cdecl _kand_mask32(__mmask32, __mmask32);
extern __mmask64 __cdecl _kand_mask64(__mmask64, __mmask64);
extern __mmask8  __cdecl _kandn_mask8(__mmask8, __mmask8);
extern __mmask16 __cdecl _kandn_mask16(__mmask16, __mmask16);
extern __mmask32 __cdecl _kandn_mask32(__mmask32, __mmask32);
extern __mmask64 __cdecl _kandn_mask64(__mmask64, __mmask64);
extern __mmask8  __cdecl _knot_mask8(__mmask8);
extern __mmask16 __cdecl _knot_mask16(__mmask16);
extern __mmask32 __cdecl _knot_mask32(__mmask32);
extern __mmask64 __cdecl _knot_mask64(__mmask64);
extern __mmask8  __cdecl _kor_mask8(__mmask8, __mmask8);
extern __mmask16 __cdecl _kor_mask16(__mmask16, __mmask16);
extern __mmask32 __cdecl _kor_mask32(__mmask32, __mmask32);
extern __mmask64 __cdecl _kor_mask64(__mmask64, __mmask64);
extern __mmask8  __cdecl _kxnor_mask8(__mmask8, __mmask8);
extern __mmask16 __cdecl _kxnor_mask16(__mmask16, __mmask16);
extern __mmask32 __cdecl _kxnor_mask32(__mmask32, __mmask32);
extern __mmask64 __cdecl _kxnor_mask64(__mmask64, __mmask64);
extern __mmask8  __cdecl _kxor_mask8(__mmask8, __mmask8);
extern __mmask16 __cdecl _kxor_mask16(__mmask16, __mmask16);
extern __mmask32 __cdecl _kxor_mask32(__mmask32, __mmask32);
extern __mmask64 __cdecl _kxor_mask64(__mmask64, __mmask64);
extern __mmask8  __cdecl _kshiftli_mask8(__mmask8, unsigned int);
extern __mmask16 __cdecl _kshiftli_mask16(__mmask16, unsigned int);
extern __mmask32 __cdecl _kshiftli_mask32(__mmask32, unsigned int);
extern __mmask64 __cdecl _kshiftli_mask64(__mmask64, unsigned int);
extern __mmask8  __cdecl _kshiftri_mask8(__mmask8, unsigned int);
extern __mmask16 __cdecl _kshiftri_mask16(__mmask16, unsigned int);
extern __mmask32 __cdecl _kshiftri_mask32(__mmask32, unsigned int);
extern __mmask64 __cdecl _kshiftri_mask64(__mmask64, unsigned int);
extern __mmask8  __cdecl _load_mask8(__mmask8 *);
extern __mmask16 __cdecl _load_mask16(__mmask16 *);
extern __mmask32 __cdecl _load_mask32(__mmask32 *);
extern __mmask64 __cdecl _load_mask64(__mmask64 *);
extern void      __cdecl _store_mask8(__mmask8 *, __mmask8);
extern void      __cdecl _store_mask16(__mmask16 *, __mmask16);
extern void      __cdecl _store_mask32(__mmask32 *, __mmask32);
extern void      __cdecl _store_mask64(__mmask64 *, __mmask64);
extern unsigned int     __cdecl _cvtmask8_u32(__mmask8);
extern unsigned int     __cdecl _cvtmask16_u32(__mmask16);
extern unsigned int     __cdecl _cvtmask32_u32(__mmask32);
extern unsigned __int64 __cdecl _cvtmask64_u64(__mmask64);
extern __mmask8         __cdecl _cvtu32_mask8(unsigned int);
extern __mmask16        __cdecl _cvtu32_mask16(unsigned int);
extern __mmask32        __cdecl _cvtu32_mask32(unsigned int);
extern __mmask64        __cdecl _cvtu64_mask64(unsigned __int64);
extern __mmask16        __cdecl _mm512_kmov(__mmask16);
extern unsigned char __cdecl _kortest_mask8_u8(__mmask8, __mmask8, unsigned char *);
extern unsigned char __cdecl _kortest_mask16_u8(__mmask16, __mmask16, unsigned char *);
extern unsigned char __cdecl _kortest_mask32_u8(__mmask32, __mmask32, unsigned char *);
extern unsigned char __cdecl _kortest_mask64_u8(__mmask64, __mmask64, unsigned char *);
extern unsigned char __cdecl _ktest_mask8_u8(__mmask8, __mmask8, unsigned char *);
extern unsigned char __cdecl _ktest_mask16_u8(__mmask16, __mmask16, unsigned char *);
extern unsigned char __cdecl _ktest_mask32_u8(__mmask32, __mmask32, unsigned char *);
extern unsigned char __cdecl _ktest_mask64_u8(__mmask64, __mmask64, unsigned char *);


extern __m512  __cdecl _mm512_mask_exp2a23_round_ps(__m512, __mmask16, __m512, int);
extern __m512  __cdecl _mm512_maskz_exp2a23_round_ps(__mmask16, __m512, int);
extern __m512d __cdecl _mm512_mask_exp2a23_round_pd(__m512d, __mmask8, __m512d, int);
extern __m512d __cdecl _mm512_maskz_exp2a23_round_pd(__mmask8, __m512d, int);


extern __m512  __cdecl _mm512_mask_rcp28_round_ps(__m512, __mmask16, __m512, const int);
extern __m512  __cdecl _mm512_maskz_rcp28_round_ps(__mmask16, __m512, const int);
extern __m512d __cdecl _mm512_mask_rcp28_round_pd(__m512d, __mmask8, __m512d, const int);
extern __m512d __cdecl _mm512_maskz_rcp28_round_pd(__mmask8, __m512d, const int);


extern __m512  __cdecl _mm512_mask_rsqrt28_round_ps(__m512, __mmask16, __m512, const int);
extern __m512  __cdecl _mm512_maskz_rsqrt28_round_ps(__mmask16, __m512, const int);
extern __m512d __cdecl _mm512_mask_rsqrt28_round_pd(__m512d, __mmask8, __m512d, const int);
extern __m512d __cdecl _mm512_maskz_rsqrt28_round_pd(__mmask8, __m512d, const int);


extern void __cdecl _mm512_prefetch_i32gather_pd(__m256i vindex, void const* base_addr, int scale, const int hint);
extern void __cdecl _mm512_prefetch_i32gather_ps(__m512i index, void const* mv, int scale, const int hint);
extern void __cdecl _mm512_prefetch_i32scatter_pd(void* base_addr, __m256i vindex, int scale, const int hint);
extern void __cdecl _mm512_prefetch_i32scatter_ps(void* mv, __m512i index, int scale, const int hint);
extern void __cdecl _mm512_prefetch_i64gather_pd(__m512i vindex, void const* base_addr, int scale, const int hint);
extern void __cdecl _mm512_prefetch_i64gather_ps(__m512i vindex, void const* base_addr, int scale, const int hint);
extern void __cdecl _mm512_prefetch_i64scatter_pd(void* base_addr, __m512i vindex, int scale, const int hint);
extern void __cdecl _mm512_prefetch_i64scatter_ps(void* base_addr, __m512i vindex, int scale, const int hint);
extern void __cdecl _mm512_mask_prefetch_i32gather_pd(__m256i vindex, __mmask8 mask, void const* base_addr, int scale, const int hint);
extern void __cdecl _mm512_mask_prefetch_i32gather_ps(__m512i vindex, __mmask16 mask, void const* base_addr, int scale, const int hint);
extern void __cdecl _mm512_mask_prefetch_i32scatter_pd(void* base_addr, __mmask8 mask, __m256i vinde, int scale, const int hint);
extern void __cdecl _mm512_mask_prefetch_i32scatter_ps(void* mv, __mmask16 k, __m512i index, int scale, const int hint);
extern void __cdecl _mm512_mask_prefetch_i64gather_pd(__m512i vindex, __mmask8 mask, void const* base_addr, int scale, const int hint);
extern void __cdecl _mm512_mask_prefetch_i64gather_ps(__m512i vindex, __mmask8 mask, void const* base_addr, int scale, const int hint);
extern void __cdecl _mm512_mask_prefetch_i64scatter_pd(void* base_addr, __mmask8 mask, __m512i vindex, int scale, const int hint);
extern void __cdecl _mm512_mask_prefetch_i64scatter_ps(void* base_addr, __mmask8 mask, __m512i vindex, int scale, const int hint);


extern void __cdecl _mm_2intersect_epi32(__m128i, __m128i, __mmask8 *, __mmask8 *);
extern void __cdecl _mm256_2intersect_epi32(__m256i, __m256i, __mmask8 *, __mmask8 *);
extern void __cdecl _mm512_2intersect_epi32(__m512i, __m512i, __mmask16 *, __mmask16 *);
extern void __cdecl _mm_2intersect_epi64(__m128i, __m128i, __mmask8 *, __mmask8 *);
extern void __cdecl _mm256_2intersect_epi64(__m256i, __m256i, __mmask8 *, __mmask8 *);
extern void __cdecl _mm512_2intersect_epi64(__m512i, __m512i, __mmask8 *, __mmask8 *);


#line 5153 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\zmmintrin.h"


typedef __m128i __m128h;
typedef __m256i __m256h;
typedef __m512i __m512h;


extern __m128h __cdecl _mm_add_ph(__m128h, __m128h);
extern __m128h __cdecl _mm_mask_add_ph(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_maskz_add_ph(__mmask8, __m128h, __m128h);
extern __m256h __cdecl _mm256_add_ph(__m256h, __m256h);
extern __m256h __cdecl _mm256_mask_add_ph(__m256h, __mmask16, __m256h, __m256h);
extern __m256h __cdecl _mm256_maskz_add_ph(__mmask16, __m256h, __m256h);
extern __m512h __cdecl _mm512_add_ph(__m512h, __m512h);
extern __m512h __cdecl _mm512_mask_add_ph(__m512h, __mmask32, __m512h, __m512h);
extern __m512h __cdecl _mm512_maskz_add_ph(__mmask32, __m512h, __m512h);
extern __m512h __cdecl _mm512_add_round_ph(__m512h, __m512h, int);
extern __m512h __cdecl _mm512_mask_add_round_ph(__m512h, __mmask32, __m512h, __m512h, int);
extern __m512h __cdecl _mm512_maskz_add_round_ph(__mmask32, __m512h, __m512h, int);


extern __m128h __cdecl _mm_add_sh(__m128h, __m128h);
extern __m128h __cdecl _mm_mask_add_sh(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_maskz_add_sh(__mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_add_round_sh(__m128h, __m128h, int);
extern __m128h __cdecl _mm_mask_add_round_sh(__m128h, __mmask8, __m128h, __m128h, int);
extern __m128h __cdecl _mm_maskz_add_round_sh(__mmask8, __m128h, __m128h, int);


extern __mmask8 __cdecl _mm_cmp_ph_mask(__m128h, __m128h, const int);
extern __mmask8 __cdecl _mm_mask_cmp_ph_mask(__mmask8, __m128h, __m128h, const int);
extern __mmask16 __cdecl _mm256_cmp_ph_mask(__m256h, __m256h, const int);
extern __mmask16 __cdecl _mm256_mask_cmp_ph_mask(__mmask16, __m256h, __m256h, const int);
extern __mmask32 __cdecl _mm512_cmp_ph_mask(__m512h, __m512h, const int);
extern __mmask32 __cdecl _mm512_mask_cmp_ph_mask(__mmask32, __m512h, __m512h, const int);
extern __mmask32 __cdecl _mm512_cmp_round_ph_mask(__m512h, __m512h, const int, const int);
extern __mmask32 __cdecl _mm512_mask_cmp_round_ph_mask(__mmask32, __m512h, __m512h, const int, const int);


extern __mmask8 __cdecl _mm_cmp_sh_mask(__m128h, __m128h, const int);
extern __mmask8 __cdecl _mm_mask_cmp_sh_mask(__mmask8, __m128h, __m128h, const int);
extern __mmask8 __cdecl _mm_cmp_round_sh_mask(__m128h, __m128h, const int, const int);
extern __mmask8 __cdecl _mm_mask_cmp_round_sh_mask(__mmask8, __m128h, __m128h, const int, const int);


extern int __cdecl _mm_comi_sh(__m128h, __m128h, const int);
extern int __cdecl _mm_comi_round_sh(__m128h, __m128h, const int, const int);


extern __m128h __cdecl _mm_cvtepi32_ph(__m128i);
extern __m128h __cdecl _mm_mask_cvtepi32_ph(__m128h, __mmask8, __m128i);
extern __m128h __cdecl _mm_maskz_cvtepi32_ph(__mmask8, __m128i);
extern __m128h __cdecl _mm256_cvtepi32_ph(__m256i);
extern __m128h __cdecl _mm256_mask_cvtepi32_ph(__m128h, __mmask8, __m256i);
extern __m128h __cdecl _mm256_maskz_cvtepi32_ph(__mmask8, __m256i);
extern __m256h __cdecl _mm512_cvtepi32_ph (__m512i);
extern __m256h __cdecl _mm512_mask_cvtepi32_ph (__m256h, __mmask16, __m512i);;
extern __m256h __cdecl _mm512_maskz_cvtepi32_ph (__mmask16, __m512i);
extern __m256h __cdecl _mm512_cvt_roundepi32_ph(__m512i, int);
extern __m256h __cdecl _mm512_mask_cvt_roundepi32_ph(__m256h, __mmask16, __m512i, int);
extern __m256h __cdecl _mm512_maskz_cvt_roundepi32_ph(__mmask16, __m512i, int);


extern __m128h __cdecl _mm_cvtpd_ph(__m128d);
extern __m128h __cdecl _mm_mask_cvtpd_ph(__m128h, __mmask8, __m128d);
extern __m128h __cdecl _mm_maskz_cvtpd_ph(__mmask8, __m128d);
extern __m128h __cdecl _mm256_cvtpd_ph(__m256d);
extern __m128h __cdecl _mm256_mask_cvtpd_ph(__m128h, __mmask8, __m256d);
extern __m128h __cdecl _mm256_maskz_cvtpd_ph(__mmask8, __m256d);
extern __m128h __cdecl _mm512_cvtpd_ph (__m512d);
extern __m128h __cdecl _mm512_mask_cvtpd_ph (__m128h, __mmask8, __m512d);
extern __m128h __cdecl _mm512_maskz_cvtpd_ph (__mmask8, __m512d);
extern __m128h __cdecl _mm512_cvt_roundpd_ph(__m512d, int);
extern __m128h __cdecl _mm512_mask_cvt_roundpd_ph(__m128h, __mmask8, __m512d, int);
extern __m128h __cdecl _mm512_maskz_cvt_roundpd_ph(__mmask8, __m512d, int);


extern __m128i __cdecl _mm_cvtph_epi32(__m128h);
extern __m128i __cdecl _mm_mask_cvtph_epi32(__m128i, __mmask8, __m128h);
extern __m128i __cdecl _mm_maskz_cvtph_epi32(__mmask8, __m128h);
extern __m256i __cdecl _mm256_cvtph_epi32(__m128h);
extern __m256i __cdecl _mm256_mask_cvtph_epi32(__m256i, __mmask8, __m128h);
extern __m256i __cdecl _mm256_maskz_cvtph_epi32(__mmask8, __m128h);
extern __m512i __cdecl _mm512_cvtph_epi32 (__m256h);
extern __m512i __cdecl _mm512_mask_cvtph_epi32 (__m512i, __mmask16, __m256h);
extern __m512i __cdecl _mm512_maskz_cvtph_epi32 (__mmask16, __m256h);
extern __m512i __cdecl _mm512_cvt_roundph_epi32(__m256h, int);
extern __m512i __cdecl _mm512_mask_cvt_roundph_epi32(__m512i, __mmask16, __m256h, int);
extern __m512i __cdecl _mm512_maskz_cvt_roundph_epi32(__mmask16, __m256h, int);


extern __m128d __cdecl _mm_cvtph_pd(__m128h);
extern __m128d __cdecl _mm_mask_cvtph_pd(__m128d, __mmask8, __m128h);
extern __m128d __cdecl _mm_maskz_cvtph_pd(__mmask8, __m128h);
extern __m256d __cdecl _mm256_cvtph_pd(__m128h);
extern __m256d __cdecl _mm256_mask_cvtph_pd(__m256d, __mmask8, __m128h);
extern __m256d __cdecl _mm256_maskz_cvtph_pd(__mmask8, __m128h);
extern __m512d __cdecl _mm512_cvtph_pd (__m128h);
extern __m512d __cdecl _mm512_mask_cvtph_pd (__m512d, __mmask8, __m128h);
extern __m512d __cdecl _mm512_maskz_cvtph_pd (__mmask8, __m128h);
extern __m512d __cdecl _mm512_cvt_roundph_pd(__m128h, int);
extern __m512d __cdecl _mm512_mask_cvt_roundph_pd(__m512d, __mmask8, __m128h, int);
extern __m512d __cdecl _mm512_maskz_cvt_roundph_pd(__mmask8, __m128h, int);


extern __m128 __cdecl _mm_cvtxph_ps(__m128h);
extern __m128 __cdecl _mm_mask_cvtxph_ps(__m128, __mmask8, __m128h);
extern __m128 __cdecl _mm_maskz_cvtxph_ps(__mmask8, __m128h);
extern __m256 __cdecl _mm256_cvtxph_ps(__m128h);
extern __m256 __cdecl _mm256_mask_cvtxph_ps(__m256, __mmask8, __m128h);
extern __m256 __cdecl _mm256_maskz_cvtxph_ps(__mmask8, __m128h);
extern __m512 __cdecl _mm512_cvtxph_ps(__m256h);
extern __m512 __cdecl _mm512_mask_cvtxph_ps(__m512, __mmask16, __m256h);
extern __m512 __cdecl _mm512_maskz_cvtxph_ps(__mmask16, __m256h);
extern __m512 __cdecl _mm512_cvtx_roundph_ps(__m256h, int);
extern __m512 __cdecl _mm512_mask_cvtx_roundph_ps(__m512, __mmask16, __m256h, int);
extern __m512 __cdecl _mm512_maskz_cvtx_roundph_ps(__mmask16, __m256h, int);


extern __m128i __cdecl _mm_cvtph_epi64(__m128h);
extern __m128i __cdecl _mm_mask_cvtph_epi64(__m128i, __mmask8, __m128h);
extern __m128i __cdecl _mm_maskz_cvtph_epi64(__mmask8, __m128h);
extern __m256i __cdecl _mm256_cvtph_epi64(__m128h);
extern __m256i __cdecl _mm256_mask_cvtph_epi64(__m256i, __mmask8, __m128h);
extern __m256i __cdecl _mm256_maskz_cvtph_epi64(__mmask8, __m128h);
extern __m512i __cdecl _mm512_cvtph_epi64 (__m128h);
extern __m512i __cdecl _mm512_mask_cvtph_epi64 (__m512i, __mmask8, __m128h);
extern __m512i __cdecl _mm512_maskz_cvtph_epi64 (__mmask8, __m128h);
extern __m512i __cdecl _mm512_cvt_roundph_epi64(__m128h, int);
extern __m512i __cdecl _mm512_mask_cvt_roundph_epi64(__m512i, __mmask8, __m128h, int);
extern __m512i __cdecl _mm512_maskz_cvt_roundph_epi64(__mmask8, __m128h, int);


extern __m128i __cdecl _mm_cvtph_epu32(__m128h);
extern __m128i __cdecl _mm_mask_cvtph_epu32(__m128i, __mmask8, __m128h);
extern __m128i __cdecl _mm_maskz_cvtph_epu32(__mmask8, __m128h);
extern __m256i __cdecl _mm256_cvtph_epu32(__m128h);
extern __m256i __cdecl _mm256_mask_cvtph_epu32(__m256i, __mmask8, __m128h);
extern __m256i __cdecl _mm256_maskz_cvtph_epu32(__mmask8, __m128h);
extern __m512i __cdecl _mm512_cvtph_epu32 (__m256h);
extern __m512i __cdecl _mm512_mask_cvtph_epu32 (__m512i, __mmask16, __m256h);
extern __m512i __cdecl _mm512_maskz_cvtph_epu32 (__mmask16, __m256h);
extern __m512i __cdecl _mm512_cvt_roundph_epu32(__m256h, int);
extern __m512i __cdecl _mm512_mask_cvt_roundph_epu32(__m512i, __mmask16, __m256h, int);
extern __m512i __cdecl _mm512_maskz_cvt_roundph_epu32(__mmask16, __m256h, int);


extern __m128i __cdecl _mm_cvtph_epu64(__m128h);
extern __m128i __cdecl _mm_mask_cvtph_epu64(__m128i, __mmask8, __m128h);
extern __m128i __cdecl _mm_maskz_cvtph_epu64(__mmask8, __m128h);
extern __m256i __cdecl _mm256_cvtph_epu64(__m128h);
extern __m256i __cdecl _mm256_mask_cvtph_epu64(__m256i, __mmask8, __m128h);
extern __m256i __cdecl _mm256_maskz_cvtph_epu64(__mmask8, __m128h);
extern __m512i __cdecl _mm512_cvtph_epu64 (__m128h);
extern __m512i __cdecl _mm512_mask_cvtph_epu64 (__m512i, __mmask8, __m128h);
extern __m512i __cdecl _mm512_maskz_cvtph_epu64 (__mmask8, __m128h);
extern __m512i __cdecl _mm512_cvt_roundph_epu64(__m128h, int);
extern __m512i __cdecl _mm512_mask_cvt_roundph_epu64(__m512i, __mmask8, __m128h, int);
extern __m512i __cdecl _mm512_maskz_cvt_roundph_epu64(__mmask8, __m128h, int);


extern __m128i __cdecl _mm_cvtph_epu16(__m128h);
extern __m128i __cdecl _mm_mask_cvtph_epu16(__m128i, __mmask8, __m128h);
extern __m128i __cdecl _mm_maskz_cvtph_epu16(__mmask8, __m128h);
extern __m256i __cdecl _mm256_cvtph_epu16(__m256h);
extern __m256i __cdecl _mm256_mask_cvtph_epu16(__m256i, __mmask16, __m256h);
extern __m256i __cdecl _mm256_maskz_cvtph_epu16(__mmask16, __m256h);
extern __m512i __cdecl _mm512_cvtph_epu16 (__m512h);
extern __m512i __cdecl _mm512_mask_cvtph_epu16 (__m512i, __mmask32, __m512h);
extern __m512i __cdecl _mm512_maskz_cvtph_epu16 (__mmask32, __m512h);
extern __m512i __cdecl _mm512_cvt_roundph_epu16(__m512h, int);
extern __m512i __cdecl _mm512_mask_cvt_roundph_epu16(__m512i, __mmask32, __m512h, int);
extern __m512i __cdecl _mm512_maskz_cvt_roundph_epu16(__mmask32, __m512h, int);


extern __m128i __cdecl _mm_cvtph_epi16(__m128h);
extern __m128i __cdecl _mm_mask_cvtph_epi16(__m128i, __mmask8, __m128h);
extern __m128i __cdecl _mm_maskz_cvtph_epi16(__mmask8, __m128h);
extern __m256i __cdecl _mm256_cvtph_epi16(__m256h);
extern __m256i __cdecl _mm256_mask_cvtph_epi16(__m256i, __mmask16, __m256h);
extern __m256i __cdecl _mm256_maskz_cvtph_epi16(__mmask16, __m256h);
extern __m512i __cdecl _mm512_cvtph_epi16 (__m512h);
extern __m512i __cdecl _mm512_mask_cvtph_epi16 (__m512i, __mmask32, __m512h);
extern __m512i __cdecl _mm512_maskz_cvtph_epi16 (__mmask32, __m512h);
extern __m512i __cdecl _mm512_cvt_roundph_epi16(__m512h, int);
extern __m512i __cdecl _mm512_mask_cvt_roundph_epi16(__m512i, __mmask32, __m512h, int);
extern __m512i __cdecl _mm512_maskz_cvt_roundph_epi16(__mmask32, __m512h, int);


extern __m128h __cdecl _mm_cvtxps_ph(__m128);
extern __m128h __cdecl _mm_mask_cvtxps_ph(__m128h, __mmask8, __m128);
extern __m128h __cdecl _mm_maskz_cvtxps_ph(__mmask8, __m128);
extern __m128h __cdecl _mm256_cvtxps_ph(__m256);
extern __m128h __cdecl _mm256_mask_cvtxps_ph(__m128h, __mmask8, __m256);
extern __m128h __cdecl _mm256_maskz_cvtxps_ph(__mmask8, __m256);
extern __m256h __cdecl _mm512_cvtxps_ph(__m512);
extern __m256h __cdecl _mm512_mask_cvtxps_ph(__m256h, __mmask16, __m512);
extern __m256h __cdecl _mm512_maskz_cvtxps_ph(__mmask16, __m512);
extern __m256h __cdecl _mm512_cvtx_roundps_ph(__m512, int);
extern __m256h __cdecl _mm512_mask_cvtx_roundps_ph(__m256h, __mmask16, __m512, int);
extern __m256h __cdecl _mm512_maskz_cvtx_roundps_ph(__mmask16, __m512, int);


extern __m128h __cdecl _mm_cvtepi64_ph(__m128i);
extern __m128h __cdecl _mm_mask_cvtepi64_ph(__m128h, __mmask8, __m128i);
extern __m128h __cdecl _mm_maskz_cvtepi64_ph(__mmask8, __m128i);
extern __m128h __cdecl _mm256_cvtepi64_ph(__m256i);
extern __m128h __cdecl _mm256_mask_cvtepi64_ph(__m128h, __mmask8, __m256i);
extern __m128h __cdecl _mm256_maskz_cvtepi64_ph(__mmask8, __m256i);
extern __m128h __cdecl _mm512_cvtepi64_ph (__m512i);
extern __m128h __cdecl _mm512_mask_cvtepi64_ph (__m128h, __mmask8, __m512i);
extern __m128h __cdecl _mm512_maskz_cvtepi64_ph (__mmask8, __m512i);
extern __m128h __cdecl _mm512_cvt_roundepi64_ph(__m512i, int);
extern __m128h __cdecl _mm512_mask_cvt_roundepi64_ph(__m128h, __mmask8, __m512i, int);
extern __m128h __cdecl _mm512_maskz_cvt_roundepi64_ph(__mmask8, __m512i, int);


extern __m128h __cdecl _mm_cvtsd_sh(__m128h, __m128d);
extern __m128h __cdecl _mm_mask_cvtsd_sh(__m128h, __mmask8, __m128h, __m128d);
extern __m128h __cdecl _mm_maskz_cvtsd_sh(__mmask8, __m128h, __m128d);
extern __m128h __cdecl _mm_cvt_roundsd_sh(__m128h, __m128d, const int);
extern __m128h __cdecl _mm_mask_cvt_roundsd_sh(__m128h, __mmask8, __m128h, __m128d, const int);
extern __m128h __cdecl _mm_maskz_cvt_roundsd_sh(__mmask8, __m128h, __m128d, const int);


extern __m128d __cdecl _mm_cvtsh_sd(__m128d, __m128h);
extern __m128d __cdecl _mm_mask_cvtsh_sd(__m128d, __mmask8, __m128d, __m128h);
extern __m128d __cdecl _mm_maskz_cvtsh_sd(__mmask8, __m128d, __m128h);
extern __m128d __cdecl _mm_cvt_roundsh_sd(__m128d, __m128h, const int);
extern __m128d __cdecl _mm_mask_cvt_roundsh_sd(__m128d, __mmask8, __m128d, __m128h, const int);
extern __m128d __cdecl _mm_maskz_cvt_roundsh_sd(__mmask8, __m128d, __m128h, const int);


extern int __cdecl _mm_cvtsh_i32(__m128h);
extern __int64 __cdecl _mm_cvtsh_i64(__m128h);
extern int __cdecl _mm_cvt_roundsh_i32(__m128h, int);
extern __int64 __cdecl _mm_cvt_roundsh_i64(__m128h, int);


extern __m128 __cdecl _mm_cvtsh_ss(__m128, __m128h);
extern __m128 __cdecl _mm_mask_cvtsh_ss(__m128, __mmask8, __m128, __m128h);
extern __m128 __cdecl _mm_maskz_cvtsh_ss(__mmask8, __m128, __m128h);
extern __m128 __cdecl _mm_cvt_roundsh_ss(__m128, __m128h, const int);
extern __m128 __cdecl _mm_mask_cvt_roundsh_ss(__m128, __mmask8, __m128, __m128h, const int);
extern __m128 __cdecl _mm_maskz_cvt_roundsh_ss(__mmask8, __m128, __m128h, const int);


extern unsigned int __cdecl _mm_cvtsh_u32(__m128h);
extern unsigned __int64 __cdecl _mm_cvtsh_u64(__m128h);
extern unsigned int __cdecl _mm_cvt_roundsh_u32(__m128h, int);
extern unsigned __int64 __cdecl _mm_cvt_roundsh_u64(__m128h, int);


extern __m128h __cdecl _mm_cvti32_sh(__m128h, int);
extern __m128h __cdecl _mm_cvti64_sh(__m128h, __int64);
extern __m128h __cdecl _mm_cvt_roundi32_sh(__m128h, int, int);
extern __m128h __cdecl _mm_cvt_roundi64_sh(__m128h, __int64, int);


extern __m128h __cdecl _mm_cvtss_sh(__m128h, __m128, const int);
extern __m128h __cdecl _mm_mask_cvtss_sh(__m128h, __mmask8, __m128h, __m128, const int);
extern __m128h __cdecl _mm_maskz_cvtss_sh(__mmask8, __m128h, __m128, const int);
extern __m128h __cdecl _mm_cvt_roundss_sh(__m128h, __m128, const int);
extern __m128h __cdecl _mm_mask_cvt_roundss_sh(__m128h, __mmask8, __m128h, __m128, const int);
extern __m128h __cdecl _mm_maskz_cvt_roundss_sh(__mmask8, __m128h, __m128, const int);


extern __m128i __cdecl _mm_cvttph_epi32(__m128h);
extern __m128i __cdecl _mm_mask_cvttph_epi32(__m128i, __mmask8, __m128h);
extern __m128i __cdecl _mm_maskz_cvttph_epi32(__mmask8, __m128h);
extern __m256i __cdecl _mm256_cvttph_epi32(__m128h);
extern __m256i __cdecl _mm256_mask_cvttph_epi32(__m256i, __mmask8, __m128h);
extern __m256i __cdecl _mm256_maskz_cvttph_epi32(__mmask8, __m128h);
extern __m512i __cdecl _mm512_cvttph_epi32 (__m256h);
extern __m512i __cdecl _mm512_mask_cvttph_epi32 (__m512i, __mmask16, __m256h);
extern __m512i __cdecl _mm512_maskz_cvttph_epi32 (__mmask16, __m256h);
extern __m512i __cdecl _mm512_cvtt_roundph_epi32(__m256h, int);
extern __m512i __cdecl _mm512_mask_cvtt_roundph_epi32(__m512i, __mmask16, __m256h, int);
extern __m512i __cdecl _mm512_maskz_cvtt_roundph_epi32(__mmask16, __m256h, int);


extern __m128i __cdecl _mm_cvttph_epi64(__m128h);
extern __m128i __cdecl _mm_mask_cvttph_epi64(__m128i, __mmask8, __m128h);
extern __m128i __cdecl _mm_maskz_cvttph_epi64(__mmask8, __m128h);
extern __m256i __cdecl _mm256_cvttph_epi64(__m128h);
extern __m256i __cdecl _mm256_mask_cvttph_epi64(__m256i, __mmask8, __m128h);
extern __m256i __cdecl _mm256_maskz_cvttph_epi64(__mmask8, __m128h);
extern __m512i __cdecl _mm512_cvttph_epi64 (__m128h);
extern __m512i __cdecl _mm512_mask_cvttph_epi64 (__m512i, __mmask8, __m128h);
extern __m512i __cdecl _mm512_maskz_cvttph_epi64 (__mmask8, __m128h);
extern __m512i __cdecl _mm512_cvtt_roundph_epi64(__m128h, int);
extern __m512i __cdecl _mm512_mask_cvtt_roundph_epi64(__m512i, __mmask8, __m128h, int);
extern __m512i __cdecl _mm512_maskz_cvtt_roundph_epi64(__mmask8, __m128h, int);


extern __m128i __cdecl _mm_cvttph_epu32(__m128h);
extern __m128i __cdecl _mm_mask_cvttph_epu32(__m128i, __mmask8, __m128h);
extern __m128i __cdecl _mm_maskz_cvttph_epu32(__mmask8, __m128h);
extern __m256i __cdecl _mm256_cvttph_epu32(__m128h);
extern __m256i __cdecl _mm256_mask_cvttph_epu32(__m256i, __mmask8, __m128h);
extern __m256i __cdecl _mm256_maskz_cvttph_epu32(__mmask8, __m128h);
extern __m512i __cdecl _mm512_cvttph_epu32 (__m256h);
extern __m512i __cdecl _mm512_mask_cvttph_epu32 (__m512i, __mmask16, __m256h);
extern __m512i __cdecl _mm512_maskz_cvttph_epu32 (__mmask16, __m256h);
extern __m512i __cdecl _mm512_cvtt_roundph_epu32(__m256h, int);
extern __m512i __cdecl _mm512_mask_cvtt_roundph_epu32(__m512i, __mmask16, __m256h, int);
extern __m512i __cdecl _mm512_maskz_cvtt_roundph_epu32(__mmask16, __m256h, int);


extern __m128i __cdecl _mm_cvttph_epu64(__m128h);
extern __m128i __cdecl _mm_mask_cvttph_epu64(__m128i, __mmask8, __m128h);
extern __m128i __cdecl _mm_maskz_cvttph_epu64(__mmask8, __m128h);
extern __m256i __cdecl _mm256_cvttph_epu64(__m128h);
extern __m256i __cdecl _mm256_mask_cvttph_epu64(__m256i, __mmask8, __m128h);
extern __m256i __cdecl _mm256_maskz_cvttph_epu64(__mmask8, __m128h);
extern __m512i __cdecl _mm512_cvttph_epu64 (__m128h);
extern __m512i __cdecl _mm512_mask_cvttph_epu64 (__m512i, __mmask8, __m128h);
extern __m512i __cdecl _mm512_maskz_cvttph_epu64 (__mmask8, __m128h);
extern __m512i __cdecl _mm512_cvtt_roundph_epu64(__m128h, int);
extern __m512i __cdecl _mm512_mask_cvtt_roundph_epu64(__m512i, __mmask8, __m128h, int);
extern __m512i __cdecl _mm512_maskz_cvtt_roundph_epu64(__mmask8, __m128h, int);


extern __m128i __cdecl _mm_cvttph_epu16(__m128h);
extern __m128i __cdecl _mm_mask_cvttph_epu16(__m128i, __mmask8, __m128h);
extern __m128i __cdecl _mm_maskz_cvttph_epu16(__mmask8, __m128h);
extern __m256i __cdecl _mm256_cvttph_epu16(__m256h);
extern __m256i __cdecl _mm256_mask_cvttph_epu16(__m256i, __mmask16, __m256h);
extern __m256i __cdecl _mm256_maskz_cvttph_epu16(__mmask16, __m256h);
extern __m512i __cdecl _mm512_cvttph_epu16 (__m512h);
extern __m512i __cdecl _mm512_mask_cvttph_epu16 (__m512i, __mmask32, __m512h);
extern __m512i __cdecl _mm512_maskz_cvttph_epu16 (__mmask32, __m512h);
extern __m512i __cdecl _mm512_cvtt_roundph_epu16(__m512h, int);
extern __m512i __cdecl _mm512_mask_cvtt_roundph_epu16(__m512i, __mmask32, __m512h, int);
extern __m512i __cdecl _mm512_maskz_cvtt_roundph_epu16(__mmask32, __m512h, int);


extern __m128i __cdecl _mm_cvttph_epi16(__m128h);
extern __m128i __cdecl _mm_mask_cvttph_epi16(__m128i, __mmask8, __m128h);
extern __m128i __cdecl _mm_maskz_cvttph_epi16(__mmask8, __m128h);
extern __m256i __cdecl _mm256_cvttph_epi16(__m256h);
extern __m256i __cdecl _mm256_mask_cvttph_epi16(__m256i, __mmask16, __m256h);
extern __m256i __cdecl _mm256_maskz_cvttph_epi16(__mmask16, __m256h);
extern __m512i __cdecl _mm512_cvttph_epi16 (__m512h);
extern __m512i __cdecl _mm512_mask_cvttph_epi16 (__m512i, __mmask32, __m512h);
extern __m512i __cdecl _mm512_maskz_cvttph_epi16 (__mmask32, __m512h);
extern __m512i __cdecl _mm512_cvtt_roundph_epi16(__m512h, int);
extern __m512i __cdecl _mm512_mask_cvtt_roundph_epi16(__m512i, __mmask32, __m512h, int);
extern __m512i __cdecl _mm512_maskz_cvtt_roundph_epi16(__mmask32, __m512h, int);


extern int __cdecl _mm_cvttsh_i32(__m128h);
extern __int64 __cdecl _mm_cvttsh_i64(__m128h);
extern int __cdecl _mm_cvtt_roundsh_i32(__m128h, int);
extern __int64 __cdecl _mm_cvtt_roundsh_i64(__m128h, int);


extern unsigned int __cdecl _mm_cvttsh_u32(__m128h);
extern unsigned __int64 __cdecl _mm_cvttsh_u64(__m128h);
extern unsigned int __cdecl _mm_cvtt_roundsh_u32(__m128h, int);
extern unsigned __int64 __cdecl _mm_cvtt_roundsh_u64(__m128h, int);


extern __m128h __cdecl _mm_cvtepu32_ph(__m128i);
extern __m128h __cdecl _mm_mask_cvtepu32_ph(__m128h, __mmask8, __m128i);
extern __m128h __cdecl _mm_maskz_cvtepu32_ph(__mmask8, __m128i);
extern __m128h __cdecl _mm256_cvtepu32_ph(__m256i);
extern __m128h __cdecl _mm256_mask_cvtepu32_ph(__m128h, __mmask8, __m256i);
extern __m128h __cdecl _mm256_maskz_cvtepu32_ph(__mmask8, __m256i);
extern __m256h __cdecl _mm512_cvtepu32_ph (__m512i);
extern __m256h __cdecl _mm512_mask_cvtepu32_ph (__m256h, __mmask16, __m512i);
extern __m256h __cdecl _mm512_maskz_cvtepu32_ph (__mmask16, __m512i);
extern __m256h __cdecl _mm512_cvt_roundepu32_ph(__m512i, int);
extern __m256h __cdecl _mm512_mask_cvt_roundepu32_ph(__m256h, __mmask16, __m512i, int);
extern __m256h __cdecl _mm512_maskz_cvt_roundepu32_ph(__mmask16, __m512i, int);


extern __m128h __cdecl _mm_cvtepu64_ph(__m128i);
extern __m128h __cdecl _mm_mask_cvtepu64_ph(__m128h, __mmask8, __m128i);
extern __m128h __cdecl _mm_maskz_cvtepu64_ph(__mmask8, __m128i);
extern __m128h __cdecl _mm256_cvtepu64_ph(__m256i);
extern __m128h __cdecl _mm256_mask_cvtepu64_ph(__m128h, __mmask8, __m256i);
extern __m128h __cdecl _mm256_maskz_cvtepu64_ph(__mmask8, __m256i);
extern __m128h __cdecl _mm512_cvtepu64_ph (__m512i);
extern __m128h __cdecl _mm512_mask_cvtepu64_ph (__m128h, __mmask8, __m512i);
extern __m128h __cdecl _mm512_maskz_cvtepu64_ph (__mmask8, __m512i);
extern __m128h __cdecl _mm512_cvt_roundepu64_ph(__m512i, int);
extern __m128h __cdecl _mm512_mask_cvt_roundepu64_ph(__m128h, __mmask8, __m512i, int);
extern __m128h __cdecl _mm512_maskz_cvt_roundepu64_ph(__mmask8, __m512i, int);


extern __m128h __cdecl _mm_cvtu32_sh(__m128h, unsigned int);
extern __m128h __cdecl _mm_cvtu64_sh(__m128h, unsigned __int64);
extern __m128h __cdecl _mm_cvt_roundu32_sh(__m128h, unsigned int, int);
extern __m128h __cdecl _mm_cvt_roundu64_sh(__m128h, unsigned __int64, int);


extern __m128h __cdecl _mm_cvtepu16_ph(__m128i);
extern __m128h __cdecl _mm_mask_cvtepu16_ph(__m128h, __mmask8, __m128i);
extern __m128h __cdecl _mm_maskz_cvtepu16_ph(__mmask8, __m128i);
extern __m256h __cdecl _mm256_cvtepu16_ph(__m256i);
extern __m256h __cdecl _mm256_mask_cvtepu16_ph(__m256h, __mmask16, __m256i);
extern __m256h __cdecl _mm256_maskz_cvtepu16_ph(__mmask16, __m256i);
extern __m512h __cdecl _mm512_cvtepu16_ph (__m512i);
extern __m512h __cdecl _mm512_mask_cvtepu16_ph (__m512h, __mmask32, __m512i);
extern __m512h __cdecl _mm512_maskz_cvtepu16_ph (__mmask32, __m512i);
extern __m512h __cdecl _mm512_cvt_roundepu16_ph(__m512i, int);
extern __m512h __cdecl _mm512_mask_cvt_roundepu16_ph(__m512h, __mmask32, __m512i, int);
extern __m512h __cdecl _mm512_maskz_cvt_roundepu16_ph(__mmask32, __m512i, int);


extern __m128h __cdecl _mm_cvtepi16_ph(__m128i);
extern __m128h __cdecl _mm_mask_cvtepi16_ph(__m128h, __mmask8, __m128i);
extern __m128h __cdecl _mm_maskz_cvtepi16_ph(__mmask8, __m128i);
extern __m256h __cdecl _mm256_cvtepi16_ph(__m256i);
extern __m256h __cdecl _mm256_mask_cvtepi16_ph(__m256h, __mmask16, __m256i);
extern __m256h __cdecl _mm256_maskz_cvtepi16_ph(__mmask16, __m256i);
extern __m512h __cdecl _mm512_cvtepi16_ph (__m512i);
extern __m512h __cdecl _mm512_mask_cvtepi16_ph (__m512h, __mmask32, __m512i);
extern __m512h __cdecl _mm512_maskz_cvtepi16_ph (__mmask32, __m512i);
extern __m512h __cdecl _mm512_cvt_roundepi16_ph(__m512i, int);
extern __m512h __cdecl _mm512_mask_cvt_roundepi16_ph(__m512h, __mmask32, __m512i, int);
extern __m512h __cdecl _mm512_maskz_cvt_roundepi16_ph(__mmask32, __m512i, int);


extern __m128h __cdecl _mm_div_ph(__m128h, __m128h);
extern __m128h __cdecl _mm_mask_div_ph(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_maskz_div_ph(__mmask8, __m128h, __m128h);
extern __m256h __cdecl _mm256_div_ph(__m256h, __m256h);
extern __m256h __cdecl _mm256_mask_div_ph(__m256h, __mmask16, __m256h, __m256h);
extern __m256h __cdecl _mm256_maskz_div_ph(__mmask16, __m256h, __m256h);
extern __m512h __cdecl _mm512_div_ph(__m512h, __m512h);
extern __m512h __cdecl _mm512_mask_div_ph(__m512h, __mmask32, __m512h, __m512h);
extern __m512h __cdecl _mm512_maskz_div_ph(__mmask32, __m512h, __m512h);
extern __m512h __cdecl _mm512_div_round_ph(__m512h, __m512h, int);
extern __m512h __cdecl _mm512_mask_div_round_ph(__m512h, __mmask32, __m512h, __m512h, int);
extern __m512h __cdecl _mm512_maskz_div_round_ph(__mmask32, __m512h, __m512h, int);


extern __m128h __cdecl _mm_div_sh(__m128h, __m128h);
extern __m128h __cdecl _mm_mask_div_sh(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_maskz_div_sh(__mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_div_round_sh(__m128h, __m128h, int);
extern __m128h __cdecl _mm_mask_div_round_sh(__m128h, __mmask8, __m128h, __m128h, int);
extern __m128h __cdecl _mm_maskz_div_round_sh(__mmask8, __m128h, __m128h, int);


extern __m128h __cdecl _mm_fmaddsub_ph(__m128h, __m128h, __m128h);
extern __m128h __cdecl _mm_mask_fmaddsub_ph(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_mask3_fmaddsub_ph(__m128h, __m128h, __m128h, __mmask8);
extern __m128h __cdecl _mm_maskz_fmaddsub_ph(__mmask8, __m128h, __m128h, __m128h);
extern __m256h __cdecl _mm256_fmaddsub_ph(__m256h, __m256h, __m256h);
extern __m256h __cdecl _mm256_mask_fmaddsub_ph(__m256h, __mmask16, __m256h, __m256h);
extern __m256h __cdecl _mm256_mask3_fmaddsub_ph(__m256h, __m256h, __m256h, __mmask16);
extern __m256h __cdecl _mm256_maskz_fmaddsub_ph(__mmask16, __m256h, __m256h, __m256h);
extern __m512h __cdecl _mm512_fmaddsub_ph(__m512h, __m512h, __m512h);
extern __m512h __cdecl _mm512_mask_fmaddsub_ph(__m512h, __mmask32, __m512h, __m512h);
extern __m512h __cdecl _mm512_mask3_fmaddsub_ph(__m512h, __m512h, __m512h, __mmask32);
extern __m512h __cdecl _mm512_maskz_fmaddsub_ph(__mmask32, __m512h, __m512h, __m512h);
extern __m512h __cdecl _mm512_fmaddsub_round_ph(__m512h, __m512h, __m512h, const int);
extern __m512h __cdecl _mm512_mask_fmaddsub_round_ph(__m512h, __mmask32, __m512h, __m512h, const int);
extern __m512h __cdecl _mm512_mask3_fmaddsub_round_ph(__m512h, __m512h, __m512h, __mmask32, const int);
extern __m512h __cdecl _mm512_maskz_fmaddsub_round_ph(__mmask32, __m512h, __m512h, __m512h, const int);


extern __m128h __cdecl _mm_fmsubadd_ph(__m128h, __m128h, __m128h);
extern __m128h __cdecl _mm_mask_fmsubadd_ph(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_mask3_fmsubadd_ph(__m128h, __m128h, __m128h, __mmask8);
extern __m128h __cdecl _mm_maskz_fmsubadd_ph(__mmask8, __m128h, __m128h, __m128h);
extern __m256h __cdecl _mm256_fmsubadd_ph(__m256h, __m256h, __m256h);
extern __m256h __cdecl _mm256_mask_fmsubadd_ph(__m256h, __mmask16, __m256h, __m256h);
extern __m256h __cdecl _mm256_mask3_fmsubadd_ph(__m256h, __m256h, __m256h, __mmask16);
extern __m256h __cdecl _mm256_maskz_fmsubadd_ph(__mmask16, __m256h, __m256h, __m256h);
extern __m512h __cdecl _mm512_fmsubadd_ph(__m512h, __m512h, __m512h);
extern __m512h __cdecl _mm512_mask_fmsubadd_ph(__m512h, __mmask32, __m512h, __m512h);
extern __m512h __cdecl _mm512_mask3_fmsubadd_ph(__m512h, __m512h, __m512h, __mmask32);
extern __m512h __cdecl _mm512_maskz_fmsubadd_ph(__mmask32, __m512h, __m512h, __m512h);
extern __m512h __cdecl _mm512_fmsubadd_round_ph(__m512h, __m512h, __m512h, const int);
extern __m512h __cdecl _mm512_mask_fmsubadd_round_ph(__m512h, __mmask32, __m512h, __m512h, const int);
extern __m512h __cdecl _mm512_mask3_fmsubadd_round_ph(__m512h, __m512h, __m512h, __mmask32, const int);
extern __m512h __cdecl _mm512_maskz_fmsubadd_round_ph(__mmask32, __m512h, __m512h, __m512h, const int);


extern __mmask8 __cdecl _mm_fpclass_ph_mask(__m128h, int);
extern __mmask8 __cdecl _mm_mask_fpclass_ph_mask(__mmask8, __m128h, int);
extern __mmask16 __cdecl _mm256_fpclass_ph_mask(__m256h, int);
extern __mmask16 __cdecl _mm256_mask_fpclass_ph_mask(__mmask16, __m256h, int);
extern __mmask32 __cdecl _mm512_fpclass_ph_mask(__m512h, int);
extern __mmask32 __cdecl _mm512_mask_fpclass_ph_mask(__mmask32, __m512h, int);


extern __mmask8 __cdecl _mm_fpclass_sh_mask(__m128h, int);
extern __mmask8 __cdecl _mm_mask_fpclass_sh_mask(__mmask8, __m128h, int);


extern __m128h __cdecl _mm_fmadd_pch(__m128h, __m128h, __m128h);
extern __m128h __cdecl _mm_mask_fmadd_pch(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_mask3_fmadd_pch(__m128h, __m128h, __m128h, __mmask8);
extern __m128h __cdecl _mm_maskz_fmadd_pch(__mmask8, __m128h, __m128h, __m128h);
extern __m256h __cdecl _mm256_fmadd_pch(__m256h, __m256h, __m256h);
extern __m256h __cdecl _mm256_mask_fmadd_pch(__m256h, __mmask8, __m256h, __m256h);
extern __m256h __cdecl _mm256_mask3_fmadd_pch(__m256h, __m256h, __m256h, __mmask8);
extern __m256h __cdecl _mm256_maskz_fmadd_pch(__mmask8, __m256h, __m256h, __m256h);
extern __m512h __cdecl _mm512_fmadd_pch(__m512h, __m512h, __m512h);
extern __m512h __cdecl _mm512_mask_fmadd_pch(__m512h, __mmask16, __m512h, __m512h);
extern __m512h __cdecl _mm512_mask3_fmadd_pch(__m512h, __m512h, __m512h, __mmask16);
extern __m512h __cdecl _mm512_maskz_fmadd_pch(__mmask16, __m512h, __m512h, __m512h);
extern __m512h __cdecl _mm512_fmadd_round_pch(__m512h, __m512h, __m512h, const int);
extern __m512h __cdecl _mm512_mask_fmadd_round_pch(__m512h, __mmask16, __m512h, __m512h, const int);
extern __m512h __cdecl _mm512_mask3_fmadd_round_pch(__m512h, __m512h, __m512h, __mmask16, const int);
extern __m512h __cdecl _mm512_maskz_fmadd_round_pch(__mmask16, __m512h, __m512h, __m512h, const int);
extern __m128h __cdecl _mm_fcmadd_pch(__m128h, __m128h, __m128h);
extern __m128h __cdecl _mm_mask_fcmadd_pch(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_mask3_fcmadd_pch(__m128h, __m128h, __m128h, __mmask8);
extern __m128h __cdecl _mm_maskz_fcmadd_pch(__mmask8, __m128h, __m128h, __m128h);
extern __m256h __cdecl _mm256_fcmadd_pch(__m256h, __m256h, __m256h);
extern __m256h __cdecl _mm256_mask_fcmadd_pch(__m256h, __mmask8, __m256h, __m256h);
extern __m256h __cdecl _mm256_mask3_fcmadd_pch(__m256h, __m256h, __m256h, __mmask8);
extern __m256h __cdecl _mm256_maskz_fcmadd_pch(__mmask8, __m256h, __m256h, __m256h);
extern __m512h __cdecl _mm512_fcmadd_pch(__m512h, __m512h, __m512h);
extern __m512h __cdecl _mm512_mask_fcmadd_pch(__m512h, __mmask16, __m512h, __m512h);
extern __m512h __cdecl _mm512_mask3_fcmadd_pch(__m512h, __m512h, __m512h, __mmask16);
extern __m512h __cdecl _mm512_maskz_fcmadd_pch(__mmask16, __m512h, __m512h, __m512h);
extern __m512h __cdecl _mm512_fcmadd_round_pch(__m512h, __m512h, __m512h, const int);
extern __m512h __cdecl _mm512_mask_fcmadd_round_pch(__m512h, __mmask16, __m512h, __m512h, const int);
extern __m512h __cdecl _mm512_mask3_fcmadd_round_pch(__m512h, __m512h, __m512h, __mmask16, const int);
extern __m512h __cdecl _mm512_maskz_fcmadd_round_pch(__mmask16, __m512h, __m512h, __m512h, const int);


extern __m128h __cdecl _mm_fcmadd_sch(__m128h, __m128h, __m128h);
extern __m128h __cdecl _mm_mask_fcmadd_sch(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_mask3_fcmadd_sch(__m128h, __m128h, __m128h, __mmask8);
extern __m128h __cdecl _mm_maskz_fcmadd_sch(__mmask8, __m128h, __m128h, __m128h);
extern __m128h __cdecl _mm_fcmadd_round_sch(__m128h, __m128h, __m128h, const int);
extern __m128h __cdecl _mm_mask_fcmadd_round_sch(__m128h, __mmask8, __m128h, __m128h, const int);
extern __m128h __cdecl _mm_mask3_fcmadd_round_sch(__m128h, __m128h, __m128h, __mmask8, const int);
extern __m128h __cdecl _mm_maskz_fcmadd_round_sch(__mmask8, __m128h, __m128h, __m128h, const int);
extern __m128h __cdecl _mm_fmadd_sch(__m128h, __m128h, __m128h);
extern __m128h __cdecl _mm_mask_fmadd_sch(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_maskz_fmadd_sch(__mmask8, __m128h, __m128h, __m128h);
extern __m128h __cdecl _mm_fmadd_round_sch(__m128h, __m128h, __m128h, const int);
extern __m128h __cdecl _mm_mask_fmadd_round_sch(__m128h, __mmask8, __m128h, __m128h, const int);
extern __m128h __cdecl _mm_maskz_fmadd_round_sch(__mmask8, __m128h, __m128h, __m128h, const int);


extern __m128h __cdecl _mm_fcmul_pch(__m128h, __m128h);
extern __m128h __cdecl _mm_mask_fcmul_pch(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_maskz_fcmul_pch(__mmask8, __m128h, __m128h);
extern __m256h __cdecl _mm256_fcmul_pch(__m256h, __m256h);
extern __m256h __cdecl _mm256_mask_fcmul_pch(__m256h, __mmask8, __m256h, __m256h);
extern __m256h __cdecl _mm256_maskz_fcmul_pch(__mmask8, __m256h, __m256h);
extern __m512h __cdecl _mm512_fcmul_pch(__m512h, __m512h);
extern __m512h __cdecl _mm512_mask_fcmul_pch(__m512h, __mmask16, __m512h, __m512h);
extern __m512h __cdecl _mm512_maskz_fcmul_pch(__mmask16, __m512h, __m512h);
extern __m512h __cdecl _mm512_fcmul_round_pch(__m512h, __m512h, const int);
extern __m512h __cdecl _mm512_mask_fcmul_round_pch(__m512h, __mmask16, __m512h, __m512h, const int);
extern __m512h __cdecl _mm512_maskz_fcmul_round_pch(__mmask16, __m512h, __m512h, const int);
extern __m128h __cdecl _mm_fmul_pch(__m128h, __m128h);
extern __m128h __cdecl _mm_mask_fmul_pch(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_maskz_fmul_pch(__mmask8, __m128h, __m128h);
extern __m256h __cdecl _mm256_fmul_pch(__m256h, __m256h);
extern __m256h __cdecl _mm256_mask_fmul_pch(__m256h, __mmask8, __m256h, __m256h);
extern __m256h __cdecl _mm256_maskz_fmul_pch(__mmask8, __m256h, __m256h);
extern __m512h __cdecl _mm512_fmul_pch(__m512h, __m512h);
extern __m512h __cdecl _mm512_mask_fmul_pch(__m512h, __mmask16, __m512h, __m512h);
extern __m512h __cdecl _mm512_maskz_fmul_pch(__mmask16, __m512h, __m512h);
extern __m512h __cdecl _mm512_fmul_round_pch(__m512h, __m512h, const int);
extern __m512h __cdecl _mm512_mask_fmul_round_pch(__m512h, __mmask16, __m512h, __m512h, const int);
extern __m512h __cdecl _mm512_maskz_fmul_round_pch(__mmask16, __m512h, __m512h, const int);


extern __m128h __cdecl _mm_fcmul_sch(__m128h, __m128h);
extern __m128h __cdecl _mm_mask_fcmul_sch(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_maskz_fcmul_sch(__mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_fcmul_round_sch(__m128h, __m128h, const int);
extern __m128h __cdecl _mm_mask_fcmul_round_sch(__m128h, __mmask8, __m128h, __m128h, const int);
extern __m128h __cdecl _mm_maskz_fcmul_round_sch(__mmask8, __m128h, __m128h, const int);
extern __m128h __cdecl _mm_fmul_sch(__m128h, __m128h);
extern __m128h __cdecl _mm_mask_fmul_sch(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_maskz_fmul_sch(__mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_fmul_round_sch(__m128h, __m128h, const int);
extern __m128h __cdecl _mm_mask_fmul_round_sch(__m128h, __mmask8, __m128h, __m128h, const int);
extern __m128h __cdecl _mm_maskz_fmul_round_sch(__mmask8, __m128h, __m128h, const int);


extern __m128h __cdecl _mm_fnmadd_ph(__m128h, __m128h, __m128h);
extern __m128h __cdecl _mm_mask_fnmadd_ph(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_mask3_fnmadd_ph(__m128h, __m128h, __m128h, __mmask8);
extern __m128h __cdecl _mm_maskz_fnmadd_ph(__mmask8, __m128h, __m128h, __m128h);
extern __m256h __cdecl _mm256_fnmadd_ph(__m256h, __m256h, __m256h);
extern __m256h __cdecl _mm256_mask_fnmadd_ph(__m256h, __mmask16, __m256h, __m256h);
extern __m256h __cdecl _mm256_mask3_fnmadd_ph(__m256h, __m256h, __m256h, __mmask16);
extern __m256h __cdecl _mm256_maskz_fnmadd_ph(__mmask16, __m256h, __m256h, __m256h);
extern __m512h __cdecl _mm512_fnmadd_ph(__m512h, __m512h, __m512h);
extern __m512h __cdecl _mm512_mask_fnmadd_ph(__m512h, __mmask32, __m512h, __m512h);
extern __m512h __cdecl _mm512_mask3_fnmadd_ph(__m512h, __m512h, __m512h, __mmask32);
extern __m512h __cdecl _mm512_maskz_fnmadd_ph(__mmask32, __m512h, __m512h, __m512h);
extern __m512h __cdecl _mm512_fnmadd_round_ph(__m512h, __m512h, __m512h, const int);
extern __m512h __cdecl _mm512_mask_fnmadd_round_ph(__m512h, __mmask32, __m512h, __m512h, const int);
extern __m512h __cdecl _mm512_mask3_fnmadd_round_ph(__m512h, __m512h, __m512h, __mmask32, const int);
extern __m512h __cdecl _mm512_maskz_fnmadd_round_ph(__mmask32, __m512h, __m512h, __m512h, const int);
extern __m128h __cdecl _mm_fmadd_ph(__m128h, __m128h, __m128h);
extern __m128h __cdecl _mm_mask_fmadd_ph(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_mask3_fmadd_ph(__m128h, __m128h, __m128h, __mmask8);
extern __m128h __cdecl _mm_maskz_fmadd_ph(__mmask8, __m128h, __m128h, __m128h);
extern __m256h __cdecl _mm256_fmadd_ph(__m256h, __m256h, __m256h);
extern __m256h __cdecl _mm256_mask_fmadd_ph(__m256h, __mmask16, __m256h, __m256h);
extern __m256h __cdecl _mm256_mask3_fmadd_ph(__m256h, __m256h, __m256h, __mmask16);
extern __m256h __cdecl _mm256_maskz_fmadd_ph(__mmask16, __m256h, __m256h, __m256h);
extern __m512h __cdecl _mm512_fmadd_ph(__m512h, __m512h, __m512h);
extern __m512h __cdecl _mm512_mask_fmadd_ph(__m512h, __mmask32, __m512h, __m512h);
extern __m512h __cdecl _mm512_mask3_fmadd_ph(__m512h, __m512h, __m512h, __mmask32);
extern __m512h __cdecl _mm512_maskz_fmadd_ph(__mmask32, __m512h, __m512h, __m512h);
extern __m512h __cdecl _mm512_fmadd_round_ph(__m512h, __m512h, __m512h, const int);
extern __m512h __cdecl _mm512_mask_fmadd_round_ph(__m512h, __mmask32, __m512h, __m512h, const int);
extern __m512h __cdecl _mm512_mask3_fmadd_round_ph(__m512h, __m512h, __m512h, __mmask32, const int);
extern __m512h __cdecl _mm512_maskz_fmadd_round_ph(__mmask32, __m512h, __m512h, __m512h, const int);


extern __m128h __cdecl _mm_fnmadd_sh(__m128h, __m128h, __m128h);
extern __m128h __cdecl _mm_mask_fnmadd_sh(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_mask3_fnmadd_sh(__m128h, __m128h, __m128h, __mmask8);
extern __m128h __cdecl _mm_maskz_fnmadd_sh(__mmask8, __m128h, __m128h, __m128h);
extern __m128h __cdecl _mm_fnmadd_round_sh(__m128h, __m128h, __m128h, const int);
extern __m128h __cdecl _mm_mask_fnmadd_round_sh(__m128h, __mmask8, __m128h, __m128h, const int);
extern __m128h __cdecl _mm_mask3_fnmadd_round_sh(__m128h, __m128h, __m128h, __mmask8, const int);
extern __m128h __cdecl _mm_maskz_fnmadd_round_sh(__mmask8, __m128h, __m128h, __m128h, const int);
extern __m128h __cdecl _mm_fmadd_sh(__m128h, __m128h, __m128h);
extern __m128h __cdecl _mm_mask_fmadd_sh(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_mask3_fmadd_sh(__m128h, __m128h, __m128h, __mmask8);
extern __m128h __cdecl _mm_maskz_fmadd_sh(__mmask8, __m128h, __m128h, __m128h);
extern __m128h __cdecl _mm_fmadd_round_sh(__m128h, __m128h, __m128h, const int);
extern __m128h __cdecl _mm_mask_fmadd_round_sh(__m128h, __mmask8, __m128h, __m128h, const int);
extern __m128h __cdecl _mm_mask3_fmadd_round_sh(__m128h, __m128h, __m128h, __mmask8, const int);
extern __m128h __cdecl _mm_maskz_fmadd_round_sh(__mmask8, __m128h, __m128h, __m128h, const int);


extern __m128h __cdecl _mm_fnmsub_ph(__m128h, __m128h, __m128h);
extern __m128h __cdecl _mm_mask_fnmsub_ph(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_mask3_fnmsub_ph(__m128h, __m128h, __m128h, __mmask8);
extern __m128h __cdecl _mm_maskz_fnmsub_ph(__mmask8, __m128h, __m128h, __m128h);
extern __m256h __cdecl _mm256_fnmsub_ph(__m256h, __m256h, __m256h);
extern __m256h __cdecl _mm256_mask_fnmsub_ph(__m256h, __mmask16, __m256h, __m256h);
extern __m256h __cdecl _mm256_mask3_fnmsub_ph(__m256h, __m256h, __m256h, __mmask16);
extern __m256h __cdecl _mm256_maskz_fnmsub_ph(__mmask16, __m256h, __m256h, __m256h);
extern __m512h __cdecl _mm512_fnmsub_ph(__m512h, __m512h, __m512h);
extern __m512h __cdecl _mm512_mask_fnmsub_ph(__m512h, __mmask32, __m512h, __m512h);
extern __m512h __cdecl _mm512_mask3_fnmsub_ph(__m512h, __m512h, __m512h, __mmask32);
extern __m512h __cdecl _mm512_maskz_fnmsub_ph(__mmask32, __m512h, __m512h, __m512h);
extern __m512h __cdecl _mm512_fnmsub_round_ph(__m512h, __m512h, __m512h, const int);
extern __m512h __cdecl _mm512_mask_fnmsub_round_ph(__m512h, __mmask32, __m512h, __m512h, const int);
extern __m512h __cdecl _mm512_mask3_fnmsub_round_ph(__m512h, __m512h, __m512h, __mmask32, const int);
extern __m512h __cdecl _mm512_maskz_fnmsub_round_ph(__mmask32, __m512h, __m512h, __m512h, const int);
extern __m128h __cdecl _mm_fmsub_ph(__m128h, __m128h, __m128h);
extern __m128h __cdecl _mm_mask_fmsub_ph(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_mask3_fmsub_ph(__m128h, __m128h, __m128h, __mmask8);
extern __m128h __cdecl _mm_maskz_fmsub_ph(__mmask8, __m128h, __m128h, __m128h);
extern __m256h __cdecl _mm256_fmsub_ph(__m256h, __m256h, __m256h);
extern __m256h __cdecl _mm256_mask_fmsub_ph(__m256h, __mmask16, __m256h, __m256h);
extern __m256h __cdecl _mm256_mask3_fmsub_ph(__m256h, __m256h, __m256h, __mmask16);
extern __m256h __cdecl _mm256_maskz_fmsub_ph(__mmask16, __m256h, __m256h, __m256h);
extern __m512h __cdecl _mm512_fmsub_ph(__m512h, __m512h, __m512h);
extern __m512h __cdecl _mm512_mask_fmsub_ph(__m512h, __mmask32, __m512h, __m512h);
extern __m512h __cdecl _mm512_mask3_fmsub_ph(__m512h, __m512h, __m512h, __mmask32);
extern __m512h __cdecl _mm512_maskz_fmsub_ph(__mmask32, __m512h, __m512h, __m512h);
extern __m512h __cdecl _mm512_fmsub_round_ph(__m512h, __m512h, __m512h, const int);
extern __m512h __cdecl _mm512_mask_fmsub_round_ph(__m512h, __mmask32, __m512h, __m512h, const int);
extern __m512h __cdecl _mm512_mask3_fmsub_round_ph(__m512h, __m512h, __m512h, __mmask32, const int);
extern __m512h __cdecl _mm512_maskz_fmsub_round_ph(__mmask32, __m512h, __m512h, __m512h, const int);


extern __m128h __cdecl _mm_fnmsub_sh(__m128h, __m128h, __m128h);
extern __m128h __cdecl _mm_mask_fnmsub_sh(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_mask3_fnmsub_sh(__m128h, __m128h, __m128h, __mmask8);
extern __m128h __cdecl _mm_maskz_fnmsub_sh(__mmask8, __m128h, __m128h, __m128h);
extern __m128h __cdecl _mm_fnmsub_round_sh(__m128h, __m128h, __m128h, const int);
extern __m128h __cdecl _mm_mask_fnmsub_round_sh(__m128h, __mmask8, __m128h, __m128h, const int);
extern __m128h __cdecl _mm_mask3_fnmsub_round_sh(__m128h, __m128h, __m128h, __mmask8, const int);
extern __m128h __cdecl _mm_maskz_fnmsub_round_sh(__mmask8, __m128h, __m128h, __m128h, const int);
extern __m128h __cdecl _mm_fmsub_sh(__m128h, __m128h, __m128h);
extern __m128h __cdecl _mm_mask_fmsub_sh(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_mask3_fmsub_sh(__m128h, __m128h, __m128h, __mmask8);
extern __m128h __cdecl _mm_maskz_fmsub_sh(__mmask8, __m128h, __m128h, __m128h);
extern __m128h __cdecl _mm_fmsub_round_sh(__m128h, __m128h, __m128h, const int);
extern __m128h __cdecl _mm_mask_fmsub_round_sh(__m128h, __mmask8, __m128h, __m128h, const int);
extern __m128h __cdecl _mm_mask3_fmsub_round_sh(__m128h, __m128h, __m128h, __mmask8, const int);
extern __m128h __cdecl _mm_maskz_fmsub_round_sh(__mmask8, __m128h, __m128h, __m128h, const int);


extern __m128h __cdecl _mm_getexp_ph(__m128h);
extern __m128h __cdecl _mm_mask_getexp_ph(__m128h, __mmask8, __m128h);
extern __m128h __cdecl _mm_maskz_getexp_ph(__mmask8, __m128h);
extern __m256h __cdecl _mm256_getexp_ph(__m256h);
extern __m256h __cdecl _mm256_mask_getexp_ph(__m256h, __mmask16, __m256h);
extern __m256h __cdecl _mm256_maskz_getexp_ph(__mmask16, __m256h);
extern __m512h __cdecl _mm512_getexp_ph(__m512h);
extern __m512h __cdecl _mm512_mask_getexp_ph(__m512h, __mmask32, __m512h);
extern __m512h __cdecl _mm512_maskz_getexp_ph(__mmask32, __m512h);
extern __m512h __cdecl _mm512_getexp_round_ph(__m512h, const int);
extern __m512h __cdecl _mm512_mask_getexp_round_ph(__m512h, __mmask32, __m512h, const int);
extern __m512h __cdecl _mm512_maskz_getexp_round_ph(__mmask32, __m512h, const int);


extern __m128h __cdecl _mm_getexp_sh(__m128h, __m128h);
extern __m128h __cdecl _mm_mask_getexp_sh(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_maskz_getexp_sh(__mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_getexp_round_sh(__m128h, __m128h, const int);
extern __m128h __cdecl _mm_mask_getexp_round_sh(__m128h, __mmask8, __m128h, __m128h, const int);
extern __m128h __cdecl _mm_maskz_getexp_round_sh(__mmask8, __m128h, __m128h, const int);


extern __m128h __cdecl _mm_getmant_ph(__m128h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM);
extern __m128h __cdecl _mm_mask_getmant_ph(__m128h, __mmask8, __m128h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM);
extern __m128h __cdecl _mm_maskz_getmant_ph(__mmask8, __m128h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM);
extern __m256h __cdecl _mm256_getmant_ph(__m256h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM);
extern __m256h __cdecl _mm256_mask_getmant_ph(__m256h, __mmask16, __m256h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM);
extern __m256h __cdecl _mm256_maskz_getmant_ph(__mmask16, __m256h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM);
extern __m512h __cdecl _mm512_getmant_ph(__m512h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM);
extern __m512h __cdecl _mm512_mask_getmant_ph(__m512h, __mmask32, __m512h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM);
extern __m512h __cdecl _mm512_maskz_getmant_ph(__mmask32, __m512h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM);
extern __m512h __cdecl _mm512_getmant_round_ph(__m512h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM, const int);
extern __m512h __cdecl _mm512_mask_getmant_round_ph(__m512h, __mmask32, __m512h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM, const int);
extern __m512h __cdecl _mm512_maskz_getmant_round_ph(__mmask32, __m512h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM, const int);


extern __m128h __cdecl _mm_getmant_sh(__m128h, __m128h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM);
extern __m128h __cdecl _mm_mask_getmant_sh(__m128h, __mmask8, __m128h, __m128h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM);
extern __m128h __cdecl _mm_maskz_getmant_sh(__mmask8, __m128h, __m128h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM);
extern __m128h __cdecl _mm_getmant_round_sh(__m128h, __m128h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM, const int);
extern __m128h __cdecl _mm_mask_getmant_round_sh(__m128h, __mmask8, __m128h, __m128h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM, const int);
extern __m128h __cdecl _mm_maskz_getmant_round_sh(__mmask8, __m128h, __m128h, _MM_MANTISSA_NORM_ENUM, _MM_MANTISSA_SIGN_ENUM, const int);


extern __m128h __cdecl _mm_max_ph(__m128h, __m128h);
extern __m128h __cdecl _mm_mask_max_ph(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_maskz_max_ph(__mmask8, __m128h, __m128h);
extern __m256h __cdecl _mm256_max_ph(__m256h, __m256h);
extern __m256h __cdecl _mm256_mask_max_ph(__m256h, __mmask16, __m256h, __m256h);
extern __m256h __cdecl _mm256_maskz_max_ph(__mmask16, __m256h, __m256h);
extern __m512h __cdecl _mm512_max_ph(__m512h, __m512h);
extern __m512h __cdecl _mm512_mask_max_ph(__m512h, __mmask32, __m512h, __m512h);
extern __m512h __cdecl _mm512_maskz_max_ph(__mmask32, __m512h, __m512h);
extern __m512h __cdecl _mm512_max_round_ph(__m512h, __m512h, int);
extern __m512h __cdecl _mm512_mask_max_round_ph(__m512h, __mmask32, __m512h, __m512h, int);
extern __m512h __cdecl _mm512_maskz_max_round_ph(__mmask32, __m512h, __m512h, int);


extern __m128h __cdecl _mm_max_sh(__m128h, __m128h);
extern __m128h __cdecl _mm_mask_max_sh(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_maskz_max_sh(__mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_max_round_sh(__m128h, __m128h, int);
extern __m128h __cdecl _mm_mask_max_round_sh(__m128h, __mmask8, __m128h, __m128h, int);
extern __m128h __cdecl _mm_maskz_max_round_sh(__mmask8, __m128h, __m128h, int);


extern __m128h __cdecl _mm_min_ph(__m128h, __m128h);
extern __m128h __cdecl _mm_mask_min_ph(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_maskz_min_ph(__mmask8, __m128h, __m128h);
extern __m256h __cdecl _mm256_min_ph(__m256h, __m256h);
extern __m256h __cdecl _mm256_mask_min_ph(__m256h, __mmask16, __m256h, __m256h);
extern __m256h __cdecl _mm256_maskz_min_ph(__mmask16, __m256h, __m256h);
extern __m512h __cdecl _mm512_min_ph(__m512h, __m512h);
extern __m512h __cdecl _mm512_mask_min_ph(__m512h, __mmask32, __m512h, __m512h);
extern __m512h __cdecl _mm512_maskz_min_ph(__mmask32, __m512h, __m512h);
extern __m512h __cdecl _mm512_min_round_ph(__m512h, __m512h, int);
extern __m512h __cdecl _mm512_mask_min_round_ph(__m512h, __mmask32, __m512h, __m512h, int);
extern __m512h __cdecl _mm512_maskz_min_round_ph(__mmask32, __m512h, __m512h, int);


extern __m128h __cdecl _mm_min_sh(__m128h, __m128h);
extern __m128h __cdecl _mm_mask_min_sh(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_maskz_min_sh(__mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_min_round_sh(__m128h, __m128h, int);
extern __m128h __cdecl _mm_mask_min_round_sh(__m128h, __mmask8, __m128h, __m128h, int);
extern __m128h __cdecl _mm_maskz_min_round_sh(__mmask8, __m128h, __m128h, int);


extern __m128h __cdecl _mm_load_sh(void const*);
extern __m128h __cdecl _mm_mask_load_sh(__m128h, __mmask8, void const*);
extern __m128h __cdecl _mm_maskz_load_sh(__mmask8, void const*);
extern void __cdecl _mm_store_sh(void*, __m128h);
extern void __cdecl _mm_mask_store_sh(void*, __mmask8, __m128h);
extern __m128h __cdecl _mm_move_sh(__m128h, __m128h);
extern __m128h __cdecl _mm_mask_move_sh(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_maskz_move_sh(__mmask8, __m128h, __m128h);


extern __m128i __cdecl _mm_cvtsi16_si128(short);
extern short __cdecl _mm_cvtsi128_si16(__m128i);


extern __m128h __cdecl _mm_mul_ph(__m128h, __m128h);
extern __m128h __cdecl _mm_mask_mul_ph(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_maskz_mul_ph(__mmask8, __m128h, __m128h);
extern __m256h __cdecl _mm256_mul_ph(__m256h, __m256h);
extern __m256h __cdecl _mm256_mask_mul_ph(__m256h, __mmask16, __m256h, __m256h);
extern __m256h __cdecl _mm256_maskz_mul_ph(__mmask16, __m256h, __m256h);
extern __m512h __cdecl _mm512_mul_ph(__m512h, __m512h);
extern __m512h __cdecl _mm512_mask_mul_ph(__m512h, __mmask32, __m512h, __m512h);
extern __m512h __cdecl _mm512_maskz_mul_ph(__mmask32, __m512h, __m512h);
extern __m512h __cdecl _mm512_mul_round_ph(__m512h, __m512h, int);
extern __m512h __cdecl _mm512_mask_mul_round_ph(__m512h, __mmask32, __m512h, __m512h, int);
extern __m512h __cdecl _mm512_maskz_mul_round_ph(__mmask32, __m512h, __m512h, int);


extern __m128h __cdecl _mm_mul_sh(__m128h, __m128h);
extern __m128h __cdecl _mm_mask_mul_sh(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_maskz_mul_sh(__mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_mul_round_sh(__m128h, __m128h, int);
extern __m128h __cdecl _mm_mask_mul_round_sh(__m128h, __mmask8, __m128h, __m128h, int);
extern __m128h __cdecl _mm_maskz_mul_round_sh(__mmask8, __m128h, __m128h, int);


extern __m128h __cdecl _mm_rcp_ph(__m128h);
extern __m128h __cdecl _mm_mask_rcp_ph(__m128h, __mmask8, __m128h);
extern __m128h __cdecl _mm_maskz_rcp_ph(__mmask8, __m128h);
extern __m256h __cdecl _mm256_rcp_ph(__m256h);
extern __m256h __cdecl _mm256_mask_rcp_ph(__m256h, __mmask16, __m256h);
extern __m256h __cdecl _mm256_maskz_rcp_ph(__mmask16, __m256h);
extern __m512h __cdecl _mm512_rcp_ph(__m512h);
extern __m512h __cdecl _mm512_mask_rcp_ph(__m512h, __mmask32, __m512h);
extern __m512h __cdecl _mm512_maskz_rcp_ph(__mmask32, __m512h);


extern __m128h __cdecl _mm_rcp_sh(__m128h, __m128h);
extern __m128h __cdecl _mm_mask_rcp_sh(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_maskz_rcp_sh(__mmask8, __m128h, __m128h);


extern __m128h __cdecl _mm_reduce_ph(__m128h, int);
extern __m128h __cdecl _mm_mask_reduce_ph(__m128h, __mmask8, __m128h, int);
extern __m128h __cdecl _mm_maskz_reduce_ph(__mmask8, __m128h, int);
extern __m256h __cdecl _mm256_reduce_ph(__m256h, int);
extern __m256h __cdecl _mm256_mask_reduce_ph(__m256h, __mmask16, __m256h, int);
extern __m256h __cdecl _mm256_maskz_reduce_ph(__mmask16, __m256h, int);
extern __m512h __cdecl _mm512_reduce_ph(__m512h, int);
extern __m512h __cdecl _mm512_mask_reduce_ph(__m512h, __mmask32, __m512h, int);
extern __m512h __cdecl _mm512_maskz_reduce_ph(__mmask32, __m512h, int);
extern __m512h __cdecl _mm512_reduce_round_ph(__m512h, int, const int);
extern __m512h __cdecl _mm512_mask_reduce_round_ph(__m512h, __mmask32, __m512h, int, const int);
extern __m512h __cdecl _mm512_maskz_reduce_round_ph(__mmask32, __m512h, int, const int);


extern __m128h __cdecl _mm_reduce_sh(__m128h, __m128h, int);
extern __m128h __cdecl _mm_mask_reduce_sh(__m128h, __mmask8, __m128h, __m128h, int);
extern __m128h __cdecl _mm_maskz_reduce_sh(__mmask8, __m128h, __m128h, int);
extern __m128h __cdecl _mm_reduce_round_sh(__m128h, __m128h, int, const int);
extern __m128h __cdecl _mm_mask_reduce_round_sh(__m128h, __mmask8, __m128h, __m128h, int, const int);
extern __m128h __cdecl _mm_maskz_reduce_round_sh(__mmask8, __m128h, __m128h, int, const int);


extern __m128h __cdecl _mm_roundscale_ph(__m128h, int);
extern __m128h __cdecl _mm_mask_roundscale_ph(__m128h, __mmask8, __m128h, int);
extern __m128h __cdecl _mm_maskz_roundscale_ph(__mmask8, __m128h, int);
extern __m256h __cdecl _mm256_roundscale_ph(__m256h, int);
extern __m256h __cdecl _mm256_mask_roundscale_ph(__m256h, __mmask16, __m256h, int);
extern __m256h __cdecl _mm256_maskz_roundscale_ph(__mmask16, __m256h, int);
extern __m512h __cdecl _mm512_roundscale_ph(__m512h, int);
extern __m512h __cdecl _mm512_mask_roundscale_ph(__m512h, __mmask32, __m512h, int);
extern __m512h __cdecl _mm512_maskz_roundscale_ph(__mmask32, __m512h, int);
extern __m512h __cdecl _mm512_roundscale_round_ph(__m512h, int, const int);
extern __m512h __cdecl _mm512_mask_roundscale_round_ph(__m512h, __mmask32, __m512h, int, const int);
extern __m512h __cdecl _mm512_maskz_roundscale_round_ph(__mmask32, __m512h, int, const int);


extern __m128h __cdecl _mm_roundscale_sh(__m128h, __m128h, int);
extern __m128h __cdecl _mm_mask_roundscale_sh(__m128h, __mmask8, __m128h, __m128h, int);
extern __m128h __cdecl _mm_maskz_roundscale_sh(__mmask8, __m128h, __m128h, int);
extern __m128h __cdecl _mm_roundscale_round_sh(__m128h, __m128h, int, const int);
extern __m128h __cdecl _mm_mask_roundscale_round_sh(__m128h, __mmask8, __m128h, __m128h, int, const int);
extern __m128h __cdecl _mm_maskz_roundscale_round_sh(__mmask8, __m128h, __m128h, int, const int);


extern __m128h __cdecl _mm_rsqrt_ph(__m128h);
extern __m128h __cdecl _mm_mask_rsqrt_ph(__m128h, __mmask8, __m128h);
extern __m128h __cdecl _mm_maskz_rsqrt_ph(__mmask8, __m128h);
extern __m256h __cdecl _mm256_rsqrt_ph(__m256h);
extern __m256h __cdecl _mm256_mask_rsqrt_ph(__m256h, __mmask16, __m256h);
extern __m256h __cdecl _mm256_maskz_rsqrt_ph(__mmask16, __m256h);
extern __m512h __cdecl _mm512_rsqrt_ph(__m512h);
extern __m512h __cdecl _mm512_mask_rsqrt_ph(__m512h, __mmask32, __m512h);
extern __m512h __cdecl _mm512_maskz_rsqrt_ph(__mmask32, __m512h);


extern __m128h __cdecl _mm_rsqrt_sh(__m128h, __m128h);
extern __m128h __cdecl _mm_mask_rsqrt_sh(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_maskz_rsqrt_sh(__mmask8, __m128h, __m128h);


extern __m128h __cdecl _mm_scalef_ph(__m128h, __m128h);
extern __m128h __cdecl _mm_mask_scalef_ph(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_maskz_scalef_ph(__mmask8, __m128h, __m128h);
extern __m256h __cdecl _mm256_scalef_ph(__m256h, __m256h);
extern __m256h __cdecl _mm256_mask_scalef_ph(__m256h, __mmask16, __m256h, __m256h);
extern __m256h __cdecl _mm256_maskz_scalef_ph(__mmask16, __m256h, __m256h);
extern __m512h __cdecl _mm512_scalef_ph(__m512h, __m512h);
extern __m512h __cdecl _mm512_mask_scalef_ph(__m512h, __mmask32, __m512h, __m512h);
extern __m512h __cdecl _mm512_maskz_scalef_ph(__mmask32, __m512h, __m512h);
extern __m512h __cdecl _mm512_scalef_round_ph(__m512h, __m512h, const int);
extern __m512h __cdecl _mm512_mask_scalef_round_ph(__m512h, __mmask32, __m512h, __m512h, const int);
extern __m512h __cdecl _mm512_maskz_scalef_round_ph(__mmask32, __m512h, __m512h, const int);


extern __m128h __cdecl _mm_scalef_sh(__m128h, __m128h);
extern __m128h __cdecl _mm_mask_scalef_sh(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_maskz_scalef_sh(__mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_scalef_round_sh(__m128h, __m128h, const int);
extern __m128h __cdecl _mm_mask_scalef_round_sh(__m128h, __mmask8, __m128h, __m128h, const int);
extern __m128h __cdecl _mm_maskz_scalef_round_sh(__mmask8, __m128h, __m128h, const int);


extern __m128h __cdecl _mm_sqrt_ph(__m128h);
extern __m128h __cdecl _mm_mask_sqrt_ph(__m128h, __mmask8, __m128h);
extern __m128h __cdecl _mm_maskz_sqrt_ph(__mmask8, __m128h);
extern __m256h __cdecl _mm256_sqrt_ph(__m256h);
extern __m256h __cdecl _mm256_mask_sqrt_ph(__m256h, __mmask16, __m256h);
extern __m256h __cdecl _mm256_maskz_sqrt_ph(__mmask16, __m256h);
extern __m512h __cdecl _mm512_sqrt_ph(__m512h);
extern __m512h __cdecl _mm512_mask_sqrt_ph(__m512h, __mmask32, __m512h);
extern __m512h __cdecl _mm512_maskz_sqrt_ph(__mmask32, __m512h);
extern __m512h __cdecl _mm512_sqrt_round_ph(__m512h, const int);
extern __m512h __cdecl _mm512_mask_sqrt_round_ph(__m512h, __mmask32, __m512h, const int);
extern __m512h __cdecl _mm512_maskz_sqrt_round_ph(__mmask32, __m512h, const int);


extern __m128h __cdecl _mm_sqrt_sh(__m128h, __m128h);
extern __m128h __cdecl _mm_mask_sqrt_sh(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_maskz_sqrt_sh(__mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_sqrt_round_sh(__m128h, __m128h, const int);
extern __m128h __cdecl _mm_mask_sqrt_round_sh(__m128h, __mmask8, __m128h, __m128h, const int);
extern __m128h __cdecl _mm_maskz_sqrt_round_sh(__mmask8, __m128h, __m128h, const int);


extern __m128h __cdecl _mm_sub_ph(__m128h, __m128h);
extern __m128h __cdecl _mm_mask_sub_ph(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_maskz_sub_ph(__mmask8, __m128h, __m128h);
extern __m256h __cdecl _mm256_sub_ph(__m256h, __m256h);
extern __m256h __cdecl _mm256_mask_sub_ph(__m256h, __mmask16, __m256h, __m256h);
extern __m256h __cdecl _mm256_maskz_sub_ph(__mmask16, __m256h, __m256h);
extern __m512h __cdecl _mm512_sub_ph(__m512h, __m512h);
extern __m512h __cdecl _mm512_mask_sub_ph(__m512h, __mmask32, __m512h, __m512h);
extern __m512h __cdecl _mm512_maskz_sub_ph(__mmask32, __m512h, __m512h);
extern __m512h __cdecl _mm512_sub_round_ph(__m512h, __m512h, int);
extern __m512h __cdecl _mm512_mask_sub_round_ph(__m512h, __mmask32, __m512h, __m512h, int);
extern __m512h __cdecl _mm512_maskz_sub_round_ph(__mmask32, __m512h, __m512h, int);


extern __m128h __cdecl _mm_sub_sh(__m128h, __m128h);
extern __m128h __cdecl _mm_mask_sub_sh(__m128h, __mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_maskz_sub_sh(__mmask8, __m128h, __m128h);
extern __m128h __cdecl _mm_sub_round_sh(__m128h, __m128h, int);
extern __m128h __cdecl _mm_mask_sub_round_sh(__m128h, __mmask8, __m128h, __m128h, int);
extern __m128h __cdecl _mm_maskz_sub_round_sh(__mmask8, __m128h, __m128h, int);

extern __m128h __cdecl _mm_mask_blend_ph (__mmask8, __m128h, __m128h);
extern __m256h __cdecl _mm256_mask_blend_ph (__mmask16, __m256h, __m256h);
extern __m512h __cdecl _mm512_mask_blend_ph (__mmask32, __m512h, __m512h);


}
#line 6219 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\zmmintrin.h"


#line 6222 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\zmmintrin.h"
#line 2463 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"

#line 2465 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"
#line 2466 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"
#line 2467 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\immintrin.h"
#line 36 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin.h"
        #line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ammintrin.h"


#pragma once


#line 37 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ammintrin.h"


#line 45 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ammintrin.h"


#line 49 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ammintrin.h"


extern "C" { 
#line 53 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ammintrin.h"


__m128 _mm_macc_ps(__m128, __m128, __m128);
__m128d _mm_macc_pd(__m128d, __m128d, __m128d);
__m128 _mm_macc_ss(__m128, __m128, __m128);
__m128d _mm_macc_sd(__m128d, __m128d, __m128d);
__m128 _mm_maddsub_ps(__m128, __m128, __m128);
__m128d _mm_maddsub_pd(__m128d, __m128d, __m128d);
__m128 _mm_msubadd_ps(__m128, __m128, __m128);
__m128d _mm_msubadd_pd(__m128d, __m128d, __m128d);
__m128 _mm_msub_ps(__m128, __m128, __m128);
__m128d _mm_msub_pd(__m128d, __m128d, __m128d);
__m128 _mm_msub_ss(__m128, __m128, __m128);
__m128d _mm_msub_sd(__m128d, __m128d, __m128d);
__m128 _mm_nmacc_ps(__m128, __m128, __m128);
__m128d _mm_nmacc_pd(__m128d, __m128d, __m128d);
__m128 _mm_nmacc_ss(__m128, __m128, __m128);
__m128d _mm_nmacc_sd(__m128d, __m128d, __m128d);
__m128 _mm_nmsub_ps(__m128, __m128, __m128);
__m128d _mm_nmsub_pd(__m128d, __m128d, __m128d);
__m128 _mm_nmsub_ss(__m128, __m128, __m128);
__m128d _mm_nmsub_sd(__m128d, __m128d, __m128d);


__m128i _mm_maccs_epi16(__m128i, __m128i, __m128i);
__m128i _mm_macc_epi16(__m128i, __m128i, __m128i);
__m128i _mm_maccsd_epi16(__m128i, __m128i, __m128i);
__m128i _mm_maccd_epi16(__m128i, __m128i, __m128i);
__m128i _mm_maccs_epi32(__m128i, __m128i, __m128i);
__m128i _mm_macc_epi32(__m128i, __m128i, __m128i);
__m128i _mm_maccslo_epi32(__m128i, __m128i, __m128i);
__m128i _mm_macclo_epi32(__m128i, __m128i, __m128i);
__m128i _mm_maccshi_epi32(__m128i, __m128i, __m128i);
__m128i _mm_macchi_epi32(__m128i, __m128i, __m128i);
__m128i _mm_maddsd_epi16(__m128i, __m128i, __m128i);
__m128i _mm_maddd_epi16(__m128i, __m128i, __m128i);


__m128i _mm_haddw_epi8(__m128i);
__m128i _mm_haddd_epi8(__m128i);
__m128i _mm_haddq_epi8(__m128i);
__m128i _mm_haddd_epi16(__m128i);
__m128i _mm_haddq_epi16(__m128i);
__m128i _mm_haddq_epi32(__m128i);
__m128i _mm_haddw_epu8(__m128i);
__m128i _mm_haddd_epu8(__m128i);
__m128i _mm_haddq_epu8(__m128i);
__m128i _mm_haddd_epu16(__m128i);
__m128i _mm_haddq_epu16(__m128i);
__m128i _mm_haddq_epu32(__m128i);
__m128i _mm_hsubw_epi8(__m128i);
__m128i _mm_hsubd_epi16(__m128i);
__m128i _mm_hsubq_epi32(__m128i);


__m128i _mm_cmov_si128(__m128i, __m128i, __m128i);
__m128i _mm_perm_epi8(__m128i, __m128i, __m128i);


__m128i _mm_rot_epi8(__m128i, __m128i);
__m128i _mm_rot_epi16(__m128i, __m128i);
__m128i _mm_rot_epi32(__m128i, __m128i);
__m128i _mm_rot_epi64(__m128i, __m128i);
__m128i _mm_roti_epi8(__m128i, int);
__m128i _mm_roti_epi16(__m128i, int);
__m128i _mm_roti_epi32(__m128i, int);
__m128i _mm_roti_epi64(__m128i, int);
__m128i _mm_shl_epi8(__m128i, __m128i);
__m128i _mm_shl_epi16(__m128i, __m128i);
__m128i _mm_shl_epi32(__m128i, __m128i);
__m128i _mm_shl_epi64(__m128i, __m128i);
__m128i _mm_sha_epi8(__m128i, __m128i);
__m128i _mm_sha_epi16(__m128i, __m128i);
__m128i _mm_sha_epi32(__m128i, __m128i);
__m128i _mm_sha_epi64(__m128i, __m128i);


__m128i _mm_com_epu8(__m128i, __m128i, int);
__m128i _mm_com_epu16(__m128i, __m128i, int);
__m128i _mm_com_epu32(__m128i, __m128i, int);
__m128i _mm_com_epu64(__m128i, __m128i, int);
__m128i _mm_com_epi8(__m128i, __m128i, int);
__m128i _mm_com_epi16(__m128i, __m128i, int);
__m128i _mm_com_epi32(__m128i, __m128i, int);
__m128i _mm_com_epi64(__m128i, __m128i, int);


__m128 _mm_frcz_ps(__m128);
__m128d _mm_frcz_pd(__m128d);
__m128 _mm_frcz_ss(__m128, __m128);
__m128d _mm_frcz_sd(__m128d, __m128d);


__m128 _mm_permute2_ps(__m128, __m128, __m128i, int);
__m128d _mm_permute2_pd(__m128d, __m128d, __m128i, int);


__m256 _mm256_macc_ps(__m256, __m256, __m256);
__m256d _mm256_macc_pd(__m256d, __m256d, __m256d);
__m256 _mm256_maddsub_ps(__m256, __m256, __m256);
__m256d _mm256_maddsub_pd(__m256d, __m256d, __m256d);
__m256 _mm256_msubadd_ps(__m256, __m256, __m256);
__m256d _mm256_msubadd_pd(__m256d, __m256d, __m256d);
__m256 _mm256_msub_ps(__m256, __m256, __m256);
__m256d _mm256_msub_pd(__m256d, __m256d, __m256d);
__m256 _mm256_nmacc_ps(__m256, __m256, __m256);
__m256d _mm256_nmacc_pd(__m256d, __m256d, __m256d);
__m256 _mm256_nmsub_ps(__m256, __m256, __m256);
__m256d _mm256_nmsub_pd(__m256d, __m256d, __m256d);
__m256i _mm256_cmov_si256(__m256i, __m256i, __m256i);
__m256 _mm256_frcz_ps(__m256);
__m256d _mm256_frcz_pd(__m256d);
__m256 _mm256_permute2_ps(__m256, __m256, __m256i, int);
__m256d _mm256_permute2_pd(__m256d, __m256d, __m256i, int);


void __llwpcb(void *);
void *__slwpcb(void);
void __lwpval32(unsigned int, unsigned int, unsigned int);
unsigned char __lwpins32(unsigned int, unsigned int, unsigned int);


#line 277 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ammintrin.h"


unsigned int _bextr_u32(unsigned int, unsigned int, unsigned int);
unsigned int _andn_u32(unsigned int, unsigned int);
unsigned int _tzcnt_u32(unsigned int);
unsigned int _lzcnt_u32(unsigned int);
unsigned int _blsr_u32(unsigned int);
unsigned int _blsmsk_u32(unsigned int);
unsigned int _blsi_u32(unsigned int);


#line 295 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ammintrin.h"


unsigned int _bextri_u32(unsigned int, unsigned int);
unsigned int _blcfill_u32(unsigned int);
unsigned int _blsfill_u32(unsigned int);
unsigned int _blcs_u32(unsigned int);
unsigned int _tzmsk_u32(unsigned int);
unsigned int _blcic_u32(unsigned int);
unsigned int _blsic_u32(unsigned int);
unsigned int _t1mskc_u32(unsigned int);
unsigned int _blcmsk_u32(unsigned int);
unsigned int _blci_u32(unsigned int);


#line 319 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ammintrin.h"

void _mm_monitorx(void const *, unsigned int, unsigned int);
void _mm_mwaitx(unsigned int, unsigned int, unsigned int);

void _mm_clzero(void const *);


#line 341 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ammintrin.h"


void __svm_invlpgb(void*, int);
void __svm_tlbsync(void);


}; 
#line 351 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ammintrin.h"

#line 353 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ammintrin.h"
#line 354 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ammintrin.h"
#line 355 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ammintrin.h"
#line 37 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin.h"
    #line 38 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin.h"

    
        #line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mm3dnow.h"


#pragma once


#line 39 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mm3dnow.h"


#line 47 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mm3dnow.h"


#pragma warning(push)
#pragma warning(disable:   4514 4820 )


extern "C" { 
#line 58 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mm3dnow.h"


void _m_femms(void);
__m64 _m_pavgusb(__m64, __m64);
__m64 _m_pf2id(__m64);
__m64 _m_pfacc(__m64, __m64);
__m64 _m_pfadd(__m64, __m64);
__m64 _m_pfcmpeq(__m64, __m64);
__m64 _m_pfcmpge(__m64, __m64);
__m64 _m_pfcmpgt(__m64, __m64);
__m64 _m_pfmax(__m64, __m64);
__m64 _m_pfmin(__m64, __m64);
__m64 _m_pfmul(__m64, __m64);
__m64 _m_pfrcp(__m64);
__m64 _m_pfrcpit1(__m64, __m64);
__m64 _m_pfrcpit2(__m64, __m64);
__m64 _m_pfrsqrt(__m64);
__m64 _m_pfrsqit1(__m64, __m64);
__m64 _m_pfsub(__m64, __m64);
__m64 _m_pfsubr(__m64, __m64);
__m64 _m_pi2fd(__m64);
__m64 _m_pmulhrw(__m64, __m64);
void _m_prefetch(void*);
void _m_prefetchw(volatile const void*_Source);

__m64 _m_from_float(float);
float _m_to_float(__m64);


__m64 _m_pf2iw(__m64);
__m64 _m_pfnacc(__m64, __m64);
__m64 _m_pfpnacc(__m64, __m64);
__m64 _m_pi2fw(__m64);
__m64 _m_pswapd(__m64);


}; 
#line 98 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mm3dnow.h"
#pragma warning(pop) 
#line 100 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mm3dnow.h"
#line 101 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\mm3dnow.h"
#line 41 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin.h"
    #line 42 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin.h"

    
#line 47 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin.h"

    
#line 52 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin.h"
#line 53 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin.h"


extern "C" {
#line 57 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin.h"


void * _AddressOfReturnAddress(void);


int _cvt_dtoi_fast (double);
int _cvt_dtoi_sat (double);
int _cvt_dtoi_sent (double);
long long _cvt_dtoll_fast (double);
long long _cvt_dtoll_sat (double);
long long _cvt_dtoll_sent (double);
unsigned _cvt_dtoui_fast (double);
unsigned _cvt_dtoui_sat (double);
unsigned _cvt_dtoui_sent (double);
unsigned long long _cvt_dtoull_fast (double);
unsigned long long _cvt_dtoull_sat (double);
unsigned long long _cvt_dtoull_sent (double);
int _cvt_ftoi_fast (float);
int _cvt_ftoi_sat (float);
int _cvt_ftoi_sent (float);
long long _cvt_ftoll_fast (float);
long long _cvt_ftoll_sat (float);
long long _cvt_ftoll_sent (float);
unsigned _cvt_ftoui_fast (float);
unsigned _cvt_ftoui_sat (float);
unsigned _cvt_ftoui_sent (float);
unsigned long long _cvt_ftoull_fast (float);
unsigned long long _cvt_ftoull_sat (float);
unsigned long long _cvt_ftoull_sent (float);


long _interlockedadd(long volatile * _Addend, long _Value);

__int64 _interlockedadd64(__int64 volatile * _Addend, __int64 _Value);


long _InterlockedAddLargeStatistic(__int64 volatile * _Addend, long _Value);


unsigned char _interlockedbittestandset(long volatile *, long);


void * _InterlockedCompareExchangePointer(void * volatile * _Destination, void * _Exchange, void * _Comparand);


void * _InterlockedExchangePointer(void * volatile * _Target, void * _Value);


void _ReadBarrier(void);


void * _ReturnAddress(void);

void _WriteBarrier(void);


void __addfsbyte(unsigned long, unsigned char);
void __addfsdword(unsigned long, unsigned long);
void __addfsword(unsigned long, unsigned short);


void __clts(void);
void __code_seg(const char *);
void __cpuid(int[4], int);
void __cpuidex(int[4], int, int);
void __cdecl __debugbreak(void);

__int64 __emul(int, int);
unsigned __int64 __emulu(unsigned int, unsigned int);
__declspec(noreturn) void __fastfail(unsigned int);

unsigned int __getcallerseflags(void);
void __halt(void);


unsigned char __inbyte(unsigned short);
void __inbytestring(unsigned short, unsigned char *, unsigned long);
void __incfsbyte(unsigned long);
void __incfsdword(unsigned long);
void __incfsword(unsigned long);


unsigned long __indword(unsigned short);
void __indwordstring(unsigned short, unsigned long *, unsigned long);
void __int2c(void);
void __invlpg(void *);
unsigned short __inword(unsigned short);
void __inwordstring(unsigned short, unsigned short *, unsigned long);
void __lidt(void *);
unsigned __int64 __ll_lshift(unsigned __int64, int);
__int64 __ll_rshift(__int64, int);
void __movsb(unsigned char *, unsigned char const *, size_t);
void __movsd(unsigned long *, unsigned long const *, size_t);

void __movsw(unsigned short *, unsigned short const *, size_t);

void __nop(void);
void __nvreg_restore_fence(void);
void __nvreg_save_fence(void);
void __outbyte(unsigned short, unsigned char);
void __outbytestring(unsigned short, unsigned char *, unsigned long);
void __outdword(unsigned short, unsigned long);
void __outdwordstring(unsigned short, unsigned long *, unsigned long);
void __outword(unsigned short, unsigned short);
void __outwordstring(unsigned short, unsigned short *, unsigned long);


unsigned __int64 __rdtsc(void);
unsigned __int64 __rdtscp(unsigned int *);

unsigned long __readcr0(void);

unsigned long __readcr2(void);

unsigned long __readcr3(void);

unsigned long __readcr4(void);

unsigned long __readcr8(void);

unsigned int __readdr(unsigned int);

unsigned int __readeflags(void);
unsigned char __readfsbyte(unsigned long);
unsigned long __readfsdword(unsigned long);
unsigned __int64 __readfsqword(unsigned long);
unsigned short __readfsword(unsigned long);


unsigned __int64 __readmsr(unsigned long);
unsigned __int64 __readpmc(unsigned long);


unsigned long __segmentlimit(unsigned long);

void __sidt(void *);

void __stosb(unsigned char *, unsigned char, size_t);
void __stosd(unsigned long *, unsigned long, size_t);

void __stosw(unsigned short *, unsigned short, size_t);
void __svm_clgi(void);
void __svm_invlpga(void *, int);
void __svm_skinit(int);
void __svm_stgi(void);
void __svm_vmload(size_t);
void __svm_vmrun(size_t);
void __svm_vmsave(size_t);


void __ud2(void);
unsigned __int64 __ull_rshift(unsigned __int64, int);

void __vmx_off(void);


void __vmx_vmptrst(unsigned __int64 *);


void __wbinvd(void);


void __writecr0(unsigned int);

void __writecr2(unsigned int);

void __writecr3(unsigned int);

void __writecr4(unsigned int);

void __writecr8(unsigned int);

void __writedr(unsigned int, unsigned int);

void __writeeflags(unsigned int);
void __writefsbyte(unsigned long, unsigned char);
void __writefsdword(unsigned long, unsigned long);
void __writefsqword(unsigned long, unsigned __int64);
void __writefsword(unsigned long, unsigned short);


void __writemsr(unsigned long, unsigned __int64);


unsigned char _bittestandcomplement(long *, long);

unsigned char _bittestandreset(long *, long);

unsigned char _bittestandset(long *, long);

[[nodiscard]]   unsigned __int64 __cdecl _byteswap_uint64(  unsigned __int64);
[[nodiscard]]   unsigned long __cdecl _byteswap_ulong(  unsigned long);
[[nodiscard]]   unsigned short __cdecl _byteswap_ushort(  unsigned short);
void __cdecl _disable(void);
void __cdecl _enable(void);
unsigned char _interlockedbittestandreset(long volatile *, long);


[[nodiscard]]   unsigned long __cdecl _lrotl(  unsigned long,   int);
[[nodiscard]]   unsigned long __cdecl _lrotr(  unsigned long,   int);
void _m_empty(void);
void _m_femms(void);
__m64 _m_from_float(float);
__m64 _m_from_int(int);
void _m_maskmovq(__m64, __m64, char *);
__m64 _m_packssdw(__m64, __m64);
__m64 _m_packsswb(__m64, __m64);
__m64 _m_packuswb(__m64, __m64);
__m64 _m_paddb(__m64, __m64);
__m64 _m_paddd(__m64, __m64);
__m64 _m_paddsb(__m64, __m64);
__m64 _m_paddsw(__m64, __m64);
__m64 _m_paddusb(__m64, __m64);
__m64 _m_paddusw(__m64, __m64);
__m64 _m_paddw(__m64, __m64);
__m64 _m_pand(__m64, __m64);
__m64 _m_pandn(__m64, __m64);
__m64 _m_pavgb(__m64, __m64);
__m64 _m_pavgusb(__m64, __m64);
__m64 _m_pavgw(__m64, __m64);
__m64 _m_pcmpeqb(__m64, __m64);
__m64 _m_pcmpeqd(__m64, __m64);
__m64 _m_pcmpeqw(__m64, __m64);
__m64 _m_pcmpgtb(__m64, __m64);
__m64 _m_pcmpgtd(__m64, __m64);
__m64 _m_pcmpgtw(__m64, __m64);
int _m_pextrw(__m64, int);
__m64 _m_pf2id(__m64);
__m64 _m_pf2iw(__m64);
__m64 _m_pfacc(__m64, __m64);
__m64 _m_pfadd(__m64, __m64);
__m64 _m_pfcmpeq(__m64, __m64);
__m64 _m_pfcmpge(__m64, __m64);
__m64 _m_pfcmpgt(__m64, __m64);
__m64 _m_pfmax(__m64, __m64);
__m64 _m_pfmin(__m64, __m64);
__m64 _m_pfmul(__m64, __m64);
__m64 _m_pfnacc(__m64, __m64);
__m64 _m_pfpnacc(__m64, __m64);
__m64 _m_pfrcp(__m64);
__m64 _m_pfrcpit1(__m64, __m64);
__m64 _m_pfrcpit2(__m64, __m64);
__m64 _m_pfrsqit1(__m64, __m64);
__m64 _m_pfrsqrt(__m64);
__m64 _m_pfsub(__m64, __m64);
__m64 _m_pfsubr(__m64, __m64);
__m64 _m_pi2fd(__m64);
__m64 _m_pi2fw(__m64);
__m64 _m_pinsrw(__m64, int, int);
__m64 _m_pmaddwd(__m64, __m64);
__m64 _m_pmaxsw(__m64, __m64);
__m64 _m_pmaxub(__m64, __m64);
__m64 _m_pminsw(__m64, __m64);
__m64 _m_pminub(__m64, __m64);
int _m_pmovmskb(__m64);
__m64 _m_pmulhrw(__m64, __m64);
__m64 _m_pmulhuw(__m64, __m64);
__m64 _m_pmulhw(__m64, __m64);
__m64 _m_pmullw(__m64, __m64);
__m64 _m_por(__m64, __m64);
void _m_prefetch(void *);
void _m_prefetchw(volatile const void *);
__m64 _m_psadbw(__m64, __m64);
__m64 _m_pshufw(__m64, int);
__m64 _m_pslld(__m64, __m64);
__m64 _m_pslldi(__m64, int);
__m64 _m_psllq(__m64, __m64);
__m64 _m_psllqi(__m64, int);
__m64 _m_psllw(__m64, __m64);
__m64 _m_psllwi(__m64, int);
__m64 _m_psrad(__m64, __m64);
__m64 _m_psradi(__m64, int);
__m64 _m_psraw(__m64, __m64);
__m64 _m_psrawi(__m64, int);
__m64 _m_psrld(__m64, __m64);
__m64 _m_psrldi(__m64, int);
__m64 _m_psrlq(__m64, __m64);
__m64 _m_psrlqi(__m64, int);
__m64 _m_psrlw(__m64, __m64);
__m64 _m_psrlwi(__m64, int);
__m64 _m_psubb(__m64, __m64);
__m64 _m_psubd(__m64, __m64);
__m64 _m_psubsb(__m64, __m64);
__m64 _m_psubsw(__m64, __m64);
__m64 _m_psubusb(__m64, __m64);
__m64 _m_psubusw(__m64, __m64);
__m64 _m_psubw(__m64, __m64);
__m64 _m_pswapd(__m64);
__m64 _m_punpckhbw(__m64, __m64);
__m64 _m_punpckhdq(__m64, __m64);
__m64 _m_punpckhwd(__m64, __m64);
__m64 _m_punpcklbw(__m64, __m64);
__m64 _m_punpckldq(__m64, __m64);
__m64 _m_punpcklwd(__m64, __m64);
__m64 _m_pxor(__m64, __m64);
float _m_to_float(__m64);
int _m_to_int(__m64);
__m128i _mm_abs_epi16(__m128i);
__m128i _mm_abs_epi32(__m128i);
__m128i _mm_abs_epi8(__m128i);
__m64 _mm_abs_pi16(__m64);
__m64 _mm_abs_pi32(__m64);
__m64 _mm_abs_pi8(__m64);
__m128i _mm_add_epi16(__m128i, __m128i);
__m128i _mm_add_epi32(__m128i, __m128i);
__m128i _mm_add_epi64(__m128i, __m128i);
__m128i _mm_add_epi8(__m128i, __m128i);
__m128d _mm_add_pd(__m128d, __m128d);
__m128 _mm_add_ps(__m128, __m128);
__m128d _mm_add_sd(__m128d, __m128d);
__m64 _mm_add_si64(__m64, __m64);
__m128 _mm_add_ss(__m128, __m128);
__m128i _mm_adds_epi16(__m128i, __m128i);
__m128i _mm_adds_epi8(__m128i, __m128i);
__m128i _mm_adds_epu16(__m128i, __m128i);
__m128i _mm_adds_epu8(__m128i, __m128i);
__m128d _mm_addsub_pd(__m128d, __m128d);
__m128 _mm_addsub_ps(__m128, __m128);
__m128i _mm_alignr_epi8(__m128i, __m128i, int);
__m64 _mm_alignr_pi8(__m64, __m64, int);
__m128d _mm_and_pd(__m128d, __m128d);
__m128 _mm_and_ps(__m128, __m128);
__m128i _mm_and_si128(__m128i, __m128i);
__m128d _mm_andnot_pd(__m128d, __m128d);
__m128 _mm_andnot_ps(__m128, __m128);
__m128i _mm_andnot_si128(__m128i, __m128i);
__m128i _mm_avg_epu16(__m128i, __m128i);
__m128i _mm_avg_epu8(__m128i, __m128i);
__m128i _mm_blend_epi16(__m128i, __m128i, int);
__m128d _mm_blend_pd(__m128d, __m128d, int);
__m128 _mm_blend_ps(__m128, __m128, int);
__m128i _mm_blendv_epi8(__m128i, __m128i, __m128i);
__m128d _mm_blendv_pd(__m128d, __m128d, __m128d);
__m128 _mm_blendv_ps(__m128, __m128, __m128);
void _mm_clflush(void const *);
void _mm_clflushopt(void const *);
void _mm_clwb(void const *);
void _mm_clzero(void const *);
__m128i _mm_cmpeq_epi16(__m128i, __m128i);
__m128i _mm_cmpeq_epi32(__m128i, __m128i);
__m128i _mm_cmpeq_epi64(__m128i, __m128i);
__m128i _mm_cmpeq_epi8(__m128i, __m128i);
__m128d _mm_cmpeq_pd(__m128d, __m128d);
__m128 _mm_cmpeq_ps(__m128, __m128);
__m128d _mm_cmpeq_sd(__m128d, __m128d);
__m128 _mm_cmpeq_ss(__m128, __m128);
int _mm_cmpestra(__m128i, int, __m128i, int, int);
int _mm_cmpestrc(__m128i, int, __m128i, int, int);
int _mm_cmpestri(__m128i, int, __m128i, int, int);
__m128i _mm_cmpestrm(__m128i, int, __m128i, int, int);
int _mm_cmpestro(__m128i, int, __m128i, int, int);
int _mm_cmpestrs(__m128i, int, __m128i, int, int);
int _mm_cmpestrz(__m128i, int, __m128i, int, int);
__m128d _mm_cmpge_pd(__m128d, __m128d);
__m128 _mm_cmpge_ps(__m128, __m128);
__m128d _mm_cmpge_sd(__m128d, __m128d);
__m128 _mm_cmpge_ss(__m128, __m128);
__m128i _mm_cmpgt_epi16(__m128i, __m128i);
__m128i _mm_cmpgt_epi32(__m128i, __m128i);
__m128i _mm_cmpgt_epi64(__m128i, __m128i);
__m128i _mm_cmpgt_epi8(__m128i, __m128i);
__m128d _mm_cmpgt_pd(__m128d, __m128d);
__m128 _mm_cmpgt_ps(__m128, __m128);
__m128d _mm_cmpgt_sd(__m128d, __m128d);
__m128 _mm_cmpgt_ss(__m128, __m128);
int _mm_cmpistra(__m128i, __m128i, int);
int _mm_cmpistrc(__m128i, __m128i, int);
int _mm_cmpistri(__m128i, __m128i, int);
__m128i _mm_cmpistrm(__m128i, __m128i, int);
int _mm_cmpistro(__m128i, __m128i, int);
int _mm_cmpistrs(__m128i, __m128i, int);
int _mm_cmpistrz(__m128i, __m128i, int);
__m128d _mm_cmple_pd(__m128d, __m128d);
__m128 _mm_cmple_ps(__m128, __m128);
__m128d _mm_cmple_sd(__m128d, __m128d);
__m128 _mm_cmple_ss(__m128, __m128);
__m128i _mm_cmplt_epi16(__m128i, __m128i);
__m128i _mm_cmplt_epi32(__m128i, __m128i);
__m128i _mm_cmplt_epi8(__m128i, __m128i);
__m128d _mm_cmplt_pd(__m128d, __m128d);
__m128 _mm_cmplt_ps(__m128, __m128);
__m128d _mm_cmplt_sd(__m128d, __m128d);
__m128 _mm_cmplt_ss(__m128, __m128);
__m128d _mm_cmpneq_pd(__m128d, __m128d);
__m128 _mm_cmpneq_ps(__m128, __m128);
__m128d _mm_cmpneq_sd(__m128d, __m128d);
__m128 _mm_cmpneq_ss(__m128, __m128);
__m128d _mm_cmpnge_pd(__m128d, __m128d);
__m128 _mm_cmpnge_ps(__m128, __m128);
__m128d _mm_cmpnge_sd(__m128d, __m128d);
__m128 _mm_cmpnge_ss(__m128, __m128);
__m128d _mm_cmpngt_pd(__m128d, __m128d);
__m128 _mm_cmpngt_ps(__m128, __m128);
__m128d _mm_cmpngt_sd(__m128d, __m128d);
__m128 _mm_cmpngt_ss(__m128, __m128);
__m128d _mm_cmpnle_pd(__m128d, __m128d);
__m128 _mm_cmpnle_ps(__m128, __m128);
__m128d _mm_cmpnle_sd(__m128d, __m128d);
__m128 _mm_cmpnle_ss(__m128, __m128);
__m128d _mm_cmpnlt_pd(__m128d, __m128d);
__m128 _mm_cmpnlt_ps(__m128, __m128);
__m128d _mm_cmpnlt_sd(__m128d, __m128d);
__m128 _mm_cmpnlt_ss(__m128, __m128);
__m128d _mm_cmpord_pd(__m128d, __m128d);
__m128 _mm_cmpord_ps(__m128, __m128);
__m128d _mm_cmpord_sd(__m128d, __m128d);
__m128 _mm_cmpord_ss(__m128, __m128);
__m128d _mm_cmpunord_pd(__m128d, __m128d);
__m128 _mm_cmpunord_ps(__m128, __m128);
__m128d _mm_cmpunord_sd(__m128d, __m128d);
__m128 _mm_cmpunord_ss(__m128, __m128);
int _mm_comieq_sd(__m128d, __m128d);
int _mm_comieq_ss(__m128, __m128);
int _mm_comige_sd(__m128d, __m128d);
int _mm_comige_ss(__m128, __m128);
int _mm_comigt_sd(__m128d, __m128d);
int _mm_comigt_ss(__m128, __m128);
int _mm_comile_sd(__m128d, __m128d);
int _mm_comile_ss(__m128, __m128);
int _mm_comilt_sd(__m128d, __m128d);
int _mm_comilt_ss(__m128, __m128);
int _mm_comineq_sd(__m128d, __m128d);
int _mm_comineq_ss(__m128, __m128);
unsigned int _mm_crc32_u16(unsigned int, unsigned short);
unsigned int _mm_crc32_u32(unsigned int, unsigned int);

unsigned int _mm_crc32_u8(unsigned int, unsigned char);
__m128 _mm_cvt_pi2ps(__m128, __m64);
__m64 _mm_cvt_ps2pi(__m128);
__m128 _mm_cvt_si2ss(__m128, int);
int _mm_cvt_ss2si(__m128);
__m128i _mm_cvtepi16_epi32(__m128i);
__m128i _mm_cvtepi16_epi64(__m128i);
__m128i _mm_cvtepi32_epi64(__m128i);
__m128d _mm_cvtepi32_pd(__m128i);
__m128 _mm_cvtepi32_ps(__m128i);
__m128i _mm_cvtepi8_epi16(__m128i);
__m128i _mm_cvtepi8_epi32(__m128i);
__m128i _mm_cvtepi8_epi64(__m128i);
__m128i _mm_cvtepu16_epi32(__m128i);
__m128i _mm_cvtepu16_epi64(__m128i);
__m128i _mm_cvtepu32_epi64(__m128i);
__m128i _mm_cvtepu8_epi16(__m128i);
__m128i _mm_cvtepu8_epi32(__m128i);
__m128i _mm_cvtepu8_epi64(__m128i);
__m128i _mm_cvtpd_epi32(__m128d);
__m64 _mm_cvtpd_pi32(__m128d);
__m128 _mm_cvtpd_ps(__m128d);
__m128d _mm_cvtpi32_pd(__m64);
__m128i _mm_cvtps_epi32(__m128);
__m128d _mm_cvtps_pd(__m128);
int _mm_cvtsd_si32(__m128d);


__m128 _mm_cvtsd_ss(__m128, __m128d);
int _mm_cvtsi128_si32(__m128i);


__m128d _mm_cvtsi32_sd(__m128d, int);
__m128i _mm_cvtsi32_si128(int);


__m128d _mm_cvtss_sd(__m128d, __m128);


__m64 _mm_cvtt_ps2pi(__m128);
int _mm_cvtt_ss2si(__m128);
__m128i _mm_cvttpd_epi32(__m128d);
__m64 _mm_cvttpd_pi32(__m128d);
__m128i _mm_cvttps_epi32(__m128);
int _mm_cvttsd_si32(__m128d);


__m128d _mm_div_pd(__m128d, __m128d);
__m128 _mm_div_ps(__m128, __m128);
__m128d _mm_div_sd(__m128d, __m128d);
__m128 _mm_div_ss(__m128, __m128);
__m128d _mm_dp_pd(__m128d, __m128d, int);
__m128 _mm_dp_ps(__m128, __m128, int);
int _mm_extract_epi16(__m128i, int);
int _mm_extract_epi32(__m128i, int);

int _mm_extract_epi8(__m128i, int);
int _mm_extract_ps(__m128, int);
__m128i _mm_extract_si64(__m128i, __m128i);
__m128i _mm_extracti_si64(__m128i, int, int);
unsigned int _mm_getcsr(void);
__m128i _mm_hadd_epi16(__m128i, __m128i);
__m128i _mm_hadd_epi32(__m128i, __m128i);
__m128d _mm_hadd_pd(__m128d, __m128d);
__m64 _mm_hadd_pi16(__m64, __m64);
__m64 _mm_hadd_pi32(__m64, __m64);
__m128 _mm_hadd_ps(__m128, __m128);
__m128i _mm_hadds_epi16(__m128i, __m128i);
__m64 _mm_hadds_pi16(__m64, __m64);
__m128i _mm_hsub_epi16(__m128i, __m128i);
__m128i _mm_hsub_epi32(__m128i, __m128i);
__m128d _mm_hsub_pd(__m128d, __m128d);
__m64 _mm_hsub_pi16(__m64, __m64);
__m64 _mm_hsub_pi32(__m64, __m64);
__m128 _mm_hsub_ps(__m128, __m128);
__m128i _mm_hsubs_epi16(__m128i, __m128i);
__m64 _mm_hsubs_pi16(__m64, __m64);
__m128i _mm_insert_epi16(__m128i, int, int);
__m128i _mm_insert_epi32(__m128i, int, int);

__m128i _mm_insert_epi8(__m128i, int, int);
__m128 _mm_insert_ps(__m128, __m128, int);
__m128i _mm_insert_si64(__m128i, __m128i);
__m128i _mm_inserti_si64(__m128i, __m128i, int, int);
__m128i _mm_lddqu_si128(__m128i const *);
void _mm_lfence(void);
__m128d _mm_load1_pd(double const *);
__m128d _mm_load_pd(double const *);
__m128 _mm_load_ps(float const *);
__m128 _mm_load_ps1(float const *);
__m128d _mm_load_sd(double const *);
__m128i _mm_load_si128(__m128i const *);
__m128 _mm_load_ss(float const *);
__m128d _mm_loaddup_pd(double const *);
__m128d _mm_loadh_pd(__m128d, double const *);
__m128 _mm_loadh_pi(__m128, __m64 const *);
__m128i _mm_loadl_epi64(__m128i const *);
__m128d _mm_loadl_pd(__m128d, double const *);
__m128 _mm_loadl_pi(__m128, __m64 const *);
__m128d _mm_loadr_pd(double const *);
__m128 _mm_loadr_ps(float const *);
__m128d _mm_loadu_pd(double const *);
__m128 _mm_loadu_ps(float const *);
__m128i _mm_loadu_si128(__m128i const *);
__m128i _mm_madd_epi16(__m128i, __m128i);
__m128i _mm_maddubs_epi16(__m128i, __m128i);
__m64 _mm_maddubs_pi16(__m64, __m64);
void _mm_maskmoveu_si128(__m128i, __m128i, char *);
__m128i _mm_max_epi16(__m128i, __m128i);
__m128i _mm_max_epi32(__m128i, __m128i);
__m128i _mm_max_epi8(__m128i, __m128i);
__m128i _mm_max_epu16(__m128i, __m128i);
__m128i _mm_max_epu32(__m128i, __m128i);
__m128i _mm_max_epu8(__m128i, __m128i);
__m128d _mm_max_pd(__m128d, __m128d);
__m128 _mm_max_ps(__m128, __m128);
__m128d _mm_max_sd(__m128d, __m128d);
__m128 _mm_max_ss(__m128, __m128);
void _mm_mfence(void);
__m128i _mm_min_epi16(__m128i, __m128i);
__m128i _mm_min_epi32(__m128i, __m128i);
__m128i _mm_min_epi8(__m128i, __m128i);
__m128i _mm_min_epu16(__m128i, __m128i);
__m128i _mm_min_epu32(__m128i, __m128i);
__m128i _mm_min_epu8(__m128i, __m128i);
__m128d _mm_min_pd(__m128d, __m128d);
__m128 _mm_min_ps(__m128, __m128);
__m128d _mm_min_sd(__m128d, __m128d);
__m128 _mm_min_ss(__m128, __m128);
__m128i _mm_minpos_epu16(__m128i);
void _mm_monitor(void const *, unsigned int, unsigned int);
__m128i _mm_move_epi64(__m128i);
__m128d _mm_move_sd(__m128d, __m128d);
__m128 _mm_move_ss(__m128, __m128);
__m128d _mm_movedup_pd(__m128d);
__m128 _mm_movehdup_ps(__m128);
__m128 _mm_movehl_ps(__m128, __m128);
__m128 _mm_moveldup_ps(__m128);
__m128 _mm_movelh_ps(__m128, __m128);
int _mm_movemask_epi8(__m128i);
int _mm_movemask_pd(__m128d);
int _mm_movemask_ps(__m128);
__m64 _mm_movepi64_pi64(__m128i);
__m128i _mm_movpi64_epi64(__m64);
__m128i _mm_mpsadbw_epu8(__m128i, __m128i, int);
__m128i _mm_mul_epi32(__m128i, __m128i);
__m128i _mm_mul_epu32(__m128i, __m128i);
__m128d _mm_mul_pd(__m128d, __m128d);
__m128 _mm_mul_ps(__m128, __m128);
__m128d _mm_mul_sd(__m128d, __m128d);
__m128 _mm_mul_ss(__m128, __m128);
__m64 _mm_mul_su32(__m64, __m64);
__m128i _mm_mulhi_epi16(__m128i, __m128i);
__m128i _mm_mulhi_epu16(__m128i, __m128i);
__m128i _mm_mulhrs_epi16(__m128i, __m128i);
__m64 _mm_mulhrs_pi16(__m64, __m64);
__m128i _mm_mullo_epi16(__m128i, __m128i);
__m128i _mm_mullo_epi32(__m128i, __m128i);
void _mm_mwait(unsigned int, unsigned int);
__m128d _mm_or_pd(__m128d, __m128d);
__m128 _mm_or_ps(__m128, __m128);
__m128i _mm_or_si128(__m128i, __m128i);
__m128i _mm_packs_epi16(__m128i, __m128i);
__m128i _mm_packs_epi32(__m128i, __m128i);
__m128i _mm_packus_epi16(__m128i, __m128i);
__m128i _mm_packus_epi32(__m128i, __m128i);
int _mm_popcnt_u32(unsigned int);

void _mm_prefetch(char const *, int);
__m128 _mm_rcp_ps(__m128);
__m128 _mm_rcp_ss(__m128);
__m128d _mm_round_pd(__m128d, int);
__m128 _mm_round_ps(__m128, int);
__m128d _mm_round_sd(__m128d, __m128d, int);
__m128 _mm_round_ss(__m128, __m128, int);
__m128 _mm_rsqrt_ps(__m128);
__m128 _mm_rsqrt_ss(__m128);
__m128i _mm_sad_epu8(__m128i, __m128i);
__m128i _mm_set1_epi16(short);
__m128i _mm_set1_epi32(int);
__m128i _mm_set1_epi64(__m64);
__m128i _mm_set1_epi64x(__int64);
__m128i _mm_set1_epi8(char);
__m128d _mm_set1_pd(double);
__m64 _mm_set1_pi16(short);
__m64 _mm_set1_pi32(int);
__m64 _mm_set1_pi8(char);
__m128i _mm_set_epi16(short, short, short, short, short, short, short, short);
__m128i _mm_set_epi32(int, int, int, int);
__m128i _mm_set_epi64(__m64, __m64);
__m128i _mm_set_epi64x(__int64, __int64);
__m128i _mm_set_epi8(char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char);
__m128d _mm_set_pd(double, double);
__m64 _mm_set_pi16(short, short, short, short);
__m64 _mm_set_pi32(int, int);
__m64 _mm_set_pi8(char, char, char, char, char, char, char, char);
__m128 _mm_set_ps(float, float, float, float);
__m128 _mm_set_ps1(float);
__m128d _mm_set_sd(double);
__m128 _mm_set_ss(float);
void _mm_setcsr(unsigned int);
__m128i _mm_setl_epi64(__m128i);
__m128i _mm_setr_epi16(short, short, short, short, short, short, short, short);
__m128i _mm_setr_epi32(int, int, int, int);
__m128i _mm_setr_epi64(__m64, __m64);
__m128i _mm_setr_epi64x(__int64, __int64);
__m128i _mm_setr_epi8(char, char, char, char, char, char, char, char, char, char, char, char, char, char, char, char);
__m128d _mm_setr_pd(double, double);
__m64 _mm_setr_pi16(short, short, short, short);
__m64 _mm_setr_pi32(int, int);
__m64 _mm_setr_pi8(char, char, char, char, char, char, char, char);
__m128 _mm_setr_ps(float, float, float, float);
__m128d _mm_setzero_pd(void);
__m128 _mm_setzero_ps(void);
__m128i _mm_setzero_si128(void);
__m64 _mm_setzero_si64(void);
void _mm_sfence(void);
__m128i _mm_shuffle_epi32(__m128i, int);
__m128i _mm_shuffle_epi8(__m128i, __m128i);
__m128d _mm_shuffle_pd(__m128d, __m128d, int);
__m64 _mm_shuffle_pi8(__m64, __m64);
__m128 _mm_shuffle_ps(__m128, __m128, unsigned int);
__m128i _mm_shufflehi_epi16(__m128i, int);
__m128i _mm_shufflelo_epi16(__m128i, int);
__m128i _mm_sign_epi16(__m128i, __m128i);
__m128i _mm_sign_epi32(__m128i, __m128i);
__m128i _mm_sign_epi8(__m128i, __m128i);
__m64 _mm_sign_pi16(__m64, __m64);
__m64 _mm_sign_pi32(__m64, __m64);
__m64 _mm_sign_pi8(__m64, __m64);
__m128i _mm_sll_epi16(__m128i, __m128i);
__m128i _mm_sll_epi32(__m128i, __m128i);
__m128i _mm_sll_epi64(__m128i, __m128i);
__m128i _mm_slli_epi16(__m128i, int);
__m128i _mm_slli_epi32(__m128i, int);
__m128i _mm_slli_epi64(__m128i, int);
__m128i _mm_slli_si128(__m128i, int);
__m128d _mm_sqrt_pd(__m128d);
__m128 _mm_sqrt_ps(__m128);
__m128d _mm_sqrt_sd(__m128d, __m128d);
__m128 _mm_sqrt_ss(__m128);
__m128i _mm_sra_epi16(__m128i, __m128i);
__m128i _mm_sra_epi32(__m128i, __m128i);
__m128i _mm_srai_epi16(__m128i, int);
__m128i _mm_srai_epi32(__m128i, int);
__m128i _mm_srl_epi16(__m128i, __m128i);
__m128i _mm_srl_epi32(__m128i, __m128i);
__m128i _mm_srl_epi64(__m128i, __m128i);
__m128i _mm_srli_epi16(__m128i, int);
__m128i _mm_srli_epi32(__m128i, int);
__m128i _mm_srli_epi64(__m128i, int);
__m128i _mm_srli_si128(__m128i, int);
void _mm_store1_pd(double *, __m128d);
void _mm_store_pd(double *, __m128d);
void _mm_store_ps(float *, __m128);
void _mm_store_ps1(float *, __m128);
void _mm_store_sd(double *, __m128d);
void _mm_store_si128(__m128i *, __m128i);
void _mm_store_ss(float *, __m128);
void _mm_storeh_pd(double *, __m128d);
void _mm_storeh_pi(__m64 *, __m128);
void _mm_storel_epi64(__m128i *, __m128i);
void _mm_storel_pd(double *, __m128d);
void _mm_storel_pi(__m64 *, __m128);
void _mm_storer_pd(double *, __m128d);
void _mm_storer_ps(float *, __m128);
void _mm_storeu_pd(double *, __m128d);
void _mm_storeu_ps(float *, __m128);
void _mm_storeu_si128(__m128i *, __m128i);


#line 875 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin.h"
__m128i _mm_stream_load_si128(const __m128i *);
#line 877 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin.h"
void _mm_stream_pd(double *, __m128d);
void _mm_stream_pi(__m64 *, __m64);
void _mm_stream_ps(float *, __m128);
void _mm_stream_sd(double *, __m128d);
void _mm_stream_si128(__m128i *, __m128i);
void _mm_stream_si32(int *, int);

void _mm_stream_ss(float *, __m128);
__m128i _mm_sub_epi16(__m128i, __m128i);
__m128i _mm_sub_epi32(__m128i, __m128i);
__m128i _mm_sub_epi64(__m128i, __m128i);
__m128i _mm_sub_epi8(__m128i, __m128i);
__m128d _mm_sub_pd(__m128d, __m128d);
__m128 _mm_sub_ps(__m128, __m128);
__m128d _mm_sub_sd(__m128d, __m128d);
__m64 _mm_sub_si64(__m64, __m64);
__m128 _mm_sub_ss(__m128, __m128);
__m128i _mm_subs_epi16(__m128i, __m128i);
__m128i _mm_subs_epi8(__m128i, __m128i);
__m128i _mm_subs_epu16(__m128i, __m128i);
__m128i _mm_subs_epu8(__m128i, __m128i);
int _mm_testc_si128(__m128i, __m128i);
int _mm_testnzc_si128(__m128i, __m128i);
int _mm_testz_si128(__m128i, __m128i);
int _mm_ucomieq_sd(__m128d, __m128d);
int _mm_ucomieq_ss(__m128, __m128);
int _mm_ucomige_sd(__m128d, __m128d);
int _mm_ucomige_ss(__m128, __m128);
int _mm_ucomigt_sd(__m128d, __m128d);
int _mm_ucomigt_ss(__m128, __m128);
int _mm_ucomile_sd(__m128d, __m128d);
int _mm_ucomile_ss(__m128, __m128);
int _mm_ucomilt_sd(__m128d, __m128d);
int _mm_ucomilt_ss(__m128, __m128);
int _mm_ucomineq_sd(__m128d, __m128d);
int _mm_ucomineq_ss(__m128, __m128);
__m128i _mm_unpackhi_epi16(__m128i, __m128i);
__m128i _mm_unpackhi_epi32(__m128i, __m128i);
__m128i _mm_unpackhi_epi64(__m128i, __m128i);
__m128i _mm_unpackhi_epi8(__m128i, __m128i);
__m128d _mm_unpackhi_pd(__m128d, __m128d);
__m128 _mm_unpackhi_ps(__m128, __m128);
__m128i _mm_unpacklo_epi16(__m128i, __m128i);
__m128i _mm_unpacklo_epi32(__m128i, __m128i);
__m128i _mm_unpacklo_epi64(__m128i, __m128i);
__m128i _mm_unpacklo_epi8(__m128i, __m128i);
__m128d _mm_unpacklo_pd(__m128d, __m128d);
__m128 _mm_unpacklo_ps(__m128, __m128);
__m128d _mm_xor_pd(__m128d, __m128d);
__m128 _mm_xor_ps(__m128, __m128);
__m128i _mm_xor_si128(__m128i, __m128i);

int __cdecl _setjmp(jmp_buf);

void _rsm(void);
void _lgdt(void *);
void _sgdt(void *);
void _clac(void);
void _stac(void);
unsigned char __cdecl _addcarry_u8(unsigned char, unsigned char, unsigned char, unsigned char *);
unsigned char __cdecl _subborrow_u8(unsigned char, unsigned char, unsigned char, unsigned char *);
unsigned char __cdecl _addcarry_u16(unsigned char, unsigned short, unsigned short, unsigned short *);
unsigned char __cdecl _subborrow_u16(unsigned char, unsigned short, unsigned short, unsigned short *);
unsigned char __cdecl _addcarry_u32(unsigned char, unsigned int, unsigned int, unsigned int *);
unsigned char __cdecl _subborrow_u32(unsigned char, unsigned int, unsigned int, unsigned int *);
void _mm_monitorx(void const *, unsigned int, unsigned int);
void _mm_mwaitx(unsigned int, unsigned int, unsigned int);


void __svm_invlpgb(void*, int);
void __svm_tlbsync(void);


#line 961 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin.h"

#line 963 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin.h"


}
#line 967 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin.h"
#pragma warning(pop) 
#line 969 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin.h"

#line 971 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\intrin.h"
#line 18 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_int128.hpp"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {


#line 36 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_int128.hpp"


#line 39 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_int128.hpp"

struct

    alignas(16)
#line 44 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_int128.hpp"
        _Base128 {
    uint64_t _Word[2];

    constexpr void _Left_shift(const unsigned char _Count) noexcept {
        
        if (_Count == 0) {
            return;
        }

        if (_Count >= 64) {
            _Word[1] = _Word[0] << (_Count % 64);
            _Word[0] = 0;
            return;
        }


#line 64 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_int128.hpp"
        {
            _Word[1] = (_Word[1] << _Count) | (_Word[0] >> (64 - _Count));
        }

        _Word[0] <<= _Count;
    }

    constexpr void _Unsigned_right_shift(const unsigned char _Count) noexcept {
        
        if (_Count == 0) {
            return;
        }

        if (_Count >= 64) {
            _Word[0] = _Word[1] >> (_Count % 64);
            _Word[1] = 0;
            return;
        }


#line 88 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_int128.hpp"
        {
            _Word[0] = (_Word[0] >> _Count) | (_Word[1] << (64 - _Count));
        }

        _Word[1] >>= _Count;
    }

    static constexpr unsigned char _AddCarry64(
        unsigned char _Carry, uint64_t _Left, uint64_t _Right, uint64_t& _Result) noexcept {
        

#line 103 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_int128.hpp"

        const uint64_t _Sum = _Left + _Right + _Carry;
        _Result             = _Sum;
        return _Carry ? _Sum <= _Left : _Sum < _Left;
    }

    static constexpr unsigned char _SubBorrow64(
        unsigned char _Carry, uint64_t _Left, uint64_t _Right, uint64_t& _Result) noexcept {
        

#line 117 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_int128.hpp"

        const auto _Difference = _Left - _Right - _Carry;
        _Result                = _Difference;
        return _Carry ? _Difference >= _Left : _Difference > _Left;
    }

    template <size_t __m, size_t __n>
    static constexpr void _Knuth_4_3_1_M(
        const uint32_t (&__u)[__m], const uint32_t (&__v)[__n], uint32_t (&__w)[__n + __m]) noexcept {


        for (auto& _Elem : __w) {
            _Elem = 0;
        }

        for (int __j = 0; __j < static_cast<int>(__n); ++__j) {
            
            uint64_t __t = 0;
            for (int __i = 0; __i < static_cast<int>(__m); ++__i) {
                __t += static_cast<uint64_t>(__u[__i]) * __v[__j] + __w[__i + __j];
                __w[__i + __j] = static_cast<uint32_t>(__t);
                __t >>= 32;
            }
            __w[__j + __m] = static_cast<uint32_t>(__t);
        }
    }

    [[nodiscard]] static constexpr uint64_t _UMul128(
        const uint64_t _Left, const uint64_t _Right, uint64_t& _High_result) noexcept {


#line 155 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_int128.hpp"

        const uint32_t __u[2] = {
            static_cast<uint32_t>(_Left),
            static_cast<uint32_t>(_Left >> 32),
        };
        const uint32_t __v[2] = {
            static_cast<uint32_t>(_Right),
            static_cast<uint32_t>(_Right >> 32),
        };
        uint32_t __w[4];

        
        _Knuth_4_3_1_M(__u, __v, __w);

        _High_result = (static_cast<uint64_t>(__w[3]) << 32) | __w[2];
        return (static_cast<uint64_t>(__w[1]) << 32) | __w[0];
    }

    static constexpr void _Knuth_4_3_1_D(uint32_t* const __u, const size_t __u_size, const uint32_t* const __v,
        const size_t __v_size, uint32_t* const __q) noexcept {
        
        
        const auto __n = static_cast<int>(__v_size);
        
        
        const auto __m = static_cast<int>(__u_size - __v_size - 1);
        

        for (auto __j = static_cast<int>(__m); __j >= 0; --__j) {
            const auto _Two_digits = (static_cast<uint64_t>(__u[__j + __n]) << 32) | __u[__j + __n - 1];
            auto __qhat            = _Two_digits / __v[__n - 1];
            auto __rhat            = _Two_digits % __v[__n - 1];

            while ((__qhat >> 32) != 0
                   || static_cast<uint32_t>(__qhat) * static_cast<uint64_t>(__v[__n - 2])
                          > ((__rhat << 32) | __u[__j + __n - 2])) {
                --__qhat;
                __rhat += __v[__n - 1];
                if ((__rhat >> 32) != 0) {
                    break;
                }
            }

            int64_t __k = 0;
            int64_t __t;
            for (int __i = 0; __i < static_cast<int>(__n); ++__i) {
                const auto _Prod = static_cast<uint32_t>(__qhat) * static_cast<uint64_t>(__v[__i]);
                __t              = __u[__i + __j] - __k - static_cast<uint32_t>(_Prod);
                __u[__i + __j]   = static_cast<uint32_t>(__t);
                __k              = static_cast<int64_t>(_Prod >> 32) - (__t >> 32);
            }
            __t            = __u[__j + __n] - __k;
            __u[__j + __n] = static_cast<uint32_t>(__t);

            __q[__j] = static_cast<uint32_t>(__qhat);
            if (__t < 0) {
                --__q[__j];
                __k = 0;
                for (int __i = 0; __i < static_cast<int>(__n); ++__i) {
                    __t            = __u[__i + __j] + __k + __v[__i];
                    __u[__i + __j] = static_cast<uint32_t>(__t);
                    __k            = __t >> 32;
                }
                __u[__j + __n] += static_cast<int32_t>(__k);
            }
        }

        
    }

    [[nodiscard]] static constexpr uint64_t _UDiv128(
        uint64_t _High, uint64_t _Low, uint64_t _Div, uint64_t& _Remainder) noexcept {
        

#line 235 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_int128.hpp"

        const auto __d = ::std:: countl_zero(static_cast<uint32_t>(_Div >> 32));
        if (__d >= 32) { 
            auto _Rem    = (_High << 32) | (_Low >> 32);
            auto _Result = _Rem / static_cast<uint32_t>(_Div);
            _Rem         = ((_Rem % static_cast<uint32_t>(_Div)) << 32) | static_cast<uint32_t>(_Low);
            _Result      = (_Result << 32) | (_Rem / static_cast<uint32_t>(_Div));
            _Remainder   = _Rem % static_cast<uint32_t>(_Div);
            return _Result;
        }

        uint32_t __u[5] = {
            static_cast<uint32_t>(_Low << __d),
            static_cast<uint32_t>(_Low >> (32 - __d)),
            static_cast<uint32_t>(_High << __d),
            static_cast<uint32_t>(_High >> (32 - __d)),
            0,
        };
        if (__d != 0) {
            __u[2] |= static_cast<uint32_t>(_Low >> (64 - __d));
            __u[4] |= static_cast<uint32_t>(_High >> (64 - __d));
        }

        uint32_t __v[2] = {
            static_cast<uint32_t>(_Div << __d),
            static_cast<uint32_t>(_Div >> (32 - __d)),
        };
        uint32_t __q[3];

        _Knuth_4_3_1_D(__u, 5, __v, 2, __q);
        
        
        _Remainder = (static_cast<uint64_t>(__u[1]) << (32 - __d)) | (__u[0] >> __d);

        
        return (static_cast<uint64_t>(__q[1]) << 32) | __q[0];
    }

    constexpr _Base128() noexcept : _Word{} {}

    template <integral _Ty>
    constexpr _Base128(const _Ty _Val) noexcept : _Word{static_cast<uint64_t>(_Val)} {
        if constexpr (signed_integral<_Ty>) {
            if (_Val < 0) {
                _Word[1] = ~0ull;
            }
        }
    }

    constexpr explicit _Base128(const uint64_t _Low, const uint64_t _High) noexcept : _Word{_Low, _High} {}

    template <integral _Ty>
    [[nodiscard]] constexpr explicit operator _Ty() const noexcept {
        return static_cast<_Ty>(_Word[0]);
    }

    [[nodiscard]] constexpr explicit operator bool() const noexcept {
        return (_Word[0] | _Word[1]) != 0;
    }

    [[nodiscard]] friend constexpr bool operator==(const _Base128&, const _Base128&) noexcept = default;

    [[nodiscard]] friend constexpr bool operator<(const _Base128& _Left, const _Base128& _Right) noexcept {
        if (_Left._Word[1] < _Right._Word[1]) {
            return true;
        }

        if (_Left._Word[1] > _Right._Word[1]) {
            return false;
        }
        return _Left._Word[0] < _Right._Word[0];
    }
    [[nodiscard]] friend constexpr bool operator>(const _Base128& _Left, const _Base128& _Right) noexcept {
        return _Right < _Left;
    }
    [[nodiscard]] friend constexpr bool operator<=(const _Base128& _Left, const _Base128& _Right) noexcept {
        return !(_Right < _Left);
    }
    [[nodiscard]] friend constexpr bool operator>=(const _Base128& _Left, const _Base128& _Right) noexcept {
        return !(_Left < _Right);
    }

    template <integral _Ty>
    [[nodiscard]] friend constexpr _Ty operator<<(const _Ty _Left, const _Base128& _Right) noexcept {
        return _Left << _Right._Word[0];
    }

    template <integral _Ty>
    [[nodiscard]] friend constexpr _Ty operator>>(const _Ty _Left, const _Base128& _Right) noexcept {
        return _Left >> _Right._Word[0];
    }

    template <integral _Ty>
    constexpr _Base128& operator<<=(const _Ty _Count) noexcept {
        _Left_shift(static_cast<unsigned char>(_Count));
        return *this;
    }

    template <integral _Ty>
    friend constexpr _Ty& operator<<=(_Ty& _Left, const _Base128& _Right) noexcept {
        _Left <<= _Right._Word[0];
        return _Left;
    }

    template <integral _Ty>
    constexpr _Base128& operator>>=(const _Ty _Count) noexcept {
        _Unsigned_right_shift(static_cast<unsigned char>(_Count));
        return *this;
    }

    template <integral _Ty>
    friend constexpr _Ty& operator>>=(_Ty& _Left, const _Base128& _Right) noexcept {
        _Left >>= _Right._Word[0];
        return _Left;
    }

    constexpr _Base128& operator++() noexcept {
        if (++_Word[0] == 0) {
            ++_Word[1];
        }
        return *this;
    }
    constexpr _Base128 operator++(int) noexcept {
        auto _Tmp = *this;
        ++*this;
        return _Tmp;
    }

    constexpr _Base128& operator--() noexcept {
        if (_Word[0]-- == 0) {
            --_Word[1];
        }
        return *this;
    }
    constexpr _Base128 operator--(int) noexcept {
        auto _Tmp = *this;
        --*this;
        return _Tmp;
    }

    [[nodiscard]] static constexpr _Base128 _Multiply(const _Base128& _Left, const _Base128& _Right) noexcept {
        _Base128 _Result;
        _Result._Word[0] = _UMul128(_Left._Word[0], _Right._Word[0], _Result._Word[1]);
        _Result._Word[1] += _Left._Word[0] * _Right._Word[1];
        _Result._Word[1] += _Left._Word[1] * _Right._Word[0];
        return _Result;
    }


    [[nodiscard]] static constexpr _Base128 _Divide(const _Base128& _Num, const uint32_t _Den) noexcept {
        _Base128 _Result;
        _Result._Word[1] = _Num._Word[1] / _Den;
        uint64_t _Rem    = ((_Num._Word[1] % _Den) << 32) | (_Num._Word[0] >> 32);
        _Result._Word[0] = (_Rem / _Den) << 32;
        _Rem             = ((_Rem % _Den) << 32) | static_cast<uint32_t>(_Num._Word[0]);
        _Result._Word[0] |= static_cast<uint32_t>(_Rem / _Den);
        return _Result;
    }
#line 395 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_int128.hpp"
    [[nodiscard]] static constexpr _Base128 _Divide(const _Base128& _Num, const uint64_t _Den) noexcept {
        _Base128 _Result;
        _Result._Word[1] = _Num._Word[1] / _Den;
        uint64_t _Rem    = _Num._Word[1] % _Den;
        _Result._Word[0] = _UDiv128(_Rem, _Num._Word[0], _Den, _Rem);
        return _Result;
    }
    [[nodiscard]] static constexpr _Base128 _Divide(_Base128 _Num, _Base128 _Den) noexcept {
        
        if (_Den._Word[1] >= _Num._Word[1]) {
            if (_Den._Word[1] > _Num._Word[1]) {
                return 0;
            }

            return _Num._Word[1] == 0 ? _Num._Word[0] / _Den._Word[0] : _Num._Word[0] >= _Den._Word[0];
        }

        
        if (_Den._Word[1] == 0) {

            if (_Den._Word[0] < (1ull << 32)) {
                return _Divide(_Num, static_cast<uint32_t>(_Den._Word[0]));
            } else
#line 419 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_int128.hpp"
            {
                return _Divide(_Num, _Den._Word[0]);
            }
        }


#line 474 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_int128.hpp"
        auto __d                   = ::std:: countl_zero(_Den._Word[1]);
        const bool _Three_word_den = __d >= 32;
        __d &= 31;
        uint32_t __u[5]{
            static_cast<uint32_t>(_Num._Word[0] << __d),
            static_cast<uint32_t>(_Num._Word[0] >> (32 - __d)),
            static_cast<uint32_t>(_Num._Word[1] << __d),
            static_cast<uint32_t>(_Num._Word[1] >> (32 - __d)),
            0,
        };
        uint32_t __v[4] = {
            static_cast<uint32_t>(_Den._Word[0] << __d),
            static_cast<uint32_t>(_Den._Word[0] >> (32 - __d)),
            static_cast<uint32_t>(_Den._Word[1] << __d),
            static_cast<uint32_t>(_Den._Word[1] >> (32 - __d)),
        };
        if (__d != 0) {
            __u[2] |= _Num._Word[0] >> (64 - __d);
            __u[4] |= _Num._Word[1] >> (64 - __d);
            __v[2] |= _Den._Word[0] >> (64 - __d);
        }

        uint32_t __q[2];
        if (_Three_word_den) {
            
            _Knuth_4_3_1_D(__u, 5, __v, 3, __q);
        } else {
            
            _Knuth_4_3_1_D(__u, 5, __v, 4, __q);
            __q[1] = 0;
        }

        return (static_cast<uint64_t>(__q[1]) << 32) | __q[0];
#line 508 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_int128.hpp"
    }


    [[nodiscard]] static constexpr _Base128 _Modulo(const _Base128& _Num, const uint32_t _Den) noexcept {
        uint64_t _Rem = _Num._Word[1];
        _Rem          = ((_Rem % _Den) << 32) | (_Num._Word[0] >> 32);
        _Rem          = ((_Rem % _Den) << 32) | static_cast<uint32_t>(_Num._Word[0]);
        return _Rem % _Den;
    }
#line 518 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_int128.hpp"
    [[nodiscard]] static constexpr _Base128 _Modulo(const _Base128& _Num, const uint64_t _Den) noexcept {
        uint64_t _Rem;
        (void) _UDiv128(_Num._Word[1] % _Den, _Num._Word[0], _Den, _Rem);
        return _Rem;
    }
    [[nodiscard]] static constexpr _Base128 _Modulo(_Base128 _Num, _Base128 _Den) noexcept {
        
        if (_Den._Word[1] >= _Num._Word[1]) {
            if (_Den._Word[1] > _Num._Word[1]) {
                return _Num;
            }

            if (_Den._Word[0] <= _Num._Word[0]) {
                return _Num._Word[1] == 0 ? _Num._Word[0] % _Den._Word[0] : _Num._Word[0] - _Den._Word[0];
            }

            return _Num;
        }

        
        if (_Den._Word[1] == 0) {

            if (_Den._Word[0] < (1ull << 32)) {
                return _Modulo(_Num, static_cast<uint32_t>(_Den._Word[0]));
            } else
#line 544 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_int128.hpp"
            {
                return _Modulo(_Num, _Den._Word[0]);
            }
        }


#line 601 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_int128.hpp"
        auto __d                   = ::std:: countl_zero(_Den._Word[1]);
        const bool _Three_word_den = __d >= 32;
        __d &= 31;
        uint32_t __u[5]{
            static_cast<uint32_t>(_Num._Word[0] << __d),
            static_cast<uint32_t>(_Num._Word[0] >> (32 - __d)),
            static_cast<uint32_t>(_Num._Word[1] << __d),
            static_cast<uint32_t>(_Num._Word[1] >> (32 - __d)),
            0,
        };
        uint32_t __v[4] = {
            static_cast<uint32_t>(_Den._Word[0] << __d),
            static_cast<uint32_t>(_Den._Word[0] >> (32 - __d)),
            static_cast<uint32_t>(_Den._Word[1] << __d),
            static_cast<uint32_t>(_Den._Word[1] >> (32 - __d)),
        };
        if (__d != 0) {
            __u[2] |= _Num._Word[0] >> (64 - __d);
            __u[4] |= _Num._Word[1] >> (64 - __d);
            __v[2] |= _Den._Word[0] >> (64 - __d);
        }

        uint32_t __q[2];
        if (_Three_word_den) {
            
            _Knuth_4_3_1_D(__u, 5, __v, 3, __q);
            
        } else {
            
            _Knuth_4_3_1_D(__u, 5, __v, 4, __q);
        }
        

        _Num._Word[0] = (static_cast<uint64_t>(__u[1]) << 32) | __u[0];
        _Num._Word[1] = (static_cast<uint64_t>(__u[3]) << 32) | __u[2];
#line 637 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_int128.hpp"
        _Num >>= __d;
        return _Num;
    }

    template <integral _Ty>
    friend constexpr _Ty& operator&=(_Ty& _Left, const _Base128& _Right) noexcept {
        _Left &= _Right._Word[0];
        return _Left;
    }

    template <integral _Ty>
    friend constexpr _Ty& operator^=(_Ty& _Left, const _Base128& _Right) noexcept {
        _Left ^= _Right._Word[0];
        return _Left;
    }

    template <integral _Ty>
    friend constexpr _Ty& operator|=(_Ty& _Left, const _Base128& _Right) noexcept {
        _Left |= _Right._Word[0];
        return _Left;
    }
};

struct _Signed128;

struct _Unsigned128 : _Base128 {
    using _Signed_type   = _Signed128;
    using _Unsigned_type = _Unsigned128;

    using _Base128::_Base128;
    constexpr explicit _Unsigned128(const _Base128& _That) noexcept : _Base128{_That} {}

    constexpr _Unsigned128& operator=(const _Base128& _That) noexcept {
        _Base128::operator=(_That);
        return *this;
    }

    [[nodiscard]] friend constexpr strong_ordering operator<=>(
        const _Unsigned128& _Left, const _Unsigned128& _Right) noexcept {
        strong_ordering _Ord = _Left._Word[1] <=> _Right._Word[1];
        if (_Ord == strong_ordering::equal) {
            _Ord = _Left._Word[0] <=> _Right._Word[0];
        }
        return _Ord;
    }

    [[nodiscard]] friend constexpr _Unsigned128 operator<<(const _Unsigned128& _Left, const _Base128& _Right) noexcept {
        auto _Tmp{_Left};
        _Tmp._Left_shift(static_cast<unsigned char>(_Right._Word[0]));
        return _Tmp;
    }

    template <integral _Ty>
    constexpr _Unsigned128& operator<<=(const _Ty _Count) noexcept {
        _Left_shift(static_cast<unsigned char>(_Count));
        return *this;
    }
    constexpr _Unsigned128& operator<<=(const _Base128& _Count) noexcept {
        _Left_shift(static_cast<unsigned char>(_Count._Word[0]));
        return *this;
    }

    [[nodiscard]] friend constexpr _Unsigned128 operator>>(const _Unsigned128& _Left, const _Base128& _Right) noexcept {
        auto _Tmp{_Left};
        _Tmp._Unsigned_right_shift(static_cast<unsigned char>(_Right._Word[0]));
        return _Tmp;
    }

    template <integral _Ty>
    constexpr _Unsigned128& operator>>=(const _Ty _Count) noexcept {
        _Unsigned_right_shift(static_cast<unsigned char>(_Count));
        return *this;
    }
    constexpr _Unsigned128& operator>>=(const _Base128& _Count) noexcept {
        _Unsigned_right_shift(static_cast<unsigned char>(_Count._Word[0]));
        return *this;
    }

    constexpr _Unsigned128& operator++() noexcept {
        if (++_Word[0] == 0) {
            ++_Word[1];
        }
        return *this;
    }
    constexpr _Unsigned128 operator++(int) noexcept {
        auto _Tmp = *this;
        ++*this;
        return _Tmp;
    }

    constexpr _Unsigned128& operator--() noexcept {
        if (_Word[0]-- == 0) {
            --_Word[1];
        }
        return *this;
    }
    constexpr _Unsigned128 operator--(int) noexcept {
        auto _Tmp = *this;
        --*this;
        return _Tmp;
    }

    [[nodiscard]] constexpr _Unsigned128 operator+() const noexcept {
        return *this;
    }

    [[nodiscard]] constexpr _Unsigned128 operator-() const noexcept {
        return _Unsigned128{} - *this;
    }

    [[nodiscard]] constexpr _Unsigned128 operator~() const noexcept {
        return _Unsigned128{~_Word[0], ~_Word[1]};
    }

    [[nodiscard]] friend constexpr _Unsigned128 operator+(const _Base128& _Left, const _Base128& _Right) noexcept {
        _Unsigned128 _Result;
        const auto _Carry = _AddCarry64(0, _Left._Word[0], _Right._Word[0], _Result._Word[0]);
        _AddCarry64(_Carry, _Left._Word[1], _Right._Word[1], _Result._Word[1]);
        return _Result;
    }

    constexpr _Unsigned128& operator+=(const _Base128& _That) noexcept {
        const auto _Carry = _AddCarry64(0, _Word[0], _That._Word[0], _Word[0]);
        _AddCarry64(_Carry, _Word[1], _That._Word[1], _Word[1]);
        return *this;
    }
    template <integral _Ty>
    friend constexpr _Ty& operator+=(_Ty& _Left, const _Unsigned128& _Right) noexcept {
        _Left += _Right._Word[0];
        return _Left;
    }

    [[nodiscard]] friend constexpr _Unsigned128 operator-(const _Base128& _Left, const _Base128& _Right) noexcept {
        _Unsigned128 _Result;
        const auto _Borrow = _SubBorrow64(0, _Left._Word[0], _Right._Word[0], _Result._Word[0]);
        _SubBorrow64(_Borrow, _Left._Word[1], _Right._Word[1], _Result._Word[1]);
        return _Result;
    }

    constexpr _Unsigned128& operator-=(const _Base128& _That) noexcept {
        const auto _Borrow = _SubBorrow64(0, _Word[0], _That._Word[0], _Word[0]);
        _SubBorrow64(_Borrow, _Word[1], _That._Word[1], _Word[1]);
        return *this;
    }
    template <integral _Ty>
    friend constexpr _Ty& operator-=(_Ty& _Left, const _Unsigned128& _Right) noexcept {
        _Left -= _Right._Word[0];
        return _Left;
    }

    [[nodiscard]] friend constexpr _Unsigned128 operator*(const _Base128& _Left, const _Base128& _Right) noexcept {
        return _Unsigned128{_Base128::_Multiply(_Left, _Right)};
    }

    constexpr _Unsigned128& operator*=(const _Base128& _That) noexcept {
        *this = *this * _That;
        return *this;
    }
    template <integral _Ty>
    friend constexpr _Ty& operator*=(_Ty& _Left, const _Unsigned128& _Right) noexcept {
        _Left *= _Right._Word[0];
        return _Left;
    }

    template <integral _Ty>
    [[nodiscard]] friend constexpr _Unsigned128 operator/(const _Unsigned128& _Num, const _Ty _Den) noexcept {

        if constexpr (sizeof(_Ty) <= 4) {
            return _Unsigned128{_Base128::_Divide(_Num, static_cast<uint32_t>(_Den))};
        } else
#line 808 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_int128.hpp"
        {
            return _Unsigned128{_Base128::_Divide(_Num, static_cast<uint64_t>(_Den))};
        }
    }
    [[nodiscard]] friend constexpr _Unsigned128 operator/(const _Base128& _Num, const _Base128& _Den) noexcept {
        return _Unsigned128{_Base128::_Divide(_Num, _Den)};
    }

    template <integral _Ty>
    constexpr _Unsigned128& operator/=(const _Ty _That) noexcept {

        if constexpr (sizeof(_Ty) <= 4) {
            *this = _Unsigned128{_Base128::_Divide(*this, static_cast<uint32_t>(_That))};
        } else
#line 823 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_int128.hpp"
        {
            *this = _Unsigned128{_Base128::_Divide(*this, static_cast<uint64_t>(_That))};
        }
        return *this;
    }
    constexpr _Unsigned128& operator/=(const _Base128& _That) noexcept {
        *this = _Unsigned128{_Base128::_Divide(*this, _That)};
        return *this;
    }
    template <integral _Ty>
    friend constexpr _Ty& operator/=(_Ty& _Left, const _Unsigned128& _Right) noexcept {
        if (_Right._Word[1] != 0) {
            _Left = 0;
        } else {
            _Left /= _Right._Word[0];
        }
        return _Left;
    }

    template <integral _Ty>
    [[nodiscard]] friend constexpr _Unsigned128 operator%(const _Base128& _Num, const _Ty _Den) noexcept {

        if constexpr (sizeof(_Ty) <= 4) {
            return _Unsigned128{_Base128::_Modulo(_Num, static_cast<uint32_t>(_Den))};
        } else
#line 849 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_int128.hpp"
        {
            return _Unsigned128{_Base128::_Modulo(_Num, static_cast<uint64_t>(_Den))};
        }
    }
    [[nodiscard]] friend constexpr _Unsigned128 operator%(const _Base128& _Num, const _Base128& _Den) noexcept {
        return _Unsigned128{_Base128::_Modulo(_Num, _Den)};
    }

    template <integral _Ty>
    constexpr _Unsigned128& operator%=(const _Ty _Den) noexcept {
        *this = *this % _Den;
        return *this;
    }
    constexpr _Unsigned128& operator%=(const _Base128& _Den) noexcept {
        *this = *this % _Den;
        return *this;
    }
    template <integral _Ty>
    friend constexpr _Ty& operator%=(_Ty& _Left, const _Unsigned128& _Right) noexcept {
        if (_Right._Word[1] == 0) {
            _Left %= _Right._Word[0];
        }
        return _Left;
    }

    [[nodiscard]] friend constexpr _Unsigned128 operator&(const _Base128& _Left, const _Base128& _Right) noexcept {
        return _Unsigned128{_Left._Word[0] & _Right._Word[0], _Left._Word[1] & _Right._Word[1]};
    }

    constexpr _Unsigned128& operator&=(const _Base128& _That) noexcept {
        _Word[0] &= _That._Word[0];
        _Word[1] &= _That._Word[1];
        return *this;
    }

    [[nodiscard]] friend constexpr _Unsigned128 operator^(const _Base128& _Left, const _Base128& _Right) noexcept {
        return _Unsigned128{_Left._Word[0] ^ _Right._Word[0], _Left._Word[1] ^ _Right._Word[1]};
    }

    constexpr _Unsigned128& operator^=(const _Base128& _That) noexcept {
        _Word[0] ^= _That._Word[0];
        _Word[1] ^= _That._Word[1];
        return *this;
    }

    [[nodiscard]] friend constexpr _Unsigned128 operator|(const _Base128& _Left, const _Base128& _Right) noexcept {
        return _Unsigned128{_Left._Word[0] | _Right._Word[0], _Left._Word[1] | _Right._Word[1]};
    }

    constexpr _Unsigned128& operator|=(const _Base128& _That) noexcept {
        _Word[0] |= _That._Word[0];
        _Word[1] |= _That._Word[1];
        return *this;
    }
};

template <>
class numeric_limits<_Unsigned128> : public _Num_int_base {
public:
    [[nodiscard]] static constexpr _Unsigned128(min)() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr _Unsigned128(max)() noexcept {
        return _Unsigned128{~0ull, ~0ull};
    }

    [[nodiscard]] static constexpr _Unsigned128 lowest() noexcept {
        return (min) ();
    }

    [[nodiscard]] static constexpr _Unsigned128 epsilon() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr _Unsigned128 round_error() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr _Unsigned128 denorm_min() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr _Unsigned128 infinity() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr _Unsigned128 quiet_NaN() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr _Unsigned128 signaling_NaN() noexcept {
        return 0;
    }

    static constexpr bool is_modulo = true;
    static constexpr int digits     = 128;
    static constexpr int digits10   = 38;
};

template <integral _Ty>
struct common_type<_Ty, _Unsigned128> {
    using type = _Unsigned128;
};
template <integral _Ty>
struct common_type<_Unsigned128, _Ty> {
    using type = _Unsigned128;
};

struct _Signed128 : _Base128 {
    using _Signed_type   = _Signed128;
    using _Unsigned_type = _Unsigned128;

    using _Base128::_Base128;
    constexpr explicit _Signed128(const _Base128& _That) noexcept : _Base128{_That} {}

    constexpr _Signed128& operator=(const _Base128& _That) noexcept {
        _Base128::operator=(_That);
        return *this;
    }

    [[nodiscard]] friend constexpr strong_ordering operator<=>(
        const _Signed128& _Left, const _Signed128& _Right) noexcept {
        strong_ordering _Ord = static_cast<int64_t>(_Left._Word[1]) <=> static_cast<int64_t>(_Right._Word[1]);
        if (_Ord == strong_ordering::equal) {
            _Ord = _Left._Word[0] <=> _Right._Word[0];
        }
        return _Ord;
    }

    [[nodiscard]] friend constexpr _Signed128 operator<<(const _Signed128& _Left, const _Base128& _Right) noexcept {
        auto _Tmp{_Left};
        _Tmp._Left_shift(static_cast<unsigned char>(_Right._Word[0]));
        return _Tmp;
    }

    template <integral _Ty>
    constexpr _Signed128& operator<<=(const _Ty _Count) noexcept {
        _Left_shift(static_cast<unsigned char>(_Count));
        return *this;
    }
    constexpr _Signed128& operator<<=(const _Base128& _Count) noexcept {
        _Left_shift(static_cast<unsigned char>(_Count._Word[0]));
        return *this;
    }

    constexpr void _Signed_right_shift(const unsigned char _Count) noexcept {
        if (_Count == 0) {
            return;
        }

        if (_Count >= 64) {
            _Word[0] = static_cast<uint64_t>(static_cast<int64_t>(_Word[1]) >> (_Count % 64));
            _Word[1] = (_Word[1] & (1ull << 63)) == 0 ? 0 : ~0ull;
            return;
        }


#line 1011 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_int128.hpp"
        {
            _Word[0] = (_Word[0] >> _Count) | (_Word[1] << (64 - _Count));
        }

        _Word[1] = static_cast<uint64_t>(static_cast<int64_t>(_Word[1]) >> _Count);
    }

    [[nodiscard]] friend constexpr _Signed128 operator>>(const _Signed128& _Left, const _Base128& _Right) noexcept {
        auto _Tmp{_Left};
        _Tmp._Signed_right_shift(static_cast<unsigned char>(_Right._Word[0]));
        return _Tmp;
    }

    template <integral _Ty>
    constexpr _Signed128& operator>>=(const _Ty _Count) noexcept {
        _Signed_right_shift(static_cast<unsigned char>(_Count));
        return *this;
    }
    constexpr _Signed128& operator>>=(const _Base128& _Count) noexcept {
        _Signed_right_shift(static_cast<unsigned char>(_Count._Word[0]));
        return *this;
    }

    constexpr _Signed128& operator++() noexcept {
        if (++_Word[0] == 0) {
            ++_Word[1];
        }
        return *this;
    }
    constexpr _Signed128 operator++(int) noexcept {
        auto _Tmp = *this;
        ++*this;
        return _Tmp;
    }

    constexpr _Signed128& operator--() noexcept {
        if (_Word[0]-- == 0) {
            --_Word[1];
        }
        return *this;
    }
    constexpr _Signed128 operator--(int) noexcept {
        auto _Tmp = *this;
        --*this;
        return _Tmp;
    }

    [[nodiscard]] constexpr _Signed128 operator+() const noexcept {
        return *this;
    }

    [[nodiscard]] constexpr _Signed128 operator-() const noexcept {
        return _Signed128{} - *this;
    }

    [[nodiscard]] constexpr _Signed128 operator~() const noexcept {
        return _Signed128{~_Word[0], ~_Word[1]};
    }

    [[nodiscard]] friend constexpr _Signed128 operator+(const _Signed128& _Left, const _Signed128& _Right) noexcept {
        _Signed128 _Result;
        const auto _Carry = _AddCarry64(0, _Left._Word[0], _Right._Word[0], _Result._Word[0]);
        _AddCarry64(_Carry, _Left._Word[1], _Right._Word[1], _Result._Word[1]);
        return _Result;
    }

    constexpr _Signed128& operator+=(const _Base128& _That) noexcept {
        const auto _Carry = _AddCarry64(0, _Word[0], _That._Word[0], _Word[0]);
        _AddCarry64(_Carry, _Word[1], _That._Word[1], _Word[1]);
        return *this;
    }
    template <integral _Ty>
    friend constexpr _Ty& operator+=(_Ty& _Left, const _Signed128& _Right) noexcept {
        _Left = static_cast<_Ty>(_Signed128{_Left} + _Right);
        return _Left;
    }

    [[nodiscard]] friend constexpr _Signed128 operator-(const _Signed128& _Left, const _Signed128& _Right) noexcept {
        _Signed128 _Result;
        const auto _Borrow = _SubBorrow64(0, _Left._Word[0], _Right._Word[0], _Result._Word[0]);
        _SubBorrow64(_Borrow, _Left._Word[1], _Right._Word[1], _Result._Word[1]);
        return _Result;
    }

    constexpr _Signed128& operator-=(const _Base128& _That) noexcept {
        const auto _Borrow = _SubBorrow64(0, _Word[0], _That._Word[0], _Word[0]);
        _SubBorrow64(_Borrow, _Word[1], _That._Word[1], _Word[1]);
        return *this;
    }
    template <integral _Ty>
    friend constexpr _Ty& operator-=(_Ty& _Left, const _Signed128& _Right) noexcept {
        _Left = static_cast<_Ty>(_Signed128{_Left} - _Right);
        return _Left;
    }

    constexpr void _Strip_negative(bool& _Flip) noexcept {
        if ((_Word[1] & (1ull << 63)) != 0) {
            *this = -*this;
            _Flip = !_Flip;
        }
    }

    [[nodiscard]] friend constexpr _Signed128 operator*(_Signed128 _Left, _Signed128 _Right) noexcept {
        bool _Negative = false;
        _Left._Strip_negative(_Negative);
        _Right._Strip_negative(_Negative);
        _Signed128 _Result{_Base128::_Multiply(_Left, _Right)};
        if (_Negative) {
            _Result = -_Result;
        }
        return _Result;
    }

    template <integral _Ty>
    constexpr _Signed128& operator*=(const _Ty _That) noexcept {
        *this = *this * _That;
        return *this;
    }
    constexpr _Signed128& operator*=(const _Signed128& _That) noexcept {
        *this = *this * _That;
        return *this;
    }
    constexpr _Signed128& operator*=(const _Unsigned128& _That) noexcept {
        *this = _Signed128{static_cast<const _Base128&>(*this) * _That};
        return *this;
    }
    template <integral _Ty>
    friend constexpr _Ty& operator*=(_Ty& _Left, const _Signed128& _Right) noexcept {
        _Left = static_cast<_Ty>(_Signed128{_Left} * _Right);
        return _Left;
    }

    template <integral _Ty>
    [[nodiscard]] friend constexpr _Signed128 operator/(_Signed128 _Num, _Ty _Den) noexcept {
        bool _Negative = false;
        _Num._Strip_negative(_Negative);
        if constexpr (is_signed_v<_Ty>) {
            if (_Den < 0) {
                _Den      = -_Den;
                _Negative = !_Negative;
            }
        }

        _Signed128 _Result;

        if constexpr (sizeof(_Ty) <= 4) {
            _Result = _Signed128{_Base128::_Divide(_Num, static_cast<uint32_t>(_Den))};
        } else
#line 1160 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_int128.hpp"
        {
            _Result = _Signed128{_Base128::_Divide(_Num, static_cast<uint64_t>(_Den))};
        }

        if (_Negative) {
            _Result = -_Result;
        }
        return _Result;
    }
    [[nodiscard]] friend constexpr _Signed128 operator/(_Signed128 _Num, _Signed128 _Den) noexcept {
        bool _Negative = false;
        _Num._Strip_negative(_Negative);
        _Den._Strip_negative(_Negative);
        _Signed128 _Result{_Base128::_Divide(_Num, _Den)};
        if (_Negative) {
            _Result = -_Result;
        }
        return _Result;
    }

    template <integral _Ty>
    constexpr _Signed128& operator/=(const _Ty _That) noexcept {
        *this = *this / _That;
        return *this;
    }
    constexpr _Signed128& operator/=(const _Signed128& _That) noexcept {
        *this = *this / _That;
        return *this;
    }
    constexpr _Signed128& operator/=(const _Unsigned128& _That) noexcept {
        *this = _Signed128{static_cast<_Base128&>(*this) / _That};
        return *this;
    }
    template <integral _Ty>
    friend constexpr _Ty& operator/=(_Ty& _Left, const _Signed128& _Right) noexcept {
        _Left = static_cast<_Ty>(_Signed128{_Left} / _Right);
        return _Left;
    }

    [[nodiscard]] friend constexpr _Signed128 operator%(_Signed128 _Left, _Signed128 _Right) noexcept {
        bool _Negative = false;
        _Left._Strip_negative(_Negative);

        if ((_Right._Word[1] & (1ull << 63)) != 0) {
            _Right = -_Right;
            
        }

        _Unsigned128 _Result{_Base128::_Modulo(_Left, _Right)};
        if (_Negative) {
            _Result = -_Result;
        }
        return _Signed128{_Result};
    }

    template <integral _Ty>
    constexpr _Signed128& operator%=(const _Ty _That) noexcept {
        *this = *this % _That;
        return *this;
    }
    constexpr _Signed128& operator%=(const _Signed128& _That) noexcept {
        *this = *this % _That;
        return *this;
    }
    constexpr _Signed128& operator%=(const _Unsigned128& _That) noexcept {
        *this = static_cast<const _Base128&>(*this) % _That;
        return *this;
    }
    template <integral _Ty>
    friend constexpr _Ty& operator%=(_Ty& _Left, const _Signed128& _Right) noexcept {
        _Left = static_cast<_Ty>(_Signed128{_Left} % _Right);
        return _Left;
    }

    [[nodiscard]] friend constexpr _Signed128 operator&(const _Signed128& _Left, const _Signed128& _Right) noexcept {
        return _Signed128{_Left._Word[0] & _Right._Word[0], _Left._Word[1] & _Right._Word[1]};
    }

    constexpr _Signed128& operator&=(const _Base128& _That) noexcept {
        _Word[0] &= _That._Word[0];
        _Word[1] &= _That._Word[1];
        return *this;
    }

    [[nodiscard]] friend constexpr _Signed128 operator^(const _Signed128& _Left, const _Signed128& _Right) noexcept {
        return _Signed128{_Left._Word[0] ^ _Right._Word[0], _Left._Word[1] ^ _Right._Word[1]};
    }

    constexpr _Signed128& operator^=(const _Base128& _That) noexcept {
        _Word[0] ^= _That._Word[0];
        _Word[1] ^= _That._Word[1];
        return *this;
    }

    [[nodiscard]] friend constexpr _Signed128 operator|(const _Signed128& _Left, const _Signed128& _Right) noexcept {
        return _Signed128{_Left._Word[0] | _Right._Word[0], _Left._Word[1] | _Right._Word[1]};
    }

    constexpr _Signed128& operator|=(const _Base128& _That) noexcept {
        _Word[0] |= _That._Word[0];
        _Word[1] |= _That._Word[1];
        return *this;
    }
};

template <>
class numeric_limits<_Signed128> : public _Num_int_base {
public:
    [[nodiscard]] static constexpr _Signed128(min)() noexcept {
        return _Signed128{0ull, 1ull << 63};
    }

    [[nodiscard]] static constexpr _Signed128(max)() noexcept {
        return _Signed128{~0ull, ~0ull >> 1};
    }

    [[nodiscard]] static constexpr _Signed128 lowest() noexcept {
        return (min) ();
    }

    [[nodiscard]] static constexpr _Signed128 epsilon() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr _Signed128 round_error() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr _Signed128 denorm_min() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr _Signed128 infinity() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr _Signed128 quiet_NaN() noexcept {
        return 0;
    }

    [[nodiscard]] static constexpr _Signed128 signaling_NaN() noexcept {
        return 0;
    }

    static constexpr int digits   = 127;
    static constexpr int digits10 = 38;
};

template <integral _Ty>
struct common_type<_Ty, _Signed128> {
    using type = _Signed128;
};
template <integral _Ty>
struct common_type<_Signed128, _Ty> {
    using type = _Signed128;
};

template <>
struct common_type<_Signed128, _Unsigned128> {
    using type = _Unsigned128;
};
template <>
struct common_type<_Unsigned128, _Signed128> {
    using type = _Unsigned128;
};


}


#pragma warning(pop)
#pragma pack(pop)
#line 1336 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_int128.hpp"
#line 1337 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_int128.hpp"
#line 1338 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\__msvc_int128.hpp"
#line 15 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
namespace ranges {
    

    template <class _Ty>
    inline constexpr bool _Is_initializer_list = _Is_specialization_v<remove_cvref_t<_Ty>, initializer_list>;

    
    template <class _Rng>
    concept viewable_range = range<_Rng>
        && ((view<remove_cvref_t<_Rng>> && constructible_from<remove_cvref_t<_Rng>, _Rng>)
            || (!view<remove_cvref_t<_Rng>>
                && (is_lvalue_reference_v<_Rng>
                    || (movable<remove_reference_t<_Rng>> && !_Is_initializer_list<_Rng>))));

    template <class _Rng>
    concept _Simple_view = view<_Rng> && range<const _Rng>
        && same_as<iterator_t<_Rng>, iterator_t<const _Rng>>
        && same_as<sentinel_t<_Rng>, sentinel_t<const _Rng>>;

    template <class _Ty>
    concept _Copy_constructible_object = copy_constructible<_Ty> && _Destructible_object<_Ty>;

    template <class _It>
    concept _Has_arrow = input_iterator<_It>
        && (is_pointer_v<_It> || _Has_member_arrow<_It&>);
    

    template <bool _IsConst, class _Ty>
    using _Maybe_const = conditional_t<_IsConst, const _Ty, _Ty>;

    template <bool _IsWrapped, class _Ty>
    using _Maybe_wrapped = conditional_t<_IsWrapped, _Ty, _Unwrapped_t<_Ty>>;

    namespace _Pipe {
        
        template <class _Left, class _Right>
        concept _Can_pipe = requires(_Left&& __l, _Right&& __r) {
            static_cast<_Right&&>(__r)(static_cast<_Left&&>(__l));
        };

        template <class _Left, class _Right>
        concept _Can_compose = constructible_from<remove_cvref_t<_Left>, _Left>
            && constructible_from<remove_cvref_t<_Right>, _Right>;
        

        template <class, class>
        struct _Pipeline;

        template <class _Derived>
        struct _Base {
            
            template <class _Other>
                requires _Can_compose<_Derived, _Other>
            constexpr auto operator|(_Base<_Other>&& __r) && noexcept(
                noexcept(_Pipeline{static_cast<_Derived&&>(*this), static_cast<_Other&&>(__r)})) {
                
                ;
                ;
                return _Pipeline{static_cast<_Derived&&>(*this), static_cast<_Other&&>(__r)};
            }

            
            template <class _Other>
                requires _Can_compose<_Derived, const _Other&>
            constexpr auto operator|(const _Base<_Other>& __r) && noexcept(
                noexcept(_Pipeline{static_cast<_Derived&&>(*this), static_cast<const _Other&>(__r)})) {
                
                ;
                ;
                return _Pipeline{static_cast<_Derived&&>(*this), static_cast<const _Other&>(__r)};
            }

            
            template <class _Other>
                requires _Can_compose<const _Derived&, _Other>
            constexpr auto operator|(_Base<_Other>&& __r) const& noexcept(
                noexcept(_Pipeline{static_cast<const _Derived&>(*this), static_cast<_Other&&>(__r)})) {
                
                ;
                ;
                return _Pipeline{static_cast<const _Derived&>(*this), static_cast<_Other&&>(__r)};
            }

            
            template <class _Other>
                requires _Can_compose<const _Derived&, const _Other&>
            constexpr auto operator|(const _Base<_Other>& __r) const& noexcept(
                noexcept(_Pipeline{static_cast<const _Derived&>(*this), static_cast<const _Other&>(__r)})) {
                
                ;
                ;
                return _Pipeline{static_cast<const _Derived&>(*this), static_cast<const _Other&>(__r)};
            }

            template <_Can_pipe<const _Derived&> _Left>
            friend constexpr auto operator|(_Left&& __l, const _Base& __r)


                noexcept(noexcept(static_cast<const _Derived&>(__r)(::std:: forward<_Left>(__l))))
#line 131 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
            {
                return static_cast<const _Derived&>(__r)(::std:: forward<_Left>(__l));
            }

            template <_Can_pipe<_Derived> _Left>
            friend constexpr auto operator|(_Left&& __l, _Base&& __r)


                noexcept(noexcept(static_cast<_Derived&&>(__r)(::std:: forward<_Left>(__l))))
#line 142 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
            {
                return static_cast<_Derived&&>(__r)(::std:: forward<_Left>(__l));
            }
        };

        template <class _Left, class _Right>
        struct _Pipeline : _Base<_Pipeline<_Left, _Right>> {
             _Left __l;
             _Right __r;

            template <class _Ty1, class _Ty2>
            constexpr explicit _Pipeline(_Ty1&& _Val1, _Ty2&& _Val2) noexcept(
                is_nothrow_convertible_v<_Ty1, _Left>&& is_nothrow_convertible_v<_Ty2, _Right>)
                : __l(::std:: forward<_Ty1>(_Val1)), __r(::std:: forward<_Ty2>(_Val2)) {}

            template <class _Ty>
            [[nodiscard]] constexpr auto operator()(_Ty&& _Val) noexcept(
                noexcept(__r(__l(::std:: forward<_Ty>(_Val))))) requires requires {
                __r(__l(static_cast<_Ty&&>(_Val)));
            }
            { return __r(__l(::std:: forward<_Ty>(_Val))); }

            template <class _Ty>
            [[nodiscard]] constexpr auto operator()(_Ty&& _Val) const
                noexcept(noexcept(__r(__l(::std:: forward<_Ty>(_Val))))) requires requires {
                __r(__l(static_cast<_Ty&&>(_Val)));
            }
            { return __r(__l(::std:: forward<_Ty>(_Val))); }
        };

        template <class _Ty1, class _Ty2>
        _Pipeline(_Ty1, _Ty2) -> _Pipeline<_Ty1, _Ty2>;
    } 

    template <range _Rng, class _Derived>
    class _Cached_position : public view_interface<_Derived> {
        static_assert(_Always_false<_Rng>, "A range must be at least forward for position caching to be worthwhile.");
    };

    template <forward_range _Rng, class _Derived>
    class _Cached_position<_Rng, _Derived> : public view_interface<_Derived> {
    private:
        using _It = iterator_t<_Rng>;

         _It _Pos{};
        bool _Cached = false;

    protected:
        _Cached_position()  = default;
        ~_Cached_position() = default;

        
        constexpr _Cached_position(const _Cached_position&) noexcept(is_nothrow_default_constructible_v<_It>) {}
        constexpr _Cached_position& operator=(const _Cached_position&) noexcept(noexcept(_Pos = _It{})) {
            _Pos    = _It{};
            _Cached = false;
            return *this;
        }

        
        constexpr _Cached_position(_Cached_position&& _Other) noexcept(noexcept(_Pos = _It{})) {
            _Other._Pos    = _It{};
            _Other._Cached = false;
        }
        constexpr _Cached_position& operator=(_Cached_position&& _Other) noexcept(noexcept(_Pos = _It{})) {
            _Pos           = _It{};
            _Cached        = false;
            _Other._Pos    = _It{};
            _Other._Cached = false;
            return *this;
        }

        [[nodiscard]] constexpr bool _Has_cache() const noexcept { 
            return _Cached;
        }

        [[nodiscard]] constexpr _It _Get_cache(_Rng&) const noexcept(is_nothrow_copy_constructible_v<_It>) {
            ;
            return _Pos;
        }

        constexpr void _Set_cache(_Rng&, _It _Iter) noexcept(is_nothrow_move_assignable_v<_It>) {
            _Pos    = ::std:: move(_Iter);
            _Cached = true;
        }
    };

    template <random_access_range _Rng, class _Derived>
    class _Cached_position<_Rng, _Derived> : public view_interface<_Derived> {
    private:
        using _It = iterator_t<_Rng>;

        range_difference_t<_Rng> _Off = -1;

    protected:
        _Cached_position()  = default;
        ~_Cached_position() = default;

        
        _Cached_position(const _Cached_position&) = default;
        _Cached_position& operator=(const _Cached_position&) = default;

        
        constexpr _Cached_position(_Cached_position&& _Other) noexcept
            : _Off(::std:: exchange(_Other._Off, range_difference_t<_Rng>{-1})) {}
        constexpr _Cached_position& operator=(_Cached_position&& _Other) noexcept {
            _Off = ::std:: exchange(_Other._Off, range_difference_t<_Rng>{-1});
            return *this;
        }

        [[nodiscard]] constexpr bool _Has_cache() const noexcept { 
            return _Off >= range_difference_t<_Rng>{0};
        }

        [[nodiscard]] constexpr _It _Get_cache(_Rng& _Range) const noexcept(noexcept(::std::ranges:: begin(_Range) + _Off)) {
            ;
            return ::std::ranges:: begin(_Range) + _Off;
        }

        constexpr void _Set_cache(_Rng& _Range, const _It& _Iter) noexcept(
            noexcept(_Off = _Iter - ::std::ranges:: begin(_Range))) {
            _Off = _Iter - ::std::ranges:: begin(_Range);
        }
    };

    template <bool _Enable, class _Rng, class _Derived>
    using _Cached_position_t = conditional_t<_Enable, _Cached_position<_Rng, _Derived>, view_interface<_Derived>>;

    template <_Copy_constructible_object _Ty>
    class _Copyable_box { 
    public:
        constexpr _Copyable_box() noexcept(is_nothrow_default_constructible_v<_Ty>) requires default_initializable<_Ty>
            : _Val(), _Engaged{true} {}

        template <class... _Types>
        constexpr _Copyable_box(in_place_t, _Types&&... _Args) noexcept(
            is_nothrow_constructible_v<_Ty, _Types...>) 
            : _Val(::std:: forward<_Types>(_Args)...), _Engaged{true} {}

        
        ~_Copyable_box() requires is_trivially_destructible_v<_Ty> = default;
        

        constexpr ~_Copyable_box() {
            if (_Engaged) {
                _Val.~_Ty();
            }
        }

        
        _Copyable_box(const _Copyable_box&) requires is_trivially_copy_constructible_v<_Ty> = default;
        

        constexpr _Copyable_box(const _Copyable_box& _That) : _Engaged{_That._Engaged} {
            if (_That._Engaged) {
                _Construct_in_place(_Val, _That._Val);
            }
        }

        
        _Copyable_box(_Copyable_box&&) requires is_trivially_move_constructible_v<_Ty> = default;
        

        constexpr _Copyable_box(_Copyable_box&& _That) : _Engaged{_That._Engaged} {
            if (_That._Engaged) {
                _Construct_in_place(_Val, ::std:: move(_That._Val));
            }
        }

        
        _Copyable_box& operator=(const _Copyable_box&) noexcept
            requires copyable<_Ty> && is_trivially_copy_assignable_v<_Ty> = default;
        

        constexpr _Copyable_box& operator=(const _Copyable_box& _That) noexcept(
            is_nothrow_copy_constructible_v<_Ty>&& is_nothrow_copy_assignable_v<_Ty>) 
            requires copyable<_Ty> {
            if (_Engaged) {
                if (_That._Engaged) {
                    _Val = _That._Val;
                } else {
                    _Val.~_Ty();
                    _Engaged = false;
                }
            } else {
                if (_That._Engaged) {
                    _Construct_in_place(_Val, _That._Val);
                    _Engaged = true;
                } else {
                    
                }
            }

            return *this;
        }

        constexpr _Copyable_box& operator=(const _Copyable_box& _That) noexcept(is_nothrow_copy_constructible_v<_Ty>) {
            if (::std:: addressof(_That) == this) {
                return *this;
            }

            if (_Engaged) {
                _Val.~_Ty();
                _Engaged = false;
            }

            if (_That._Engaged) {
                _Construct_in_place(_Val, _That._Val);
                _Engaged = true;
            }

            return *this;
        }

        
        _Copyable_box& operator=(_Copyable_box&&) noexcept
            requires movable<_Ty> && is_trivially_move_assignable_v<_Ty> = default;
        

        constexpr _Copyable_box& operator=(_Copyable_box&& _That) noexcept(
            is_nothrow_move_constructible_v<_Ty>&& is_nothrow_move_assignable_v<_Ty>) 
            requires movable<_Ty> {
            if (_Engaged) {
                if (_That._Engaged) {
                    _Val = ::std:: move(_That._Val);
                } else {
                    _Val.~_Ty();
                    _Engaged = false;
                }
            } else {
                if (_That._Engaged) {
                    _Construct_in_place(_Val, ::std:: move(_That._Val));
                    _Engaged = true;
                } else {
                    
                }
            }

            return *this;
        }

        constexpr _Copyable_box& operator=(_Copyable_box&& _That) noexcept(is_nothrow_move_constructible_v<_Ty>) {
            if (::std:: addressof(_That) == this) {
                return *this;
            }

            if (_Engaged) {
                _Val.~_Ty();
                _Engaged = false;
            }

            if (_That._Engaged) {
                _Construct_in_place(_Val, ::std:: move(_That._Val));
                _Engaged = true;
            }

            return *this;
        }

        constexpr explicit operator bool() const noexcept {
            return _Engaged;
        }

        [[nodiscard]] constexpr _Ty& operator*() noexcept {
            ;
            return _Val;
        }
        [[nodiscard]] constexpr const _Ty& operator*() const noexcept {
            ;
            return _Val;
        }

    private:
        union {
            _Ty _Val;
        };
        bool _Engaged;
    };

    
    template <_Copy_constructible_object _Ty>
        requires (copyable<_Ty>
            || (is_nothrow_copy_constructible_v<_Ty>
                && (movable<_Ty> || is_nothrow_move_constructible_v<_Ty>)))
    class _Copyable_box<_Ty> { 
        
    public:
        
        _Copyable_box() requires default_initializable<_Ty> = default;
        

        template <class... _Types>
        constexpr _Copyable_box(in_place_t, _Types&&... _Args) noexcept(
            is_nothrow_constructible_v<_Ty, _Types...>) 
            : _Val(::std:: forward<_Types>(_Args)...) {}

        _Copyable_box(const _Copyable_box&) = default;
        _Copyable_box(_Copyable_box&&)      = default;

        
        _Copyable_box& operator=(const _Copyable_box&) requires copyable<_Ty> = default;
        _Copyable_box& operator=(_Copyable_box&&) requires movable<_Ty> = default;
        

        constexpr _Copyable_box& operator=(const _Copyable_box& _That) noexcept {
            if (::std:: addressof(_That) != this) {
                _Val.~_Ty();
                _Construct_in_place(_Val, _That._Val);
            }

            return *this;
        }

        constexpr _Copyable_box& operator=(_Copyable_box&& _That) noexcept {
            if (::std:: addressof(_That) != this) {
                _Val.~_Ty();
                _Construct_in_place(_Val, ::std:: move(_That._Val));
            }

            return *this;
        }

        constexpr explicit operator bool() const noexcept {
            return true;
        }

        [[nodiscard]] constexpr _Ty& operator*() noexcept {
            return _Val;
        }
        [[nodiscard]] constexpr const _Ty& operator*() const noexcept {
            return _Val;
        }

    private:
         _Ty _Val{};
    };

    template <movable _Ty>
    class _Defaultabox { 
    public:
        constexpr _Defaultabox() noexcept {}

        
        ~_Defaultabox() requires is_trivially_destructible_v<_Ty> = default;
        

        constexpr ~_Defaultabox() {
            if (_Engaged) {
                _Val.~_Ty();
            }
        }

        
        _Defaultabox(const _Defaultabox&)
            requires copy_constructible<_Ty> && is_trivially_copy_constructible_v<_Ty> = default;
        

        constexpr _Defaultabox(const _Defaultabox& _That) requires copy_constructible<_Ty> : _Engaged{_That._Engaged} {
            if (_That._Engaged) {
                _Construct_in_place(_Val, _That._Val);
            }
        }

        
        _Defaultabox(_Defaultabox&&) requires is_trivially_move_constructible_v<_Ty> = default;
        

        constexpr _Defaultabox(_Defaultabox&& _That) : _Engaged{_That._Engaged} {
            if (_That._Engaged) {
                _Construct_in_place(_Val, ::std:: move(_That._Val));
            }
        }

        template <_Not_same_as<_Ty> _Uty>
            requires convertible_to<const _Uty&, _Ty>
        constexpr _Defaultabox(const _Defaultabox<_Uty>& _That) : _Engaged{_That} {
            if (_That) {
                _Construct_in_place(_Val, *_That);
            }
        }

        template <_Not_same_as<_Ty> _Uty>
            requires convertible_to<_Uty, _Ty>
        constexpr _Defaultabox(_Defaultabox<_Uty>&& _That) : _Engaged{_That} {
            if (_That) {
                _Construct_in_place(_Val, ::std:: move(*_That));
            }
        }

        
        _Defaultabox& operator=(const _Defaultabox&) noexcept
            requires copyable<_Ty> && is_trivially_copy_assignable_v<_Ty> = default;
        

        constexpr _Defaultabox& operator=(const _Defaultabox& _That) noexcept(
            is_nothrow_copy_constructible_v<_Ty>&& is_nothrow_copy_assignable_v<_Ty>) 
            requires copyable<_Ty> {
            if (_Engaged) {
                if (_That._Engaged) {
                    _Val = _That._Val;
                } else {
                    _Val.~_Ty();
                    _Engaged = false;
                }
            } else {
                if (_That._Engaged) {
                    _Construct_in_place(_Val, _That._Val);
                    _Engaged = true;
                } else {
                    
                }
            }

            return *this;
        }

        
        _Defaultabox& operator=(_Defaultabox&&) noexcept requires is_trivially_move_assignable_v<_Ty> = default;
        

        constexpr _Defaultabox& operator=(_Defaultabox&& _That) noexcept(
            is_nothrow_move_constructible_v<_Ty>&& is_nothrow_move_assignable_v<_Ty>)  {
            if (_Engaged) {
                if (_That._Engaged) {
                    _Val = ::std:: move(_That._Val);
                } else {
                    _Val.~_Ty();
                    _Engaged = false;
                }
            } else {
                if (_That._Engaged) {
                    _Construct_in_place(_Val, ::std:: move(_That._Val));
                    _Engaged = true;
                } else {
                    
                }
            }

            return *this;
        }

        constexpr _Defaultabox& operator=(_Ty&& _That) noexcept(
            is_nothrow_move_constructible_v<_Ty>&& is_nothrow_move_assignable_v<_Ty>) {
            if (_Engaged) {
                _Val = ::std:: move(_That);
            } else {
                _Construct_in_place(_Val, ::std:: move(_That));
                _Engaged = true;
            }

            return *this;
        }

        constexpr _Defaultabox& operator=(const _Ty& _That) noexcept(
            is_nothrow_copy_constructible_v<_Ty>&& is_nothrow_copy_assignable_v<_Ty>) requires copyable<_Ty> {
            if (_Engaged) {
                _Val = _That;
            } else {
                _Construct_in_place(_Val, _That);
                _Engaged = true;
            }

            return *this;
        }

        constexpr explicit operator bool() const noexcept {
            return _Engaged;
        }

        [[nodiscard]] constexpr _Ty& operator*() noexcept {
            ;
            return _Val;
        }
        [[nodiscard]] constexpr const _Ty& operator*() const noexcept {
            ;
            return _Val;
        }

        constexpr void _Reset() noexcept {
            if (_Engaged) {
                _Val.~_Ty();
                _Engaged = false;
            }
        }

        [[nodiscard]] constexpr bool operator==(const _Defaultabox& _That) const noexcept(noexcept(_Val == _That._Val)) {
            ;
            return _Engaged == _That._Engaged && (!_Engaged || _Val == _That._Val);
        }

    private:
        union {
            _Ty _Val;
        };
        bool _Engaged = false;
    };

    
    template <movable _Ty>
        requires default_initializable<_Ty>
    class _Defaultabox<_Ty> { 
        
    public:
        _Defaultabox() = default;

        template <_Not_same_as<_Ty> _Uty>
            requires convertible_to<const _Uty&, _Ty>
        constexpr _Defaultabox(const _Defaultabox<_Uty>& _That) {
            if (_That) {
                _Value = static_cast<_Ty>(*_That);
            }
        }

        template <_Not_same_as<_Ty> _Uty>
            requires convertible_to<_Uty, _Ty>
        constexpr _Defaultabox(_Defaultabox<_Uty>&& _That) {
            if (_That) {
                _Value = static_cast<_Ty>(::std:: move(*_That));
            }
        }

        constexpr _Defaultabox& operator=(const _Ty& _Right) noexcept(
            is_nothrow_copy_assignable_v<_Ty>) requires copyable<_Ty> {
            _Value = _Right;
            return *this;
        }
        constexpr _Defaultabox& operator=(_Ty&& _Right) noexcept(is_nothrow_move_assignable_v<_Ty>) {
            _Value = ::std:: move(_Right);
            return *this;
        }

        constexpr explicit operator bool() const noexcept {
            return true;
        }

        [[nodiscard]] constexpr _Ty& operator*() noexcept {
            return _Value;
        }
        [[nodiscard]] constexpr const _Ty& operator*() const noexcept {
            return _Value;
        }

        constexpr void _Reset() noexcept(noexcept(_Value = _Ty{})) {
            _Value = _Ty{};
        }

        [[nodiscard]] bool operator==(const _Defaultabox&) const = default;

    private:
         _Ty _Value{};
    };

    template <_Destructible_object _Ty, bool _Needs_operator_bool = true>
    class _Non_propagating_cache { 
    public:
        constexpr _Non_propagating_cache() noexcept {}

        constexpr ~_Non_propagating_cache() {
            if (_Engaged) {
                _Val.~_Ty();
            }
        }

        
        ~_Non_propagating_cache() requires is_trivially_destructible_v<_Ty> = default;
        

        constexpr _Non_propagating_cache(const _Non_propagating_cache&) noexcept {}

        constexpr _Non_propagating_cache(_Non_propagating_cache&& _Other) noexcept {
            if (_Other._Engaged) {
                _Other._Val.~_Ty();
                _Other._Engaged = false;
            }
        }

        constexpr _Non_propagating_cache& operator=(const _Non_propagating_cache& _Other) noexcept {
            if (::std:: addressof(_Other) == this) {
                return *this;
            }

            if (_Engaged) {
                _Val.~_Ty();
                _Engaged = false;
            }

            return *this;
        }

        constexpr _Non_propagating_cache& operator=(_Non_propagating_cache&& _Other) noexcept {
            if (_Engaged) {
                _Val.~_Ty();
                _Engaged = false;
            }

            if (_Other._Engaged) {
                _Other._Val.~_Ty();
                _Other._Engaged = false;
            }

            return *this;
        }

        [[nodiscard]] constexpr explicit operator bool() const noexcept requires _Needs_operator_bool {
            return _Engaged;
        }

        [[nodiscard]] constexpr _Ty& operator*() noexcept {
            ;
            return _Val;
        }
        [[nodiscard]] constexpr const _Ty& operator*() const noexcept {
            ;
            return _Val;
        }

        template <class... _Types>
        constexpr _Ty& _Emplace(_Types&&... _Args) noexcept(is_nothrow_constructible_v<_Ty, _Types...>) {
            if (_Engaged) {
                _Val.~_Ty();
                _Engaged = false;
            }

            _Construct_in_place(_Val, ::std:: forward<_Types>(_Args)...);
            _Engaged = true;

            return _Val;
        }

    private:
        union {
            _Ty _Val;
        };
        bool _Engaged = false;
    };

    template <_Destructible_object _Ty>
        requires is_trivially_destructible_v<_Ty>
    class _Non_propagating_cache<_Ty, false> { 
                                               
    public:
        constexpr _Non_propagating_cache() noexcept {}

        ~_Non_propagating_cache() = default;

        constexpr _Non_propagating_cache(const _Non_propagating_cache&) noexcept {}

        constexpr _Non_propagating_cache(_Non_propagating_cache&&) noexcept {}

        constexpr _Non_propagating_cache& operator=(const _Non_propagating_cache&) noexcept {
            return *this;
        }

        constexpr _Non_propagating_cache& operator=(_Non_propagating_cache&&) noexcept {
            return *this;
        }

        [[nodiscard]] constexpr _Ty& operator*() noexcept {
            return _Val;
        }
        [[nodiscard]] constexpr const _Ty& operator*() const noexcept {
            return _Val;
        }

        template <class... _Types>
        constexpr _Ty& _Emplace(_Types&&... _Args) noexcept(is_nothrow_constructible_v<_Ty, _Types...>) {
            _Construct_in_place(_Val, ::std:: forward<_Types>(_Args)...);
            return _Val;
        }

    private:
        union {
            _Ty _Val;
        };
    };

    template <class _Fn, class... _Types>
    class _Range_closure : public _Pipe::_Base<_Range_closure<_Fn, _Types...>> {
    public:
        
        
        ;
        ;

        
        template <class... _UTypes>
            requires (same_as<decay_t<_UTypes>, _Types> && ...)
        constexpr explicit _Range_closure(_UTypes&&... _Args) noexcept(
            conjunction_v<is_nothrow_constructible<_Types, _UTypes>...>)
            : _Captures(::std:: forward<_UTypes>(_Args)...) {}
        

        void operator()(auto&&) &       = delete;
        void operator()(auto&&) const&  = delete;
        void operator()(auto&&) &&      = delete;
        void operator()(auto&&) const&& = delete;

        using _Indices = index_sequence_for<_Types...>;

        template <class _Ty>
            requires invocable<_Fn, _Ty, _Types&...>
        constexpr decltype(auto) operator()(_Ty&& _Arg) & noexcept(
            noexcept(_Call(*this, ::std:: forward<_Ty>(_Arg), _Indices{}))) {
            return _Call(*this, ::std:: forward<_Ty>(_Arg), _Indices{});
        }

        template <class _Ty>
            requires invocable<_Fn, _Ty, const _Types&...>
        constexpr decltype(auto) operator()(_Ty&& _Arg) const& noexcept(
            noexcept(_Call(*this, ::std:: forward<_Ty>(_Arg), _Indices{}))) {
            return _Call(*this, ::std:: forward<_Ty>(_Arg), _Indices{});
        }

        template <class _Ty>
            requires invocable<_Fn, _Ty, _Types...>
        constexpr decltype(auto) operator()(_Ty&& _Arg) && noexcept(
            noexcept(_Call(::std:: move(*this), ::std:: forward<_Ty>(_Arg), _Indices{}))) {
            return _Call(::std:: move(*this), ::std:: forward<_Ty>(_Arg), _Indices{});
        }

        template <class _Ty>
            requires invocable<_Fn, _Ty, const _Types...>
        constexpr decltype(auto) operator()(_Ty&& _Arg) const&& noexcept(
            noexcept(_Call(::std:: move(*this), ::std:: forward<_Ty>(_Arg), _Indices{}))) {
            return _Call(::std:: move(*this), ::std:: forward<_Ty>(_Arg), _Indices{});
        }

    private:
        template <class _SelfTy, class _Ty, size_t... _Idx>
        static constexpr decltype(auto) _Call(_SelfTy&& _Self, _Ty&& _Arg, index_sequence<_Idx...>) noexcept(
            noexcept(_Fn{}(::std:: forward<_Ty>(_Arg), ::std:: get<_Idx>(::std:: forward<_SelfTy>(_Self)._Captures)...))) {
            ;
            return _Fn{}(::std:: forward<_Ty>(_Arg), ::std:: get<_Idx>(::std:: forward<_SelfTy>(_Self)._Captures)...);
        }

        tuple<_Types...> _Captures;
    };

    
    template <class _Ty>
        requires is_object_v<_Ty>
    class empty_view : public view_interface<empty_view<_Ty>> {
        
    public:
        [[nodiscard]] static constexpr _Ty* begin() noexcept {
            return nullptr;
        }

        [[nodiscard]] static constexpr _Ty* end() noexcept {
            return nullptr;
        }

        [[nodiscard]] static constexpr _Ty* data() noexcept {
            return nullptr;
        }

        [[nodiscard]] static constexpr size_t size() noexcept {
            return 0;
        }

        [[nodiscard]] static constexpr bool empty() noexcept {
            return true;
        }
    };

    namespace views {
        template <class _Ty>
        inline constexpr empty_view<_Ty> empty;
    } 

    
    template <copy_constructible _Ty>
        requires is_object_v<_Ty>
    class single_view : public view_interface<single_view<_Ty>> {
        
    public:
        
        single_view() requires default_initializable<_Ty> = default;
        

        constexpr explicit single_view(const _Ty& _Val_) noexcept(is_nothrow_copy_constructible_v<_Ty>) 
            : _Val{in_place, _Val_} {}
        constexpr explicit single_view(_Ty&& _Val_) noexcept(is_nothrow_move_constructible_v<_Ty>) 
            : _Val{in_place, ::std:: move(_Val_)} {}

        
        template <class... _Types>
            requires constructible_from<_Ty, _Types...>
        constexpr explicit single_view(in_place_t, _Types&&... _Args) noexcept(
            is_nothrow_constructible_v<_Ty, _Types...>) 
            
            : _Val{in_place, ::std:: forward<_Types>(_Args)...} {}

        [[nodiscard]] constexpr _Ty* begin() noexcept {
            return data();
        }
        [[nodiscard]] constexpr const _Ty* begin() const noexcept {
            return data();
        }

        [[nodiscard]] constexpr _Ty* end() noexcept {
            return data() + 1;
        }
        [[nodiscard]] constexpr const _Ty* end() const noexcept {
            return data() + 1;
        }

        [[nodiscard]] static constexpr size_t size() noexcept {
            return 1;
        }

        [[nodiscard]] constexpr _Ty* data() noexcept {
            return ::std:: addressof(*_Val);
        }
        [[nodiscard]] constexpr const _Ty* data() const noexcept {
            return ::std:: addressof(*_Val);
        }

    private:
         _Copyable_box<_Ty> _Val{};
    };

    template <class _Ty>
    single_view(_Ty) -> single_view<_Ty>;

    namespace views {
        struct _Single_fn {
            
            template <class _Ty>
            [[nodiscard]] constexpr auto operator()(_Ty&& _Val) const noexcept(
                noexcept(single_view<decay_t<_Ty>>(::std:: forward<_Ty>(_Val)))) requires requires {
                typename single_view<decay_t<_Ty>>;
                single_view<decay_t<_Ty>>(static_cast<_Ty&&>(_Val));
            } {
                return single_view<decay_t<_Ty>>(::std:: forward<_Ty>(_Val));
            }
            
        };

        inline constexpr _Single_fn single;
    } 

    template <class _Ty>
    using _Iota_diff_t = conditional_t<is_integral_v<_Ty>,
        conditional_t<sizeof(_Ty) < sizeof(int), int,
            conditional_t<sizeof(_Ty) < sizeof(long long), long long, _Signed128>>,
        iter_difference_t<_Ty>>;

    
    template <class _Ty>
    concept _Decrementable = incrementable<_Ty> && requires(_Ty __t) {
        { --__t } -> same_as<_Ty&>;
        { __t-- } -> same_as<_Ty>;
    };

    template <class _Ty>
    concept _Advanceable = _Decrementable<_Ty> && totally_ordered<_Ty>
        && requires(_Ty __i, const _Ty __j, const _Iota_diff_t<_Ty> __n) {
            { __i += __n } -> same_as<_Ty&>;
            { __i -= __n } -> same_as<_Ty&>;
            _Ty(__j + __n);
            _Ty(__n + __j);
            _Ty(__j - __n);
            { __j - __j } -> convertible_to<_Iota_diff_t<_Ty>>;
        };
    

    template <class _Wi>
    struct _Ioterator_category_base {};

    template <incrementable _Wi>
        requires integral<_Iota_diff_t<_Wi>> 
    struct _Ioterator_category_base<_Wi> {
        using iterator_category = input_iterator_tag;
    };

    template <weakly_incrementable _Wi>
        requires copyable<_Wi>
    struct _Ioterator : _Ioterator_category_base<_Wi> {
         _Wi _Current{};

        using iterator_concept = conditional_t<_Advanceable<_Wi>, random_access_iterator_tag,
            conditional_t<_Decrementable<_Wi>, bidirectional_iterator_tag,
                conditional_t<incrementable<_Wi>, forward_iterator_tag, input_iterator_tag>>>;
        using value_type       = _Wi;
        using difference_type  = _Iota_diff_t<_Wi>;

        
        _Ioterator() requires default_initializable<_Wi> = default;
        

        constexpr explicit _Ioterator(_Wi _Val) noexcept(is_nothrow_move_constructible_v<_Wi>) 
            : _Current(::std:: move(_Val)) {}

        [[nodiscard]] constexpr _Wi operator*() const noexcept(is_nothrow_copy_constructible_v<_Wi>) {
            return _Current;
        }

        constexpr _Ioterator& operator++() noexcept(noexcept(++_Current))  {
            ++_Current;
            return *this;
        }

        constexpr auto operator++(int) noexcept(
            noexcept(++_Current) && (!incrementable<_Wi> || is_nothrow_copy_constructible_v<_Wi>) )  {
            if constexpr (incrementable<_Wi>) {
                auto _Tmp = *this;
                ++_Current;
                return _Tmp;
            } else {
                ++_Current;
            }
        }

        constexpr _Ioterator& operator--() noexcept(
            noexcept(--_Current))  requires _Decrementable<_Wi> {
            --_Current;
            return *this;
        }

        constexpr _Ioterator operator--(int) noexcept(is_nothrow_copy_constructible_v<_Wi>&& noexcept(
            --_Current))  requires _Decrementable<_Wi> {
            auto _Tmp = *this;
            --_Current;
            return _Tmp;
        }


    private:
        template <class _Left, class _Right>
        static constexpr bool _Nothrow_plus_equal = noexcept(::std:: declval<_Left&>() += ::std:: declval<const _Right&>());
        template <_Integer_like _Left, class _Right>
        static constexpr bool _Nothrow_plus_equal<_Left, _Right> = true;
        

        template <class _Left, class _Right>
        static constexpr bool _Nothrow_minus_equal = noexcept(::std:: declval<_Left&>() -= ::std:: declval<const _Right&>());
        template <_Integer_like _Left, class _Right>
        static constexpr bool _Nothrow_minus_equal<_Left, _Right> = true;

    public:
#line 1090 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"

        constexpr _Ioterator& operator+=(const difference_type _Off)


#line 1095 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
            noexcept(_Nothrow_plus_equal<_Wi, difference_type>) 
#line 1097 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
            requires _Advanceable<_Wi> {
            if constexpr (_Integer_like<_Wi>) {
                if constexpr (_Signed_integer_like<_Wi>) {
                    _Current = static_cast<_Wi>(_Current + _Off);
                } else {
                    if (_Off >= difference_type{0}) {
                        _Current += static_cast<_Wi>(_Off);
                    } else {
                        _Current -= static_cast<_Wi>(-_Off);
                    }
                }
            } else {
                _Current += _Off;
            }
            return *this;
        }

        constexpr _Ioterator& operator-=(const difference_type _Off)


#line 1118 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
            noexcept(_Nothrow_minus_equal<_Wi, difference_type>) 
#line 1120 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
            requires _Advanceable<_Wi> {
            if constexpr (_Integer_like<_Wi>) {
                if constexpr (_Signed_integer_like<_Wi>) {
                    _Current = static_cast<_Wi>(_Current - _Off);
                } else {
                    if (_Off >= difference_type{0}) {
                        _Current -= static_cast<_Wi>(_Off);
                    } else {
                        _Current += static_cast<_Wi>(-_Off);
                    }
                }
            } else {
                _Current -= _Off;
            }
            return *this;
        }

        [[nodiscard]] constexpr _Wi operator[](const difference_type _Idx) const
            noexcept(noexcept(static_cast<_Wi>(_Current + _Idx)))  requires _Advanceable<_Wi> {
            if constexpr (_Integer_like<_Wi>) {
                return static_cast<_Wi>(_Current + static_cast<_Wi>(_Idx));
            } else {
                return static_cast<_Wi>(_Current + _Idx);
            }
        }

        [[nodiscard]] friend constexpr bool operator==(const _Ioterator& _Left, const _Ioterator& _Right) noexcept(
            noexcept(_Left._Current == _Right._Current)) requires equality_comparable<_Wi> {
            return _Left._Current == _Right._Current;
        }

        [[nodiscard]] friend constexpr bool operator<(const _Ioterator& _Left, const _Ioterator& _Right) noexcept(
            noexcept(_Left._Current < _Right._Current))  requires totally_ordered<_Wi> {
            return _Left._Current < _Right._Current;
        }
        [[nodiscard]] friend constexpr bool operator>(const _Ioterator& _Left, const _Ioterator& _Right) noexcept(
            noexcept(_Right._Current < _Left._Current))  requires totally_ordered<_Wi> {
            return _Right._Current < _Left._Current;
        }
        [[nodiscard]] friend constexpr bool operator<=(const _Ioterator& _Left, const _Ioterator& _Right) noexcept(
            noexcept(!(_Right._Current < _Left._Current)))  requires totally_ordered<_Wi> {
            return !(_Right._Current < _Left._Current);
        }
        [[nodiscard]] friend constexpr bool operator>=(const _Ioterator& _Left, const _Ioterator& _Right) noexcept(
            noexcept(!(_Left._Current < _Right._Current)))  requires totally_ordered<_Wi> {
            return !(_Left._Current < _Right._Current);
        }

        [[nodiscard]] friend constexpr auto operator<=>(const _Ioterator& _Left, const _Ioterator& _Right) noexcept(
            noexcept(_Left._Current <=> _Right._Current)) requires totally_ordered<_Wi> && three_way_comparable<_Wi> {
            return _Left._Current <=> _Right._Current;
        }

        [[nodiscard]] friend constexpr _Ioterator operator+(_Ioterator _It, const difference_type _Off) noexcept(
            is_nothrow_move_constructible_v<_Ioterator>&& noexcept(
                _It += _Off))  requires _Advanceable<_Wi> {
            _It += _Off;
            return _It;
        }
        [[nodiscard]] friend constexpr _Ioterator operator+(const difference_type _Off, _Ioterator _It) noexcept(
            is_nothrow_move_constructible_v<_Wi>&& noexcept(
                static_cast<_Wi>(_It._Current + _Off)))  requires _Advanceable<_Wi> {
            return _Ioterator{static_cast<_Wi>(_It._Current + _Off)};
        }

        [[nodiscard]] friend constexpr _Ioterator operator-(_Ioterator _It, const difference_type _Off) noexcept(
            is_nothrow_move_constructible_v<_Ioterator>&& noexcept(
                _It -= _Off))  requires _Advanceable<_Wi> {
            _It -= _Off;
            return _It;
        }

        [[nodiscard]] friend constexpr difference_type
            operator-(const _Ioterator& _Left, const _Ioterator& _Right) noexcept(
                noexcept(_Left._Current - _Right._Current))  requires _Advanceable<_Wi> {
            if constexpr (_Integer_like<_Wi>) {
                if constexpr (_Signed_integer_like<_Wi>) {
                    return static_cast<difference_type>(
                        static_cast<difference_type>(_Left._Current) - static_cast<difference_type>(_Right._Current));
                } else if (_Right._Current > _Left._Current) {
                    return static_cast<difference_type>(
                        -static_cast<difference_type>(_Right._Current - _Left._Current));
                } else {
                    return static_cast<difference_type>(_Left._Current - _Right._Current);
                }
            } else {
                return static_cast<difference_type>(_Left._Current - _Right._Current);
            }
        }
    };

    
    template <weakly_incrementable _Wi, semiregular _Bo>
        requires _Weakly_equality_comparable_with<_Wi, _Bo> && copyable<_Wi>
    struct _Iotinel {
        
    private:
        using _It = _Ioterator<_Wi>;

        [[nodiscard]] constexpr bool _Equal(const _It& _That) const noexcept(noexcept(_That._Current == _Last)) {
            return _That._Current == _Last;
        }

        [[nodiscard]] constexpr iter_difference_t<_Wi> _Delta(const _It& _That) const
            noexcept(noexcept(_Last - _That._Current)) {
            ;
            return _Last - _That._Current;
        }

    public:
         _Bo _Last{};

        [[nodiscard]] friend constexpr bool operator==(const _It& _Left, const _Iotinel& _Right) noexcept(
            noexcept(_Right._Equal(_Left)))  {
            return _Right._Equal(_Left);
        }

        [[nodiscard]] friend constexpr iter_difference_t<_Wi> operator-(const _It& _Left, const _Iotinel& _Right) noexcept(
            noexcept(_Right._Delta(_Left)))  requires sized_sentinel_for<_Bo, _Wi> {
            return -_Right._Delta(_Left);
        }

        [[nodiscard]] friend constexpr iter_difference_t<_Wi> operator-(const _Iotinel& _Left, const _It& _Right) noexcept(
            noexcept(_Left._Delta(_Right)))  requires sized_sentinel_for<_Bo, _Wi> {
            return _Left._Delta(_Right);
        }
    };

    
    template <weakly_incrementable _Wi, semiregular _Bo = unreachable_sentinel_t>
        requires _Weakly_equality_comparable_with<_Wi, _Bo> && copyable<_Wi>
    class iota_view : public view_interface<iota_view<_Wi, _Bo>> {
        
    private:
         _Wi _Value{};
         _Bo _Bound{};

        using _It = _Ioterator<_Wi>;
        using _Se = conditional_t<same_as<_Wi, _Bo>, _It,
            conditional_t<same_as<_Bo, unreachable_sentinel_t>, _Bo, _Iotinel<_Wi, _Bo>>>;

        [[nodiscard]] static constexpr _Bo& _Bound_from(_Se& _Last) noexcept {
            if constexpr (same_as<_Wi, _Bo>) {
                return _Last._Current;
            } else if constexpr (same_as<_Bo, unreachable_sentinel_t>) {
                return _Last;
            } else {
                return _Last._Last;
            }
        }

    public:
        
        iota_view() requires default_initializable<_Wi> = default;
        

        constexpr explicit iota_view(_Wi _Value_) noexcept(
            is_nothrow_move_constructible_v<_Wi>&& is_nothrow_default_constructible_v<_Bo>) 
            : _Value(::std:: move(_Value_)) {}

        constexpr iota_view(type_identity_t<_Wi> _Value_, type_identity_t<_Bo> _Bound_) noexcept(
            is_nothrow_move_constructible_v<_Wi>&& is_nothrow_move_constructible_v<_Bo>) 
            : _Value(::std:: move(_Value_)), _Bound(::std:: move(_Bound_)) {
            if constexpr (totally_ordered_with<_Wi, _Bo>) {
                ;
#line 1286 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
            }
        }

        constexpr iota_view(_It _First, _Se _Last) noexcept(
            is_nothrow_move_constructible_v<_Wi>&& is_nothrow_move_constructible_v<_Bo>) 
            : _Value(::std:: move(_First._Current)), _Bound(::std:: move(_Bound_from(_Last))) {}

        [[nodiscard]] constexpr _It begin() const noexcept(is_nothrow_copy_constructible_v<_Wi>)  {
            return _It{_Value};
        }

        [[nodiscard]] constexpr _Se end() const noexcept(is_nothrow_copy_constructible_v<_Bo>)  {
            if constexpr (same_as<_Wi, _Bo>) {
                return _It{_Bound};
            } else if constexpr (same_as<_Bo, unreachable_sentinel_t>) {
                return unreachable_sentinel;
            } else {
                return _Se{_Bound};
            }
        }

        
        [[nodiscard]] constexpr auto size() const noexcept(noexcept(_Bound - _Value)) 
            requires (same_as<_Wi, _Bo> && _Advanceable<_Wi>)
                || (_Integer_like<_Wi> && _Integer_like<_Bo>)
                || sized_sentinel_for<_Bo, _Wi> {
            
            if constexpr (_Integer_like<_Wi> && _Integer_like<_Bo>) {
#pragma warning(suppress : 4146) 
                return (_Value < 0) ? ((_Bound < 0) ? (_To_unsigned_like(-_Value) - _To_unsigned_like(-_Bound))
#pragma warning(suppress : 4146) 
                                                    : (_To_unsigned_like(_Bound) + _To_unsigned_like(-_Value)))
                                    : (_To_unsigned_like(_Bound) - _To_unsigned_like(_Value));
            } else {
                return _To_unsigned_like(_Bound - _Value);
            }
        }
    };

    
    template <class _Wi, class _Bo>
        requires (!_Integer_like<_Wi> || !_Integer_like<_Bo>
            || (_Signed_integer_like<_Wi> == _Signed_integer_like<_Bo>))
    iota_view(_Wi, _Bo) -> iota_view<_Wi, _Bo>;
    

    template <class _Wi, class _Bo>
    inline constexpr bool enable_borrowed_range<iota_view<_Wi, _Bo>> = true;

    namespace views {
        struct _Iota_fn {
            template <class _Ty>
            [[nodiscard]] constexpr auto operator()(_Ty&& _Val) const
                noexcept(noexcept(iota_view(static_cast<_Ty&&>(_Val)))) requires requires {
                iota_view(static_cast<_Ty&&>(_Val));
            }
            { return iota_view(static_cast<_Ty&&>(_Val)); }

            template <class _Ty1, class _Ty2>
            [[nodiscard]] constexpr auto operator()(_Ty1&& _Val1, _Ty2&& _Val2) const noexcept(
                noexcept(iota_view(static_cast<_Ty1&&>(_Val1), static_cast<_Ty2&&>(_Val2)))) requires requires {
                iota_view(static_cast<_Ty1&&>(_Val1), static_cast<_Ty2&&>(_Val2));
            }
            { return iota_view(static_cast<_Ty1&&>(_Val1), static_cast<_Ty2&&>(_Val2)); }
        };

        inline constexpr _Iota_fn iota;
    } 

    template <class _Ty, class _Elem, class _Traits>
    concept _Stream_extractable = requires(basic_istream<_Elem, _Traits>& __is, _Ty& __t) {
        __is >> __t;
    };

    
    template <movable _Ty, class _Elem, class _Traits = char_traits<_Elem>>
        requires default_initializable<_Ty> && _Stream_extractable<_Ty, _Elem, _Traits>
    class basic_istream_view : public view_interface<basic_istream_view<_Ty, _Elem, _Traits>> {
        
    private:
        class _Iterator {
        private:
            basic_istream_view* _Parent;

        public:
            using iterator_concept = input_iterator_tag;
            using difference_type  = ptrdiff_t;
            using value_type       = _Ty;

            constexpr explicit _Iterator(basic_istream_view& _Parent_) noexcept : _Parent{::std:: addressof(_Parent_)} {}

            _Iterator(const _Iterator&) = delete;
            _Iterator(_Iterator&&)      = default;

            _Iterator& operator=(const _Iterator&) = delete;
            _Iterator& operator=(_Iterator&&) = default;

            _Iterator& operator++() {


#line 1389 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                *_Parent->_Stream >> _Parent->_Val;
                return *this;
            }

            void operator++(int) {
                ++*this;
            }

            [[nodiscard]] _Ty& operator*() const noexcept  {


#line 1403 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                return _Parent->_Val;
            }

            [[nodiscard]] friend bool operator==(const _Iterator& _Left, default_sentinel_t) noexcept  {
                return _Left._Parent->_Stream_at_end();
            }
        };

        basic_istream<_Elem, _Traits>* _Stream;
        _Ty _Val = _Ty{};

    public:
        constexpr explicit basic_istream_view(basic_istream<_Elem, _Traits>& _Stream_) noexcept(
            is_nothrow_default_constructible_v<_Ty>) 
            : _Stream{::std:: addressof(_Stream_)} {}

        [[nodiscard]] constexpr auto begin() {
            *_Stream >> _Val;
            return _Iterator{*this};
        }

        [[nodiscard]] constexpr default_sentinel_t end() const noexcept {
            return default_sentinel;
        }

        [[nodiscard]] constexpr bool _Stream_at_end() const noexcept {
            return !*_Stream;
        }
    };

    template <class _Ty>
    using istream_view = basic_istream_view<_Ty, char>;
    template <class _Ty>
    using wistream_view = basic_istream_view<_Ty, wchar_t>;

    namespace views {
        template <class _Ty>
        struct _Istream_fn {
            
            template <class _StreamTy>
                requires derived_from<_StreamTy,
                    basic_istream<typename _StreamTy::char_type, typename _StreamTy::traits_type>>
            [[nodiscard]] constexpr auto operator()(_StreamTy& _Stream) const
                noexcept(is_nothrow_default_constructible_v<_Ty>)  {
                
                return basic_istream_view<_Ty, typename _StreamTy::char_type, typename _StreamTy::traits_type>(_Stream);
            }
        };

        template <class _Ty>
        inline constexpr _Istream_fn<_Ty> istream;
    } 

    template <range _Rng>
        requires is_object_v<_Rng>
    class ref_view : public view_interface<ref_view<_Rng>> {
    private:
        _Rng* _Range;

        static void _Rvalue_poison(_Rng&);
        static void _Rvalue_poison(_Rng&&) = delete;

    public:
        
        template <_Not_same_as<ref_view> _OtherRng>
        constexpr ref_view(_OtherRng&& _Other) noexcept(
            noexcept(static_cast<_Rng&>(::std:: forward<_OtherRng>(_Other)))) 
            requires convertible_to<_OtherRng, _Rng&> && requires {
                _Rvalue_poison(static_cast<_OtherRng&&>(_Other));
            } : _Range{::std:: addressof(static_cast<_Rng&>(::std:: forward<_OtherRng>(_Other)))} {}
        

        [[nodiscard]] constexpr _Rng& base() const noexcept  {
            return *_Range;
        }

        [[nodiscard]] constexpr iterator_t<_Rng> begin() const
            noexcept(noexcept(::std::ranges:: begin(*_Range)))  {
            return ::std::ranges:: begin(*_Range);
        }

        [[nodiscard]] constexpr sentinel_t<_Rng> end() const noexcept(noexcept(::std::ranges:: end(*_Range)))  {
            return ::std::ranges:: end(*_Range);
        }

        [[nodiscard]] constexpr bool empty() const noexcept(noexcept(::std::ranges:: empty(*_Range))) 
            requires _Can_empty<_Rng> {
            return ::std::ranges:: empty(*_Range);
        }

        [[nodiscard]] constexpr auto size() const noexcept(noexcept(::std::ranges:: size(*_Range))) 
            requires sized_range<_Rng> {
            return ::std::ranges:: size(*_Range);
        }

        [[nodiscard]] constexpr auto data() const noexcept(noexcept(::std::ranges:: data(*_Range))) 
            requires contiguous_range<_Rng> {
            return ::std::ranges:: data(*_Range);
        }
    };

    template <class _Rng>
    ref_view(_Rng&) -> ref_view<_Rng>;

    template <class _Rng>
    inline constexpr bool enable_borrowed_range<ref_view<_Rng>> = true;

    
    template <range _Rng>
        requires (movable<_Rng> && !_Is_initializer_list<_Rng>)
    class owning_view : public view_interface<owning_view<_Rng>> {
        
    private:
        _Rng _Range{};

    public:
        
        owning_view() requires default_initializable<_Rng> = default;
        

        constexpr owning_view(_Rng&& _Range_) noexcept(is_nothrow_move_constructible_v<_Rng>) 
            : _Range(::std:: move(_Range_)) {}

        owning_view(owning_view&&) = default;
        owning_view& operator=(owning_view&&) = default;

        [[nodiscard]] constexpr _Rng& base() & noexcept {
            return _Range;
        }
        [[nodiscard]] constexpr const _Rng& base() const& noexcept {
            return _Range;
        }
        [[nodiscard]] constexpr _Rng&& base() && noexcept {
            return ::std:: move(_Range);
        }
        [[nodiscard]] constexpr const _Rng&& base() const&& noexcept {
            return ::std:: move(_Range);
        }

        [[nodiscard]] constexpr iterator_t<_Rng> begin() noexcept(noexcept(::std::ranges:: begin(_Range)))  {
            return ::std::ranges:: begin(_Range);
        }

        [[nodiscard]] constexpr sentinel_t<_Rng> end() noexcept(noexcept(::std::ranges:: end(_Range)))  {
            return ::std::ranges:: end(_Range);
        }

        [[nodiscard]] constexpr auto begin() const
            noexcept(noexcept(::std::ranges:: begin(_Range)))  requires range<const _Rng> {
            return ::std::ranges:: begin(_Range);
        }

        [[nodiscard]] constexpr auto end() const
            noexcept(noexcept(::std::ranges:: end(_Range)))  requires range<const _Rng> {
            return ::std::ranges:: end(_Range);
        }

        [[nodiscard]] constexpr bool empty() noexcept(noexcept(::std::ranges:: empty(_Range))) 
            requires _Can_empty<_Rng> {
            return ::std::ranges:: empty(_Range);
        }
        [[nodiscard]] constexpr bool empty() const noexcept(noexcept(::std::ranges:: empty(_Range))) 
            requires _Can_empty<const _Rng> {
            return ::std::ranges:: empty(_Range);
        }

        [[nodiscard]] constexpr auto size() noexcept(noexcept(::std::ranges:: size(_Range))) 
            requires sized_range<_Rng> {
            return ::std::ranges:: size(_Range);
        }
        [[nodiscard]] constexpr auto size() const noexcept(noexcept(::std::ranges:: size(_Range))) 
            requires sized_range<const _Rng> {
            return ::std::ranges:: size(_Range);
        }

        [[nodiscard]] constexpr auto data() noexcept(noexcept(::std::ranges:: data(_Range))) 
            requires contiguous_range<_Rng> {
            return ::std::ranges:: data(_Range);
        }
        [[nodiscard]] constexpr auto data() const noexcept(noexcept(::std::ranges:: data(_Range))) 
            requires contiguous_range<const _Rng> {
            return ::std::ranges:: data(_Range);
        }
    };

    template <class _Rng>
    inline constexpr bool enable_borrowed_range<owning_view<_Rng>> = enable_borrowed_range<_Rng>;

    namespace views {
        template <class _Rng>
        concept _Can_ref_view = requires(_Rng&& __r) {
            ref_view{static_cast<_Rng&&>(__r)};
        };

        template <class _Rng>
        concept _Ownable = requires(_Rng&& __r) {
            owning_view{static_cast<_Rng&&>(__r)};
        };

        class _All_fn : public _Pipe::_Base<_All_fn> {
        private:
            enum class _St { _None, _View, _Ref, _Own };

            template <class _Rng>
            [[nodiscard]] static consteval _Choice_t<_St> _Choose() noexcept {
                if constexpr (view<remove_cvref_t<_Rng>>) {
                    if constexpr (constructible_from<remove_cvref_t<_Rng>, _Rng>) {
                        return {_St::_View, is_nothrow_constructible_v<remove_cvref_t<_Rng>, _Rng>};
                    }
                } else if constexpr (_Can_ref_view<_Rng>) {
                    return {_St::_Ref, noexcept(ref_view{::std:: declval<_Rng>()})};
                } else if constexpr (_Ownable<_Rng>) {
                    return {_St::_Own, noexcept(owning_view{::std:: declval<_Rng>()})};
                }

                return {_St::_None};
            }

            template <class _Rng>
            static constexpr _Choice_t<_St> _Choice = _Choose<_Rng>();

        public:
            
            template <viewable_range _Rng>
                requires (_Choice<_Rng>._Strategy != _St::_None)
            [[nodiscard]] constexpr auto operator()(_Rng&& _Range) const noexcept(_Choice<_Rng>._No_throw) {
                
                constexpr _St _Strat = _Choice<_Rng>._Strategy;

                if constexpr (_Strat == _St::_View) {
                    return ::std:: forward<_Rng>(_Range);
                } else if constexpr (_Strat == _St::_Ref) {
                    return ref_view{::std:: forward<_Rng>(_Range)};
                } else if constexpr (_Strat == _St::_Own) {
                    return owning_view{::std:: forward<_Rng>(_Range)};
                } else {
                    static_assert(_Always_false<_Rng>, "Should be unreachable");
                }
            }
        };

        inline constexpr _All_fn all;

        template <viewable_range _Rng>
        using all_t = decltype(all(::std:: declval<_Rng>()));
    } 

    
    template <input_range _Vw, indirect_unary_predicate<iterator_t<_Vw>> _Pr>
        requires view<_Vw> && is_object_v<_Pr>
    class filter_view : public _Cached_position_t<forward_range<_Vw>, _Vw, filter_view<_Vw, _Pr>> {
        
    private:
         _Vw _Range{};
         _Copyable_box<_Pr> _Pred{};

        template <class _View>
        struct _Category_base {};

        template <forward_range _View>
        struct _Category_base<_View> {
            using iterator_category =
                conditional_t<derived_from<_Iter_cat_t<iterator_t<_View>>, bidirectional_iterator_tag>,
                    bidirectional_iterator_tag,
                    conditional_t<derived_from<_Iter_cat_t<iterator_t<_View>>, forward_iterator_tag>,
                        forward_iterator_tag, _Iter_cat_t<iterator_t<_View>>>>;
        };

        class _Iterator : public _Category_base<_Vw> {
        private:
             iterator_t<_Vw> _Current{};
            filter_view* _Parent{};


#line 1682 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"

        public:
            using iterator_concept = conditional_t<bidirectional_range<_Vw>, bidirectional_iterator_tag,
                conditional_t<forward_range<_Vw>, forward_iterator_tag, input_iterator_tag>>;
            using value_type       = range_value_t<_Vw>;
            using difference_type  = range_difference_t<_Vw>;

            
            _Iterator() requires default_initializable<iterator_t<_Vw>> = default;
            

            constexpr _Iterator(filter_view& _Parent_, iterator_t<_Vw> _Current_) noexcept(
                is_nothrow_move_constructible_v<iterator_t<_Vw>>) 
                : _Current(::std:: move(_Current_)), _Parent{::std:: addressof(_Parent_)} {


#line 1702 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
            }

            [[nodiscard]] constexpr const iterator_t<_Vw>& base() const& noexcept {
                return _Current;
            }
            [[nodiscard]] constexpr iterator_t<_Vw> base() && noexcept(
                is_nothrow_move_constructible_v<iterator_t<_Vw>>)  {
                return ::std:: move(_Current);
            }

            [[nodiscard]] constexpr range_reference_t<_Vw> operator*() const
                noexcept(noexcept(*_Current))  {


#line 1717 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                return *_Current;
            }

            
            [[nodiscard]] constexpr iterator_t<_Vw> operator->() const
                noexcept(is_nothrow_copy_constructible_v<iterator_t<_Vw>>) 
                requires _Has_arrow<iterator_t<_Vw>> && copyable<iterator_t<_Vw>> {
                

#line 1728 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                return _Current;
            }

            constexpr _Iterator& operator++() {


#line 1736 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                _Current =
                    ::std::ranges:: find_if(::std:: move(++_Current), ::std::ranges:: end(_Parent->_Range), ::std:: ref(*_Parent->_Pred));
                return *this;
            }

            constexpr decltype(auto) operator++(int) {
                if constexpr (forward_range<_Vw>) {
                    auto _Tmp = *this;
                    ++*this;
                    return _Tmp;
                } else {
                    ++*this;
                }
            }

            constexpr _Iterator& operator--() requires bidirectional_range<_Vw> {


#line 1755 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                do {


#line 1760 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                    --_Current;
                } while (!::std:: invoke(*_Parent->_Pred, *_Current));
                return *this;
            }

            constexpr _Iterator operator--(int) requires bidirectional_range<_Vw> {
                auto _Tmp = *this;
                --*this;
                return _Tmp;
            }

            [[nodiscard]] friend constexpr bool operator==(
                const _Iterator& _Left, const _Iterator& _Right) requires equality_comparable<iterator_t<_Vw>> {


#line 1777 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                return _Left._Current == _Right._Current;
            }

            [[nodiscard]] friend constexpr range_rvalue_reference_t<_Vw> iter_move(const _Iterator& _It) noexcept(
                noexcept(::std::ranges:: iter_move(_It._Current))) {


#line 1785 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                return ::std::ranges:: iter_move(_It._Current);
            }

            friend constexpr void iter_swap(const _Iterator& _Left, const _Iterator& _Right) noexcept(noexcept(
                ::std::ranges:: iter_swap(_Left._Current, _Right._Current))) requires indirectly_swappable<iterator_t<_Vw>> {


#line 1794 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                return ::std::ranges:: iter_swap(_Left._Current, _Right._Current);
            }

            [[nodiscard]] constexpr bool _Equal(const sentinel_t<_Vw>& _Last) const
                noexcept(noexcept(_Implicitly_convert_to<bool>(_Current == _Last))) {
                return _Current == _Last;
            }
        };

        class _Sentinel {
        private:
             sentinel_t<_Vw> _Last{};

        public:
            _Sentinel() = default;
            constexpr explicit _Sentinel(filter_view& _Parent) noexcept(
                noexcept(::std::ranges:: end(_Parent._Range))
                && is_nothrow_move_constructible_v<sentinel_t<_Vw>>) 
                : _Last(::std::ranges:: end(_Parent._Range)) {}

            [[nodiscard]] constexpr sentinel_t<_Vw> base() const
                noexcept(is_nothrow_copy_constructible_v<sentinel_t<_Vw>>)  {
                return _Last;
            }

            [[nodiscard]] friend constexpr bool operator==(const _Iterator& _It, const _Sentinel& _Se) noexcept(
                noexcept(_It._Equal(_Se._Last)))  {
                return _It._Equal(_Se._Last);
            }
        };

    public:
        
        filter_view() requires default_initializable<_Vw> && default_initializable<_Pr> = default;
        

        constexpr filter_view(_Vw _Range_, _Pr _Pred_) noexcept(
            is_nothrow_move_constructible_v<_Vw>&& is_nothrow_move_constructible_v<_Pr>) 
            : _Range(::std:: move(_Range_)), _Pred{in_place, ::std:: move(_Pred_)} {}

        [[nodiscard]] constexpr _Vw base() const& noexcept(
            is_nothrow_copy_constructible_v<_Vw>)  requires copy_constructible<_Vw> {
            return _Range;
        }
        [[nodiscard]] constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>)  {
            return ::std:: move(_Range);
        }

        [[nodiscard]] constexpr const _Pr& pred() const noexcept  {


#line 1846 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
            return *_Pred;
        }

        [[nodiscard]] constexpr _Iterator begin() {


#line 1854 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
            if constexpr (forward_range<_Vw>) {
                if (this->_Has_cache()) {
                    return _Iterator{*this, this->_Get_cache(_Range)};
                }
            }

            auto _First = ::std::ranges:: find_if(_Range, ::std:: ref(*_Pred));
            if constexpr (forward_range<_Vw>) {
                this->_Set_cache(_Range, _First);
            }

            return _Iterator{*this, ::std:: move(_First)};
        }

        [[nodiscard]] constexpr auto end() {
            if constexpr (common_range<_Vw>) {
                return _Iterator{*this, ::std::ranges:: end(_Range)};
            } else {
                return _Sentinel{*this};
            }
        }
    };

    template <class _Rng, class _Pr>
    filter_view(_Rng&&, _Pr) -> filter_view<views::all_t<_Rng>, _Pr>;

    namespace views {
        struct _Filter_fn {
            
            template <viewable_range _Rng, class _Pr>
            [[nodiscard]] constexpr auto operator()(_Rng&& _Range, _Pr&& _Pred) const noexcept(noexcept(
                filter_view(::std:: forward<_Rng>(_Range), ::std:: forward<_Pr>(_Pred)))) requires requires {
                filter_view(static_cast<_Rng&&>(_Range), ::std:: forward<_Pr>(_Pred));
            } {
                
                return filter_view(::std:: forward<_Rng>(_Range), ::std:: forward<_Pr>(_Pred));
            }

            
            template <class _Pr>
                requires constructible_from<decay_t<_Pr>, _Pr>
            [[nodiscard]] constexpr auto operator()(_Pr&& _Pred) const
                noexcept(is_nothrow_constructible_v<decay_t<_Pr>, _Pr>) {
                
                return _Range_closure<_Filter_fn, decay_t<_Pr>>{::std:: forward<_Pr>(_Pred)};
            }
        };

        inline constexpr _Filter_fn filter;
    } 

    
    template <class _Rng, class _Fn> 
    concept _Can_const_transform = range<const _Rng> && regular_invocable<const _Fn&, range_reference_t<const _Rng>>;


#line 1914 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"

    template <input_range _Vw, copy_constructible _Fn>
        requires view<_Vw> && is_object_v<_Fn>
            && regular_invocable<_Fn&, range_reference_t<_Vw>>
            && _Can_reference<invoke_result_t<_Fn&, range_reference_t<_Vw>>>
    class transform_view : public view_interface<transform_view<_Vw, _Fn>> {
        
    private:
         _Vw _Range{};
         _Copyable_box<_Fn> _Fun{};

        template <bool _Const>
        class _Sentinel;

        template <class _Base>
        struct _Category_base {};

        template <forward_range _Base>
        struct _Category_base<_Base> {
            using iterator_category =
                conditional_t<is_lvalue_reference_v<invoke_result_t<_Fn&, range_reference_t<_Base>>>,
                    conditional_t<derived_from<_Iter_cat_t<iterator_t<_Base>>, contiguous_iterator_tag>,
                        random_access_iterator_tag, _Iter_cat_t<iterator_t<_Base>>>,
                    input_iterator_tag>;
        };

        template <bool _Const>
        class _Iterator : public _Category_base<_Maybe_const<_Const, _Vw>> {
        private:
            template <bool>
            friend class _Iterator;
            template <bool>
            friend class _Sentinel;

            using _Parent_t = _Maybe_const<_Const, transform_view>;
            using _Base     = _Maybe_const<_Const, _Vw>;

            iterator_t<_Base> _Current{};
            _Parent_t* _Parent{};


#line 1960 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"


#line 1966 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"

        public:
            using iterator_concept = conditional_t<random_access_range<_Base>, random_access_iterator_tag,
                conditional_t<bidirectional_range<_Base>, bidirectional_iterator_tag,
                    conditional_t<forward_range<_Base>, forward_iterator_tag, input_iterator_tag>>>;
            using value_type       = remove_cvref_t<invoke_result_t<_Fn&, range_reference_t<_Base>>>;
            using difference_type  = range_difference_t<_Base>;

            
            _Iterator() requires default_initializable<iterator_t<_Base>> = default;
            

            constexpr _Iterator(_Parent_t& _Parent_, iterator_t<_Base> _Current_) noexcept(
                is_nothrow_move_constructible_v<iterator_t<_Base>>) 
                : _Current{::std:: move(_Current_)}, _Parent{::std:: addressof(_Parent_)} {


#line 1987 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
            }

            
            constexpr _Iterator(_Iterator<!_Const> _It)
                noexcept(is_nothrow_constructible_v<iterator_t<_Base>, iterator_t<_Vw>>) 
                requires _Const && convertible_to<iterator_t<_Vw>, iterator_t<_Base>>
                : _Current{::std:: move(_It._Current)}, _Parent{_It._Parent} {}
            

            [[nodiscard]] constexpr const iterator_t<_Base>& base() const& noexcept {
                return _Current;
            }
            [[nodiscard]] constexpr iterator_t<_Base> base() && noexcept(
                is_nothrow_move_constructible_v<iterator_t<_Base>>)  {
                return ::std:: move(_Current);
            }

            [[nodiscard]] constexpr decltype(auto) operator*() const
                noexcept(noexcept(::std:: invoke(*_Parent->_Fun, *_Current))) {


#line 2011 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                return ::std:: invoke(*_Parent->_Fun, *_Current);
            }

            constexpr _Iterator& operator++() noexcept(noexcept(++_Current))  {


#line 2020 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                ++_Current;
                return *this;
            }

            constexpr decltype(auto) operator++(int) noexcept(
                noexcept(++_Current)
                && (!forward_range<_Base> || is_nothrow_copy_constructible_v<iterator_t<_Base>>) )  {
                if constexpr (forward_range<_Base>) {
                    auto _Tmp = *this;
                    ++*this;
                    return _Tmp;
                } else {
                    ++*this;
                }
            }

            constexpr _Iterator& operator--() noexcept(
                noexcept(--_Current))  requires bidirectional_range<_Base> {


#line 2045 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                --_Current;
                return *this;
            }
            constexpr _Iterator operator--(int) noexcept(
                noexcept(--_Current) && is_nothrow_copy_constructible_v<iterator_t<_Base>>) 
                requires bidirectional_range<_Base> {
                auto _Tmp = *this;
                --*this;
                return _Tmp;
            }

            constexpr void _Verify_offset(const difference_type _Off) const requires random_access_range<_Base> {

                (void) _Off;


#line 2083 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
            }

            constexpr _Iterator& operator+=(const difference_type _Off)
                noexcept(noexcept(_Current += _Off))  requires random_access_range<_Base> {


#line 2090 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                _Current += _Off;
                return *this;
            }
            constexpr _Iterator& operator-=(const difference_type _Off)
                noexcept(noexcept(_Current -= _Off))  requires random_access_range<_Base> {


#line 2098 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                _Current -= _Off;
                return *this;
            }

            [[nodiscard]] constexpr decltype(auto) operator[](const difference_type _Idx) const
                noexcept(noexcept(::std:: invoke(*_Parent->_Fun, _Current[_Idx]))) 
                requires random_access_range<_Base> {


#line 2110 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                return ::std:: invoke(*_Parent->_Fun, _Current[_Idx]);
            }

            [[nodiscard]] friend constexpr bool operator==(const _Iterator& _Left, const _Iterator& _Right) noexcept(
                noexcept(_Left._Current
                         == _Right._Current))  requires equality_comparable<iterator_t<_Base>> {


#line 2119 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                return _Left._Current == _Right._Current;
            }

            [[nodiscard]] friend constexpr bool operator<(const _Iterator& _Left, const _Iterator& _Right) noexcept(
                noexcept(_Left._Current < _Right._Current))  requires random_access_range<_Base> {


#line 2127 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                return _Left._Current < _Right._Current;
            }
            [[nodiscard]] friend constexpr bool operator>(const _Iterator& _Left, const _Iterator& _Right) noexcept(
                noexcept(_Left._Current < _Right._Current))  requires random_access_range<_Base> {
                return _Right < _Left;
            }
            [[nodiscard]] friend constexpr bool operator<=(const _Iterator& _Left, const _Iterator& _Right) noexcept(
                noexcept(_Left._Current < _Right._Current))  requires random_access_range<_Base> {
                return !(_Right < _Left);
            }
            [[nodiscard]] friend constexpr bool operator>=(const _Iterator& _Left, const _Iterator& _Right) noexcept(
                noexcept(_Left._Current < _Right._Current))  requires random_access_range<_Base> {
                return !(_Left < _Right);
            }
            
            [[nodiscard]] friend constexpr auto operator<=>(const _Iterator& _Left, const _Iterator& _Right) noexcept(
                noexcept(_Left._Current <=> _Right._Current)) 
                requires random_access_range<_Base> && three_way_comparable<iterator_t<_Base>> {
                

#line 2149 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                return _Left._Current <=> _Right._Current;
            }

            [[nodiscard]] friend constexpr _Iterator operator+(_Iterator _It, difference_type _Off)
                noexcept(noexcept(_It._Current += _Off))  requires random_access_range<_Base> {


#line 2157 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                _It._Current += _Off;
                return _It;
            }
            [[nodiscard]] friend constexpr _Iterator operator+(difference_type _Off, _Iterator _It)
                noexcept(noexcept(_It._Current += _Off))  requires random_access_range<_Base> {


#line 2165 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                _It._Current += _Off;
                return _It;
            }

            [[nodiscard]] friend constexpr _Iterator operator-(_Iterator _It, difference_type _Off)
                noexcept(noexcept(_It._Current -= _Off))  requires random_access_range<_Base> {


#line 2174 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                _It._Current -= _Off;
                return _It;
            }

            [[nodiscard]] friend constexpr difference_type operator-(const _Iterator& _Left,
                const _Iterator& _Right) noexcept(noexcept(_Left._Current - _Right._Current)) 
                requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>> {


#line 2184 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                return _Left._Current - _Right._Current;
            }
        };

        template <bool _Const>
        class _Sentinel {
        private:
            template <bool>
            friend class _Sentinel;

            using _Parent_t = _Maybe_const<_Const, transform_view>;
            using _Base     = _Maybe_const<_Const, _Vw>;
            template <bool _OtherConst>
            using _Maybe_const_iter = iterator_t<_Maybe_const<_OtherConst, _Vw>>;

            sentinel_t<_Base> _Last{};

            template <bool _OtherConst>
            [[nodiscard]] static constexpr const _Maybe_const_iter<_OtherConst>& _Get_current(
                const _Iterator<_OtherConst>& _It) noexcept {


#line 2208 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                return _It._Current;
            }

        public:
            _Sentinel() = default;
            constexpr explicit _Sentinel(sentinel_t<_Base> _Last_) noexcept(
                is_nothrow_move_constructible_v<sentinel_t<_Base>>) 
                : _Last(::std:: move(_Last_)) {}

            
            constexpr _Sentinel(_Sentinel<!_Const> _Se)
                noexcept(is_nothrow_constructible_v<sentinel_t<_Base>, sentinel_t<_Vw>>) 
                requires _Const && convertible_to<sentinel_t<_Vw>, sentinel_t<_Base>>
                : _Last(::std:: move(_Se._Last)) {}
            

            [[nodiscard]] constexpr sentinel_t<_Base> base() const
                noexcept(is_nothrow_copy_constructible_v<sentinel_t<_Base>>)  {
                return _Last;
            }

            
            template <bool _OtherConst>
                requires sentinel_for<sentinel_t<_Base>, _Maybe_const_iter<_OtherConst>>
            [[nodiscard]] friend constexpr bool operator==(const _Iterator<_OtherConst>& _Left,
                const _Sentinel& _Right) noexcept(noexcept(_Get_current(_Left) == _Right._Last))  {
                return _Get_current(_Left) == _Right._Last;
            }

            template <bool _OtherConst>
                requires sized_sentinel_for<sentinel_t<_Base>, _Maybe_const_iter<_OtherConst>>
            [[nodiscard]] friend constexpr range_difference_t<_Maybe_const<_OtherConst, _Vw>>
                operator-(const _Iterator<_OtherConst>& _Left, const _Sentinel& _Right) noexcept(
                    noexcept(_Get_current(_Left) - _Right._Last))  {
                return _Get_current(_Left) - _Right._Last;
            }

            template <bool _OtherConst>
                requires sized_sentinel_for<sentinel_t<_Base>, _Maybe_const_iter<_OtherConst>>
            [[nodiscard]] friend constexpr range_difference_t<_Maybe_const<_OtherConst, _Vw>>
                operator-(const _Sentinel& _Left, const _Iterator<_OtherConst>& _Right) noexcept(
                    noexcept(_Left._Last - _Get_current(_Right)))  {
                return _Left._Last - _Get_current(_Right);
            }
        };

    public:
        transform_view() requires default_initializable<_Vw> && default_initializable<_Fn> = default;
        

        constexpr transform_view(_Vw _Range_, _Fn _Fun_) noexcept(
            is_nothrow_move_constructible_v<_Vw>&& is_nothrow_move_constructible_v<_Fn>) 
            : _Range(::std:: move(_Range_)), _Fun{in_place, ::std:: move(_Fun_)} {}

        [[nodiscard]] constexpr _Vw base() const& noexcept(
            is_nothrow_copy_constructible_v<_Vw>)  requires copy_constructible<_Vw> {
            return _Range;
        }
        [[nodiscard]] constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>)  {
            return ::std:: move(_Range);
        }

        [[nodiscard]] constexpr _Iterator<false> begin() noexcept(
            noexcept(::std::ranges:: begin(_Range)) && is_nothrow_move_constructible_v<iterator_t<_Vw>>)  {
            return _Iterator<false>{*this, ::std::ranges:: begin(_Range)};
        }

        
        [[nodiscard]] constexpr _Iterator<true> begin() const noexcept(noexcept(
            ::std::ranges:: begin(_Range)) && is_nothrow_move_constructible_v<iterator_t<_Vw>>) 


            requires range<const _Vw> && regular_invocable<const _Fn&, range_reference_t<const _Vw>>
#line 2283 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
        {
            
            return _Iterator<true>{*this, ::std::ranges:: begin(_Range)};
        }

        
        [[nodiscard]] constexpr auto end() noexcept(noexcept(
            ::std::ranges:: end(_Range)) && is_nothrow_move_constructible_v<decltype(::std::ranges:: end(_Range))>)  {
            
            if constexpr (common_range<_Vw>) {
                return _Iterator<false>{*this, ::std::ranges:: end(_Range)};
            } else {
                return _Sentinel<false>{::std::ranges:: end(_Range)};
            }
        }

        
        [[nodiscard]] constexpr auto end() const noexcept(noexcept(
            ::std::ranges:: end(_Range)) && is_nothrow_move_constructible_v<decltype(::std::ranges:: end(_Range))>) 


            requires range<const _Vw> && regular_invocable<const _Fn&, range_reference_t<const _Vw>>
#line 2307 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
        {
            
            if constexpr (common_range<_Vw>) {
                return _Iterator<true>{*this, ::std::ranges:: end(_Range)};
            } else {
                return _Sentinel<true>{::std::ranges:: end(_Range)};
            }
        }

        [[nodiscard]] constexpr auto size() noexcept(
            noexcept(::std::ranges:: size(_Range)))  requires sized_range<_Vw> {
            return ::std::ranges:: size(_Range);
        }
        [[nodiscard]] constexpr auto size() const
            noexcept(noexcept(::std::ranges:: size(_Range)))  requires sized_range<const _Vw> {
            return ::std::ranges:: size(_Range);
        }
    };


    template <class _Rng, class _Fn>
    transform_view(_Rng&&, _Fn) -> transform_view<views::all_t<_Rng>, _Fn>;

    namespace views {
        struct _Transform_fn {
            
            template <viewable_range _Rng, class _Fn>
            [[nodiscard]] constexpr auto operator()(_Rng&& _Range, _Fn _Fun) const noexcept(noexcept(
                transform_view(::std:: forward<_Rng>(_Range), ::std:: move(_Fun)))) requires requires {
                transform_view(static_cast<_Rng&&>(_Range), ::std:: move(_Fun));
            } {
                
                return transform_view(::std:: forward<_Rng>(_Range), ::std:: move(_Fun));
            }

            
            template <class _Fn>
                requires constructible_from<decay_t<_Fn>, _Fn>
            [[nodiscard]] constexpr auto operator()(_Fn&& _Fun) const
                noexcept(is_nothrow_constructible_v<decay_t<_Fn>, _Fn>) {
                
                return _Range_closure<_Transform_fn, decay_t<_Fn>>{::std:: forward<_Fn>(_Fun)};
            }
        };

        inline constexpr _Transform_fn transform;
    } 

    template <view _Vw>
    class take_view : public view_interface<take_view<_Vw>> {
    private:
         _Vw _Range{};
        range_difference_t<_Vw> _Count = 0;

        template <bool _Const, bool _Wrapped = true>
        class _Sentinel {
        private:
            template <bool, bool>
            friend class _Sentinel;

            using _Base_t        = _Maybe_const<_Const, _Vw>;
            using _Base_sentinel = _Maybe_wrapped<_Wrapped, sentinel_t<_Base_t>>;
            template <bool _OtherConst>
            using _Base_iterator = _Maybe_wrapped<_Wrapped, iterator_t<_Maybe_const<_OtherConst, _Vw>>>;
            template <bool _OtherConst>
            using _Counted_iter = counted_iterator<_Base_iterator<_OtherConst>>;

            _Base_sentinel _Last{};

        public:
            _Sentinel() = default;

            constexpr explicit _Sentinel(_Base_sentinel _Last_) noexcept(
                is_nothrow_move_constructible_v<_Base_sentinel>) 
                : _Last(::std:: move(_Last_)) {}

            
            constexpr _Sentinel(_Sentinel<!_Const, _Wrapped> _That) noexcept(
                is_nothrow_constructible_v<_Base_sentinel, _Maybe_wrapped<_Wrapped, sentinel_t<_Vw>>>) 
                requires _Const && convertible_to<_Maybe_wrapped<_Wrapped, sentinel_t<_Vw>>, _Base_sentinel>
                : _Last(::std:: move(_That._Last)) {}
            

            [[nodiscard]] constexpr _Base_sentinel base() const
                noexcept(is_nothrow_copy_constructible_v<_Base_sentinel>)  {
                return _Last;
            }

            [[nodiscard]] friend constexpr bool operator==(const _Counted_iter<_Const>& _Left, const _Sentinel& _Right) {
                return _Left.count() == 0 || _Left.base() == _Right._Last;
            }

            
            template <bool _OtherConst = !_Const>
                requires sentinel_for<_Base_sentinel, _Base_iterator<_OtherConst>>
            [[nodiscard]] friend constexpr bool operator==(
                const _Counted_iter<_OtherConst>& _Left, const _Sentinel& _Right) {
                
                return _Left.count() == 0 || _Left.base() == _Right._Last;
            }

            using _Prevent_inheriting_unwrap = _Sentinel;

            
            [[nodiscard]] constexpr auto _Unwrapped() const&
                requires _Wrapped && _Unwrappable_v<const iterator_t<_Base_t>&> {
                
                return _Sentinel<_Const, false>{_Get_unwrapped(_Last)};
            }
            
            [[nodiscard]] constexpr auto _Unwrapped() && requires _Wrapped && _Unwrappable_v<iterator_t<_Base_t>> {
                
                return _Sentinel<_Const, false>{_Get_unwrapped(::std:: move(_Last))};
            }

            static constexpr bool _Unwrap_when_unverified = _Do_unwrap_when_unverified_v<iterator_t<_Base_t>>;

            constexpr void _Seek_to(const _Sentinel<_Const, false>& _That) requires _Wrapped {
                _Seek_wrapped(_Last, _That._Last);
            }
            constexpr void _Seek_to(_Sentinel<_Const, false>&& _That) requires _Wrapped {
                _Seek_wrapped(_Last, ::std:: move(_That._Last));
            }
        };

    public:
        
        take_view() requires default_initializable<_Vw> = default;
        

        constexpr take_view(_Vw _Range_, const range_difference_t<_Vw> _Count_) noexcept(
            is_nothrow_move_constructible_v<_Vw>) 
            : _Range(::std:: move(_Range_)), _Count{_Count_} {}

        [[nodiscard]] constexpr _Vw base() const& noexcept(
            is_nothrow_copy_constructible_v<_Vw>)  requires copy_constructible<_Vw> {
            return _Range;
        }
        [[nodiscard]] constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>)  {
            return ::std:: move(_Range);
        }

        
        [[nodiscard]] constexpr auto begin() requires (!_Simple_view<_Vw>) {
            
            if constexpr (sized_range<_Vw>) {
                if constexpr (random_access_range<_Vw>) {
                    return ::std::ranges:: begin(_Range);
                } else {
                    const auto _Size = static_cast<range_difference_t<_Vw>>(size());
                    return counted_iterator(::std::ranges:: begin(_Range), _Size);
                }
            } else {
                return counted_iterator(::std::ranges:: begin(_Range), _Count);
            }
        }

        [[nodiscard]] constexpr auto begin() const requires range<const _Vw> {
            if constexpr (sized_range<const _Vw>) {
                if constexpr (random_access_range<const _Vw>) {
                    return ::std::ranges:: begin(_Range);
                } else {
                    const auto _Size = static_cast<range_difference_t<_Vw>>(size());
                    return counted_iterator(::std::ranges:: begin(_Range), _Size);
                }
            } else {
                return counted_iterator(::std::ranges:: begin(_Range), _Count);
            }
        }

        
        [[nodiscard]] constexpr auto end() requires (!_Simple_view<_Vw>) {
            
            if constexpr (sized_range<_Vw>) {
                if constexpr (random_access_range<_Vw>) {
                    return ::std::ranges:: begin(_Range) + static_cast<range_difference_t<_Vw>>(size());
                } else {
                    return default_sentinel;
                }
            } else {
                return _Sentinel<false>{::std::ranges:: end(_Range)};
            }
        }

        [[nodiscard]] constexpr auto end() const requires range<const _Vw> {
            if constexpr (sized_range<const _Vw>) {
                if constexpr (random_access_range<const _Vw>) {
                    return ::std::ranges:: begin(_Range) + static_cast<range_difference_t<_Vw>>(size());
                } else {
                    return default_sentinel;
                }
            } else {
                return _Sentinel<true>{::std::ranges:: end(_Range)};
            }
        }

        [[nodiscard]] constexpr auto size() requires sized_range<_Vw> {
            const auto _Length = ::std::ranges:: size(_Range);
            return (::std:: min)(_Length, static_cast<decltype(_Length)>(_Count));
        }

        [[nodiscard]] constexpr auto size() const requires sized_range<const _Vw> {
            const auto _Length = ::std::ranges:: size(_Range);
            return (::std:: min)(_Length, static_cast<decltype(_Length)>(_Count));
        }
    };

    template <class _Rng>
    take_view(_Rng&&, range_difference_t<_Rng>) -> take_view<views::all_t<_Rng>>;

    template <class _Rng>
    inline constexpr bool enable_borrowed_range<take_view<_Rng>> = enable_borrowed_range<_Rng>;

    namespace views {
        template <class>
        inline constexpr bool _Is_subrange = false;
        template <class _It, class _Se, subrange_kind _Ki>
        inline constexpr bool _Is_subrange<subrange<_It, _Se, _Ki>> = true;

        template <class _Rng>
        concept _Random_sized_range = random_access_range<_Rng> && sized_range<_Rng>;

        class _Take_fn {
        private:
            enum class _St {
                _Empty,
                _Reconstruct_span,
                _Reconstruct_string_view,
                _Reconstruct_iota_view,
                _Reconstruct_subrange,
                _Take_view
            };

            template <class _Rng>
            [[nodiscard]] static consteval _Choice_t<_St> _Choose() noexcept {
                using _Ty = remove_cvref_t<_Rng>;

                if constexpr (_Is_specialization_v<_Ty, empty_view>) {
                    return {_St::_Empty, true};
                } else if constexpr (_Is_span_v<_Ty>) {
                    return {_St::_Reconstruct_span, true};
                } else if constexpr (_Is_specialization_v<_Ty, basic_string_view>) {
                    return {_St::_Reconstruct_string_view, true};
                } else if constexpr (_Random_sized_range<_Ty> && _Is_specialization_v<_Ty, iota_view>) {
                    return {_St::_Reconstruct_iota_view,
                        noexcept(::std::ranges:: begin(::std:: declval<_Rng&>()) + ::std::ranges:: distance(::std:: declval<_Rng&>()))};
                } else if constexpr (_Random_sized_range<_Ty> && _Is_subrange<_Ty>) {
                    return {_St::_Reconstruct_subrange,
                        noexcept(subrange(::std::ranges:: begin(::std:: declval<_Rng&>()),
                            ::std::ranges:: begin(::std:: declval<_Rng&>()) + ::std::ranges:: distance(::std:: declval<_Rng&>())))};
                } else {
                    return {_St::_Take_view, noexcept(take_view(::std:: declval<_Rng>(), range_difference_t<_Rng>{0}))};
                }
            }

            template <class _Rng>
            static constexpr _Choice_t<_St> _Choice = _Choose<_Rng>();

        public:
            template <viewable_range _Rng>
            [[nodiscard]] constexpr auto operator()(_Rng&& _Range, range_difference_t<_Rng> _Count) const
                noexcept(_Choice<_Rng>._No_throw) {
                constexpr _St _Strat = _Choice<_Rng>._Strategy;

                if constexpr (_Strat == _St::_Empty) {
                    
                    return remove_cvref_t<_Rng>{};
                } else if constexpr (_Strat == _St::_Take_view) {
                    return take_view(::std:: forward<_Rng>(_Range), _Count);
                } else {
                    
                    _Count            = (::std:: min)(::std::ranges:: distance(_Range), _Count);
                    const auto _First = ::std::ranges:: begin(_Range);

                    if constexpr (_Strat == _St::_Reconstruct_span) {
                        return span(_First, _First + _Count);
                    } else if constexpr (_Strat == _St::_Reconstruct_string_view) {
                        return remove_cvref_t<_Rng>(_First, _First + _Count);
                    } else if constexpr (_Strat == _St::_Reconstruct_iota_view) {
                        using _Vt = range_value_t<_Rng>;
                        return iota_view<_Vt, _Vt>(_First, _First + _Count);
                    } else if constexpr (_Strat == _St::_Reconstruct_subrange) {
                        return subrange(_First, _First + _Count);
                    } else {
                        static_assert(_Always_false<_Rng>, "Should be unreachable");
                    }
                }
            }

            
            template <class _Ty>
                requires constructible_from<decay_t<_Ty>, _Ty>
            [[nodiscard]] constexpr auto operator()(_Ty&& _Length) const
            noexcept(is_nothrow_constructible_v<decay_t<_Ty>, _Ty>) {
                
                return _Range_closure<_Take_fn, decay_t<_Ty>>{::std:: forward<_Ty>(_Length)};
            }
        };

        inline constexpr _Take_fn take;
    } 

    
    template <view _Vw, class _Pr>
        requires input_range<_Vw> && is_object_v<_Pr> && indirect_unary_predicate<const _Pr, iterator_t<_Vw>>
    class take_while_view : public view_interface<take_while_view<_Vw, _Pr>>  {
        
    private:
         _Vw _Range{};
         _Copyable_box<_Pr> _Pred{};

        template <bool _Const, bool _Wrapped = true>
        class _Sentinel {
        private:
            template <bool, bool>
            friend class _Sentinel;

            using _Base_t        = _Maybe_const<_Const, _Vw>;
            using _Base_iterator = _Maybe_wrapped<_Wrapped, iterator_t<_Base_t>>;
            using _Base_sentinel = _Maybe_wrapped<_Wrapped, sentinel_t<_Base_t>>;

            template <bool _OtherConst>
            using _Maybe_const_iter = _Maybe_wrapped<_Wrapped, iterator_t<_Maybe_const<_OtherConst, _Vw>>>;

             _Base_sentinel _Last{};
            const _Pr* _Pred = nullptr;

        public:
            _Sentinel() = default;

            constexpr explicit _Sentinel(_Base_sentinel _Last_, const _Pr* const _Pred_) noexcept(
                is_nothrow_move_constructible_v<_Base_sentinel>) 
                : _Last(::std:: move(_Last_)), _Pred(_Pred_) {}

            
            constexpr _Sentinel(_Sentinel<!_Const, _Wrapped> _That) noexcept(
                is_nothrow_constructible_v<_Base_sentinel, _Maybe_wrapped<_Wrapped, sentinel_t<_Vw>>>) 
                requires _Const && convertible_to<_Maybe_wrapped<_Wrapped, sentinel_t<_Vw>>, _Base_sentinel>
                : _Last(::std:: move(_That._Last)), _Pred(_That._Pred) {}
            

            [[nodiscard]] constexpr _Base_sentinel base() const
                noexcept(is_nothrow_copy_constructible_v<_Base_sentinel>)  {
                return _Last;
            }

            [[nodiscard]] friend constexpr bool operator==(const _Base_iterator& _Left, const _Sentinel& _Right) {
                return _Right._Last == _Left || !::std:: invoke(*_Right._Pred, *_Left);
            }

            
            template <bool _OtherConst = !_Const>
                requires sentinel_for<_Base_sentinel, _Maybe_const_iter<_OtherConst>>
            [[nodiscard]] friend constexpr bool operator==(
                const _Maybe_const_iter<_OtherConst>& _Left, const _Sentinel& _Right) {
                
                return _Right._Last == _Left || !::std:: invoke(*_Right._Pred, *_Left);
            }

            using _Prevent_inheriting_unwrap = _Sentinel;

            
            [[nodiscard]] constexpr auto _Unwrapped() const&
                requires _Wrapped && _Unwrappable_v<const iterator_t<_Base_t>&> {
                
                return _Sentinel<_Const, false>{_Get_unwrapped(_Last), _Pred};
            }
            
            [[nodiscard]] constexpr auto _Unwrapped() && requires _Wrapped && _Unwrappable_v<iterator_t<_Base_t>> {
                
                return _Sentinel<_Const, false>{_Get_unwrapped(::std:: move(_Last)), _Pred};
            }

            static constexpr bool _Unwrap_when_unverified = _Do_unwrap_when_unverified_v<iterator_t<_Base_t>>;

            constexpr void _Seek_to(const _Sentinel<_Const, false>& _That) requires _Wrapped {
                _Seek_wrapped(_Last, _That._Last);
            }
            constexpr void _Seek_to(_Sentinel<_Const, false>&& _That) requires _Wrapped {
                _Seek_wrapped(_Last, ::std:: move(_That._Last));
            }
        };

    public:
        
        take_while_view() requires default_initializable<_Vw> && default_initializable<_Pr> = default;
        

        constexpr take_while_view(_Vw _Range_, _Pr _Pred_) noexcept(
            is_nothrow_move_constructible_v<_Vw>&& is_nothrow_move_constructible_v<_Pr>) 
            : _Range(::std:: move(_Range_)), _Pred{in_place, ::std:: move(_Pred_)} {}

        [[nodiscard]] constexpr _Vw base() const& noexcept(
            is_nothrow_copy_constructible_v<_Vw>)  requires copy_constructible<_Vw> {
            return _Range;
        }
        [[nodiscard]] constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>)  {
            return ::std:: move(_Range);
        }

        [[nodiscard]] constexpr const _Pr& pred() const noexcept  {


#line 2712 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
            return *_Pred;
        }

        
        [[nodiscard]] constexpr auto begin() noexcept(
            noexcept(::std::ranges:: begin(_Range)))  requires (!_Simple_view<_Vw>) {
            
            return ::std::ranges:: begin(_Range);
        }

        
        [[nodiscard]] constexpr auto begin() const noexcept(
            noexcept(::std::ranges:: begin(_Range)))  requires range<const _Vw>
            && indirect_unary_predicate<const _Pr, iterator_t<const _Vw>> {
            
            return ::std::ranges:: begin(_Range);
        }

        
        [[nodiscard]] constexpr auto end() noexcept(
            noexcept(::std::ranges:: end(_Range)) && is_nothrow_move_constructible_v<_Sentinel<false>>) 
            requires (!_Simple_view<_Vw>) {
            

#line 2738 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
            return _Sentinel<false>{::std::ranges:: end(_Range), ::std:: addressof(*_Pred)};
        }

        
        [[nodiscard]] constexpr auto end() const noexcept(
            noexcept(::std::ranges:: end(_Range)) && is_nothrow_move_constructible_v<_Sentinel<true>>) 
            requires range<const _Vw> && indirect_unary_predicate<const _Pr, iterator_t<const _Vw>> {
            

#line 2749 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
            return _Sentinel<true>{::std::ranges:: end(_Range), ::std:: addressof(*_Pred)};
        }
    };

    template <class _Rng, class _Pr>
    take_while_view(_Rng&&, _Pr) -> take_while_view<views::all_t<_Rng>, _Pr>;

    namespace views {
        struct _Take_while_fn {
            template <viewable_range _Rng, class _Pr>
            [[nodiscard]] constexpr auto operator()(_Rng&& _Range, _Pr _Pred) const
                noexcept(noexcept(take_while_view(::std:: forward<_Rng>(_Range), ::std:: move(_Pred)))) requires requires {
                take_while_view(static_cast<_Rng&&>(_Range), ::std:: move(_Pred));
            }
            { return take_while_view(::std:: forward<_Rng>(_Range), ::std:: move(_Pred)); }

            
            template <class _Pr>
                requires constructible_from<decay_t<_Pr>, _Pr>
            [[nodiscard]] constexpr auto operator()(_Pr&& _Pred) const
                noexcept(is_nothrow_constructible_v<decay_t<_Pr>, _Pr>) {
                
                return _Range_closure<_Take_while_fn, decay_t<_Pr>>{::std:: forward<_Pr>(_Pred)};
            }
        };

        inline constexpr _Take_while_fn take_while;
    } 

    template <view _Vw>
    class drop_view : public _Cached_position_t<forward_range<_Vw> && !(random_access_range<_Vw> && sized_range<_Vw>),
                          _Vw, drop_view<_Vw>> {
    private:
         _Vw _Range{};
        range_difference_t<_Vw> _Count = 0;

        [[nodiscard]] constexpr auto _Find_first() {
            if constexpr (sized_range<_Vw>) {
                ;
                auto _Offset = ::std::ranges:: distance(_Range);
                if constexpr (bidirectional_range<_Vw> && common_range<_Vw>) {
                    if (_Count >= _Offset / 2) {
                        auto _Result = ::std::ranges:: end(_Range);
                        while (_Offset > _Count) {
                            --_Offset;
                            --_Result;
                        }

                        return _Result;
                    }
                }

                if (_Offset > _Count) {
                    _Offset = _Count;
                }

                return ::std::ranges:: next(::std::ranges:: begin(_Range), _Offset);
            } else {
                return ::std::ranges:: next(::std::ranges:: begin(_Range), _Count, ::std::ranges:: end(_Range));
            }
        }

    public:
        
        drop_view() requires default_initializable<_Vw> = default;
        

        constexpr drop_view(_Vw _Range_, const range_difference_t<_Vw> _Count_) noexcept(
            is_nothrow_move_constructible_v<_Vw>) 
            : _Range(::std:: move(_Range_)), _Count{_Count_} {


#line 2822 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
        }

        [[nodiscard]] constexpr _Vw base() const& noexcept(
            is_nothrow_copy_constructible_v<_Vw>)  requires copy_constructible<_Vw> {
            return _Range;
        }
        [[nodiscard]] constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>)  {
            return ::std:: move(_Range);
        }

        
        [[nodiscard]] constexpr auto begin()
            requires (!(_Simple_view<_Vw> && random_access_range<const _Vw> && sized_range<const _Vw>)) {
            
            if constexpr (sized_range<_Vw> && random_access_range<_Vw>) {
                const auto _Offset = (::std:: min)(::std::ranges:: distance(_Range), _Count);
                return ::std::ranges:: begin(_Range) + _Offset;
            } else {
                if constexpr (forward_range<_Vw>) {
                    if (this->_Has_cache()) {
                        return this->_Get_cache(_Range);
                    }
                }

                same_as<iterator_t<_Vw>> auto _Result = _Find_first();
                if constexpr (forward_range<_Vw>) {
                    this->_Set_cache(_Range, _Result);
                }
                return _Result;
            }
        }

        
        [[nodiscard]] constexpr auto begin() const
            requires random_access_range<const _Vw> && sized_range<const _Vw> {
            
            const auto _Offset = (::std:: min)(::std::ranges:: distance(_Range), _Count);
            return ::std::ranges:: begin(_Range) + _Offset;
        }

        
        [[nodiscard]] constexpr auto end() requires (!_Simple_view<_Vw>) {
            
            return ::std::ranges:: end(_Range);
        }

        [[nodiscard]] constexpr auto end() const requires range<const _Vw> {
            return ::std::ranges:: end(_Range);
        }

        [[nodiscard]] constexpr auto size() requires sized_range<_Vw> {
            const auto _Size          = ::std::ranges:: size(_Range);
            const auto _Count_as_size = static_cast<range_size_t<_Vw>>(_Count);
            if (_Size < _Count_as_size) {
                return range_size_t<_Vw>{0};
            } else {
                return static_cast<range_size_t<_Vw>>(_Size - _Count_as_size);
            }
        }

        [[nodiscard]] constexpr auto size() const requires sized_range<const _Vw> {
            const auto _Size          = ::std::ranges:: size(_Range);
            const auto _Count_as_size = static_cast<range_size_t<_Vw>>(_Count);
            if (_Size < _Count_as_size) {
                return range_size_t<_Vw>{0};
            } else {
                return static_cast<range_size_t<_Vw>>(_Size - _Count_as_size);
            }
        }
    };

    template <class _Rng>
    drop_view(_Rng&&, range_difference_t<_Rng>) -> drop_view<views::all_t<_Rng>>;

    template <class _Rng>
    inline constexpr bool enable_borrowed_range<drop_view<_Rng>> = enable_borrowed_range<_Rng>;

    namespace views {
        class _Drop_fn {
        private:
            enum class _St { _Empty, _Reconstruct_span, _Reconstruct_subrange, _Reconstruct_other, _Drop_view };

            template <class _Rng>
            [[nodiscard]] static consteval _Choice_t<_St> _Choose() noexcept {
                using _Ty = remove_cvref_t<_Rng>;

                if constexpr (_Is_specialization_v<_Ty, empty_view>) {
                    return {_St::_Empty, true};
                } else if constexpr (_Is_span_v<_Ty>) {
                    return {_St::_Reconstruct_span, true};
                } else if constexpr (_Is_specialization_v<_Ty, basic_string_view>) {
                    return {_St::_Reconstruct_other, true};
                } else if constexpr (_Random_sized_range<_Ty> && _Is_subrange<_Ty>) {
                    if constexpr (sized_sentinel_for<sentinel_t<_Ty>, iterator_t<_Ty>>) {
                        return {_St::_Reconstruct_subrange,
                            noexcept(_Ty(::std::ranges:: begin(::std:: declval<_Rng&>()) + ::std::ranges:: distance(::std:: declval<_Rng&>()),
                                ::std::ranges:: end(::std:: declval<_Rng&>())))};
                    } else {
                        return {_St::_Reconstruct_subrange,
                            noexcept(_Ty(::std::ranges:: begin(::std:: declval<_Rng&>()) + ::std::ranges:: distance(::std:: declval<_Rng&>()),
                                ::std::ranges:: end(::std:: declval<_Rng&>()), range_difference_t<_Rng>{0}))};
                    }
                } else if constexpr (_Random_sized_range<_Ty> && _Is_specialization_v<_Ty, iota_view>) {
                    return {_St::_Reconstruct_other,
                        noexcept(_Ty(::std::ranges:: begin(::std:: declval<_Rng&>()) + ::std::ranges:: distance(::std:: declval<_Rng&>()),
                            ::std::ranges:: end(::std:: declval<_Rng&>())))};
                } else {
                    return {_St::_Drop_view, noexcept(drop_view(::std:: declval<_Rng>(), range_difference_t<_Rng>{0}))};
                }
            }

            template <class _Rng>
            static constexpr _Choice_t<_St> _Choice = _Choose<_Rng>();

        public:
            template <viewable_range _Rng>
            [[nodiscard]] constexpr auto operator()(_Rng&& _Range, range_difference_t<_Rng> _Count) const
                noexcept(_Choice<_Rng>._No_throw) {
                constexpr _St _Strat = _Choice<_Rng>._Strategy;

                if constexpr (_Strat == _St::_Empty) {
                    
                    return remove_cvref_t<_Rng>{};
                } else if constexpr (_Strat == _St::_Drop_view) {
                    return drop_view(::std:: forward<_Rng>(_Range), _Count);
                } else {
                    
                    _Count = (::std:: min)(::std::ranges:: distance(_Range), _Count);

                    if constexpr (_Strat == _St::_Reconstruct_span) {
                        return span(_Ubegin(_Range) + _Count, _Uend(_Range));
                    } else if constexpr (_Strat == _St::_Reconstruct_subrange) {
                        if constexpr (sized_sentinel_for<sentinel_t<_Rng>, iterator_t<_Rng>>) {
                            return remove_cvref_t<_Rng>(::std::ranges:: begin(_Range) + _Count, ::std::ranges:: end(_Range));
                        } else {
                            return remove_cvref_t<_Rng>(
                                ::std::ranges:: begin(_Range) + _Count, ::std::ranges:: end(_Range), ::std::ranges:: size(_Range) - _Count);
                        }
                    } else if constexpr (_Strat == _St::_Reconstruct_other) {
                        return remove_cvref_t<_Rng>(::std::ranges:: begin(_Range) + _Count, ::std::ranges:: end(_Range));
                    } else {
                        static_assert(_Always_false<_Rng>, "Should be unreachable");
                    }
                }
            }

            
            template <class _Ty>
                requires constructible_from<decay_t<_Ty>, _Ty>
            [[nodiscard]] constexpr auto operator()(_Ty&& _Length) const
                noexcept(is_nothrow_constructible_v<decay_t<_Ty>, _Ty>) {
                
                return _Range_closure<_Drop_fn, decay_t<_Ty>>{::std:: forward<_Ty>(_Length)};
            }
        };

        inline constexpr _Drop_fn drop;
    } 

    
    template <view _Vw, class _Pr>
        requires input_range<_Vw> && is_object_v<_Pr> && indirect_unary_predicate<const _Pr, iterator_t<_Vw>>
    class drop_while_view : public _Cached_position_t<forward_range<_Vw>, _Vw, drop_while_view<_Vw, _Pr>> {
        
    private:
         _Vw _Range{};
         _Copyable_box<_Pr> _Pred{};

    public:
        
        drop_while_view() requires default_initializable<_Vw> && default_initializable<_Pr> = default;
        

        constexpr drop_while_view(_Vw _Range_, _Pr _Pred_) noexcept(
            is_nothrow_move_constructible_v<_Vw>&& is_nothrow_move_constructible_v<_Pr>) 
            : _Range(::std:: move(_Range_)), _Pred{in_place, ::std:: move(_Pred_)} {}

        [[nodiscard]] constexpr _Vw base() const& noexcept(
            is_nothrow_copy_constructible_v<_Vw>)  requires copy_constructible<_Vw> {
            return _Range;
        }
        [[nodiscard]] constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>)  {
            return ::std:: move(_Range);
        }

        [[nodiscard]] constexpr const _Pr& pred() const noexcept  {


#line 3011 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
            return *_Pred;
        }

        [[nodiscard]] constexpr auto begin() {


#line 3019 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
            if constexpr (forward_range<_Vw>) {
                if (this->_Has_cache()) {
                    return this->_Get_cache(_Range);
                }
            }

            auto _First = ::std::ranges:: find_if_not(_Range, ::std:: cref(*_Pred));
            if constexpr (forward_range<_Vw>) {
                this->_Set_cache(_Range, _First);
            }

            return _First;
        }

        [[nodiscard]] constexpr auto end() noexcept(noexcept(::std::ranges:: end(_Range)))  {
            return ::std::ranges:: end(_Range);
        }
    };

    template <class _Rng, class _Pr>
    drop_while_view(_Rng&&, _Pr) -> drop_while_view<views::all_t<_Rng>, _Pr>;

    template <class _Rng, class _Pr>
    inline constexpr bool enable_borrowed_range<drop_while_view<_Rng, _Pr>> = enable_borrowed_range<_Rng>;

    namespace views {
        struct _Drop_while_fn {
            template <viewable_range _Rng, class _Pr>
            [[nodiscard]] constexpr auto operator()(_Rng&& _Range, _Pr _Pred) const
                noexcept(noexcept(drop_while_view(::std:: forward<_Rng>(_Range), ::std:: move(_Pred)))) requires requires {
                drop_while_view(static_cast<_Rng&&>(_Range), ::std:: move(_Pred));
            }
            { return drop_while_view(::std:: forward<_Rng>(_Range), ::std:: move(_Pred)); }

            
            template <class _Pr>
                requires constructible_from<decay_t<_Pr>, _Pr>
            [[nodiscard]] constexpr auto operator()(_Pr&& _Pred) const
                noexcept(is_nothrow_constructible_v<decay_t<_Pr>, _Pr>) {
                
                return _Range_closure<_Drop_while_fn, decay_t<_Pr>>{::std:: forward<_Pr>(_Pred)};
            }
        };

        inline constexpr _Drop_while_fn drop_while;
    } 

    
    template <input_range _Vw>
        requires view<_Vw> && input_range<range_reference_t<_Vw>>
    class join_view;
    

    template <class _Vw>
    class _Join_view_base : public view_interface<join_view<_Vw>> {
    private:
        struct _Cache_wrapper {
            template <input_iterator _Iter>
            constexpr _Cache_wrapper(_Not_quite_object::_Construct_tag, const _Iter& _It) noexcept(noexcept(*_It))
                : _Val(*_It) {}

            remove_cv_t<range_reference_t<_Vw>> _Val;
        };

    protected:
         _Non_propagating_cache<_Cache_wrapper, false> _Inner{};
    };

    template <class _Rng> 
    concept _Can_const_join = input_range<const _Rng> && is_reference_v<range_reference_t<const _Rng>>;

    
    template <class _Vw>
        requires is_reference_v<range_reference_t<_Vw>>
    class _Join_view_base<_Vw> : public view_interface<join_view<_Vw>> {};

    template <input_range _Vw>
        requires view<_Vw> && input_range<range_reference_t<_Vw>>
    class join_view : public _Join_view_base<_Vw> {
        
    private:
        template <bool _Const>
        using _InnerRng = range_reference_t<_Maybe_const<_Const, _Vw>>;
         _Vw _Range{};

        template <bool _Const>
        class _Sentinel;

        template <class _Outer, class _Inner, bool _Deref_is_glvalue>
        struct _Category_base {};

        template <forward_range _Outer, forward_range _Inner>
        struct _Category_base<_Outer, _Inner, true> {
            using iterator_category =
                conditional_t<common_range<_Inner> 
                                  && derived_from<_Iter_cat_t<iterator_t<_Outer>>, bidirectional_iterator_tag> 
                                  && derived_from<_Iter_cat_t<iterator_t<_Inner>>, bidirectional_iterator_tag>,
                    bidirectional_iterator_tag,
                    conditional_t<derived_from<_Iter_cat_t<iterator_t<_Outer>>, forward_iterator_tag> 
                                      && derived_from<_Iter_cat_t<iterator_t<_Inner>>, forward_iterator_tag>,
                        forward_iterator_tag, input_iterator_tag>>;
        };

        template <bool _Const>
        class _Iterator
            : public _Category_base<_Maybe_const<_Const, _Vw>, _InnerRng<_Const>, is_reference_v<_InnerRng<_Const>>> {
        private:
            template <bool>
            friend class _Iterator;
            template <bool>
            friend class _Sentinel;

            using _Parent_t  = _Maybe_const<_Const, join_view>;
            using _Base      = _Maybe_const<_Const, _Vw>;
            using _OuterIter = iterator_t<_Base>;
            using _InnerIter = iterator_t<_InnerRng<_Const>>;

            
            static constexpr bool _Deref_is_glvalue = is_reference_v<_InnerRng<_Const>>;

             _OuterIter _Outer{};
             _Defaultabox<_InnerIter> _Inner{}; 
            _Parent_t* _Parent{};

            constexpr auto&& _Update_inner() {
                if constexpr (_Deref_is_glvalue) {
                    return *_Outer;
                } else {
                    return _Parent->_Inner._Emplace(_Not_quite_object::_Construct_tag{}, _Outer)._Val;
                }
            }

            constexpr void _Satisfy() {
                const auto _Last = ::std::ranges:: end(_Parent->_Range);
                for (; _Outer != _Last; ++_Outer) {
                    auto&& _Tmp = _Update_inner();
                    _Inner      = ::std::ranges:: begin(_Tmp);
                    if (*_Inner != ::std::ranges:: end(_Tmp)) {
                        return;
                    }
                }
                if constexpr (_Deref_is_glvalue) {
                    _Inner._Reset();
                }
            }


#line 3182 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"

        public:
            
            using iterator_concept = conditional_t<_Deref_is_glvalue
                && bidirectional_range<_Base> && bidirectional_range<_InnerRng<_Const>>
                && common_range<_InnerRng<_Const>>, bidirectional_iterator_tag,
                conditional_t<_Deref_is_glvalue && forward_range<_Base> && forward_range<_InnerRng<_Const>>,
                    forward_iterator_tag, input_iterator_tag>>;
            
            using value_type      = range_value_t<_InnerRng<_Const>>;
            using difference_type = common_type_t<range_difference_t<_Base>, range_difference_t<_InnerRng<_Const>>>;

            
            _Iterator() requires default_initializable<_OuterIter> = default; 
            

            constexpr _Iterator(_Parent_t& _Parent_, _OuterIter _Outer_)
                : _Outer{::std:: move(_Outer_)}, _Parent{::std:: addressof(_Parent_)} {


#line 3206 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                _Satisfy();
            }

            
            constexpr _Iterator(_Iterator<!_Const> _It)
                requires _Const && convertible_to<iterator_t<_Vw>, _OuterIter>
                      && convertible_to<iterator_t<_InnerRng<false>>, _InnerIter>
                : _Outer{::std:: move(_It._Outer)}, _Inner{::std:: move(_It._Inner)}, _Parent{_It._Parent} {}
            

            [[nodiscard]] constexpr decltype(auto) operator*() const noexcept(noexcept(**_Inner))  {


#line 3220 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                return **_Inner;
            }

            
            [[nodiscard]] constexpr _InnerIter operator->() const noexcept(is_nothrow_copy_constructible_v<_InnerIter>)
                 requires _Has_arrow<_InnerIter> && copyable<_InnerIter> {
                

#line 3230 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                return *_Inner;
            }

            constexpr _Iterator& operator++() {
                if constexpr (_Deref_is_glvalue) {
                    if (++*_Inner == ::std::ranges:: end(*_Outer)) {
                        ++_Outer;
                        _Satisfy();
                    }
                } else {
                    if (++*_Inner == ::std::ranges:: end((*_Parent->_Inner)._Val)) {
                        ++_Outer;
                        _Satisfy();
                    }
                }
                return *this;
            }

            constexpr decltype(auto) operator++(int) {
                if constexpr (_Deref_is_glvalue && forward_range<_Base> && forward_range<_InnerRng<_Const>>) {
                    auto _Tmp = *this;
                    ++*this;
                    return _Tmp;
                } else {
                    ++*this;
                }
            }

            
            constexpr _Iterator& operator--()
                requires _Deref_is_glvalue && bidirectional_range<_Base> && bidirectional_range<_InnerRng<_Const>>
                      && common_range<_InnerRng<_Const>> {
                
                if (_Outer == ::std::ranges:: end(_Parent->_Range)) {
                    --_Outer;
                    _Inner = ::std::ranges:: end(*_Outer);
                }
                while (*_Inner == ::std::ranges:: begin(*_Outer)) {
                    --_Outer;
                    *_Inner = ::std::ranges:: end(*_Outer);
                }
                --*_Inner;
                return *this;
            }

            
            constexpr _Iterator operator--(int)
                requires _Deref_is_glvalue && bidirectional_range<_Base> && bidirectional_range<_InnerRng<_Const>>
                      && common_range<_InnerRng<_Const>> {
                
                auto _Tmp = *this;
                --*this;
                return _Tmp;
            }

            
            [[nodiscard]] friend constexpr bool operator==(const _Iterator& _Left, const _Iterator& _Right) noexcept(
                noexcept(_Implicitly_convert_to<bool>(_Left._Outer == _Right._Outer
                    && _Left._Inner == _Right._Inner))) 
                requires _Deref_is_glvalue && equality_comparable<_OuterIter> && equality_comparable<_InnerIter> {
                

#line 3294 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                return _Left._Outer == _Right._Outer && _Left._Inner == _Right._Inner;
            }

            [[nodiscard]] friend constexpr decltype(auto) iter_move(const _Iterator& _It) noexcept(
                noexcept(::std::ranges:: iter_move(*_It._Inner))) {


#line 3302 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                return ::std::ranges:: iter_move(*_It._Inner);
            }

            
            friend constexpr void iter_swap(const _Iterator& _Left, const _Iterator& _Right) noexcept(
                noexcept(::std::ranges:: iter_swap(*_Left._Inner, *_Right._Inner)))
                requires indirectly_swappable<_InnerIter> {
                

#line 3314 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                ::std::ranges:: iter_swap(*_Left._Inner, *_Right._Inner);
            }
        };

        template <bool _Const>
        class _Sentinel {
        private:
            template <bool>
            friend class _Iterator;
            template <bool>
            friend class _Sentinel;

            using _Parent_t = _Maybe_const<_Const, join_view>;
            using _Base     = _Maybe_const<_Const, _Vw>;

            template <bool _OtherConst>
            using _Maybe_const_iter = iterator_t<_Maybe_const<_OtherConst, _Vw>>;

             sentinel_t<_Base> _Last{};

            
            template <bool _OtherConst>
                requires sentinel_for<sentinel_t<_Base>, _Maybe_const_iter<_OtherConst>>
            [[nodiscard]] constexpr bool _Equal(const _Iterator<_OtherConst>& _It) const noexcept(
                    noexcept(_Implicitly_convert_to<bool>(_It._Outer == _Last))) {
                
                return _It._Outer == _Last;
            }

        public:
            _Sentinel() = default;
            constexpr explicit _Sentinel(_Parent_t& _Parent) noexcept(
                noexcept(::std::ranges:: end(_Parent._Range))
                && is_nothrow_move_constructible_v<sentinel_t<_Base>>) 
                : _Last(::std::ranges:: end(_Parent._Range)) {}

            
            constexpr _Sentinel(_Sentinel<!_Const> _Se)
                noexcept(is_nothrow_constructible_v<sentinel_t<_Base>, sentinel_t<_Vw>>) 
                requires _Const && convertible_to<sentinel_t<_Vw>, sentinel_t<_Base>>
                : _Last(::std:: move(_Se._Last)) {}

            template <bool _OtherConst>
                requires sentinel_for<sentinel_t<_Base>, _Maybe_const_iter<_OtherConst>>
            [[nodiscard]] friend constexpr bool operator==(const _Iterator<_OtherConst>& _Left,
                const _Sentinel& _Right) noexcept(noexcept(_Right._Equal(_Left)))  {
                
                return _Right._Equal(_Left);
            }
        };

    public:
        
        join_view() requires default_initializable<_Vw> = default;
        

        constexpr explicit join_view(_Vw _Range_) noexcept(is_nothrow_move_constructible_v<_Vw>) 
            : _Range(::std:: move(_Range_)) {}

        [[nodiscard]] constexpr _Vw base() const& noexcept(
            is_nothrow_copy_constructible_v<_Vw>)  requires copy_constructible<_Vw> {
            return _Range;
        }
        [[nodiscard]] constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>)  {
            return ::std:: move(_Range);
        }

        [[nodiscard]] constexpr auto begin() {
            constexpr bool _Use_const = _Simple_view<_Vw> && is_reference_v<_InnerRng<false>>;
            return _Iterator<_Use_const>{*this, ::std::ranges:: begin(_Range)};
        }

        
        [[nodiscard]] constexpr _Iterator<true> begin() const
        

            requires input_range<const _Vw> && is_reference_v<_InnerRng<true>>
        #line 3393 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
        {
            
            return _Iterator<true>{*this, ::std::ranges:: begin(_Range)};
        }

        [[nodiscard]] constexpr auto end() {
            if constexpr (forward_range<_Vw> && is_reference_v<_InnerRng<false>> 
                          && forward_range<_InnerRng<false>> && common_range<_Vw> && common_range<_InnerRng<false>>) {
                return _Iterator<_Simple_view<_Vw>>{*this, ::std::ranges:: end(_Range)};
            } else {
                return _Sentinel<_Simple_view<_Vw>>{*this};
            }
        }

        
        [[nodiscard]] constexpr auto end() const
        

            requires input_range<const _Vw> && is_reference_v<_InnerRng<true>>
        #line 3414 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
        {
            if constexpr (forward_range<const _Vw> && forward_range<_InnerRng<true>>
                    && common_range<const _Vw> && common_range<_InnerRng<true>>) {
                
                return _Iterator<true>{*this, ::std::ranges:: end(_Range)};
            } else {
                return _Sentinel<true>{*this};
            }
        }
    };

    template <class _Rng>
    explicit join_view(_Rng&&) -> join_view<views::all_t<_Rng>>;

    namespace views {
        class _Join_fn : public _Pipe::_Base<_Join_fn> {
        public:
            
            template <viewable_range _Rng>
            [[nodiscard]] constexpr auto operator()(_Rng&& _Range) const noexcept(noexcept(
                join_view<views::all_t<_Rng>>{::std:: forward<_Rng>(_Range)})) requires requires {
                join_view<views::all_t<_Rng>>{static_cast<_Rng&&>(_Range)};
            } {
                
                return join_view<views::all_t<_Rng>>{::std:: forward<_Rng>(_Range)};
            }
        };

        inline constexpr _Join_fn join;
    } 

    template <auto> 
    struct _Require_constant;

    
    template <class _Ty>
    concept _Tiny_range = sized_range<_Ty>
        && requires { typename _Require_constant<remove_reference_t<_Ty>::size()>; }
        && (remove_reference_t<_Ty>::size() <= 1);

    template <input_range _Vw, forward_range _Pat>
        requires (view<_Vw> && view<_Pat>
            && indirectly_comparable<iterator_t<_Vw>, iterator_t<_Pat>, ::std::ranges:: equal_to>
            && (forward_range<_Vw> || _Tiny_range<_Pat>))
    class lazy_split_view;
    

    template <class _Vw, class _Pat>
    class _Lazy_split_view_base : public view_interface<lazy_split_view<_Vw, _Pat>> {
    protected:
         _Defaultabox<iterator_t<_Vw>> _Current{};
    };

    template <forward_range _Vw, class _Pat>
    class _Lazy_split_view_base<_Vw, _Pat> : public view_interface<lazy_split_view<_Vw, _Pat>> {};

    
    template <input_range _Vw, forward_range _Pat>
        requires (view<_Vw> && view<_Pat>
            && indirectly_comparable<iterator_t<_Vw>, iterator_t<_Pat>, ::std::ranges:: equal_to>
            && (forward_range<_Vw> || _Tiny_range<_Pat>))
    class lazy_split_view : public _Lazy_split_view_base<_Vw, _Pat> {
        
    private:
         _Vw _Range{};
         _Pat _Pattern{};

        template <bool>
        class _Inner_iter;

        template <class>
        class _Outer_iter_base {};

        template <forward_iterator _Iter>
        class _Outer_iter_base<_Iter> {
        protected:
            _Iter _Current{};

        public:
            using iterator_category = input_iterator_tag;

            _Outer_iter_base() = default;
            constexpr explicit _Outer_iter_base(_Iter _Current_) noexcept(is_nothrow_move_constructible_v<_Iter>)
                : _Current{::std:: move(_Current_)} {}
        };

        template <bool _Const>
        class _Outer_iter : public _Outer_iter_base<iterator_t<_Maybe_const<_Const, _Vw>>> {
        private:
            template <bool>
            friend class _Inner_iter;
            friend _Outer_iter<true>;

            using _Mybase   = _Outer_iter_base<iterator_t<_Maybe_const<_Const, _Vw>>>;
            using _ParentTy = _Maybe_const<_Const, lazy_split_view>;
            using _BaseTy   = _Maybe_const<_Const, _Vw>;

            _ParentTy* _Parent   = nullptr;
            bool _Trailing_empty = false;

            [[nodiscard]] constexpr iterator_t<_BaseTy>& _Get_current() noexcept {
                if constexpr (forward_range<_BaseTy>) {
                    return this->_Current;
                } else {
                    return *_Parent->_Current;
                }
            }

            [[nodiscard]] constexpr const iterator_t<_BaseTy>& _Get_current() const noexcept {
                if constexpr (forward_range<_BaseTy>) {
                    return this->_Current;
                } else {
                    return *_Parent->_Current;
                }
            }

            [[nodiscard]] constexpr bool _At_end() const
                noexcept(noexcept(_Implicitly_convert_to<bool>(_Get_current() == ::std::ranges:: end(_Parent->_Range)))) {
                return _Get_current() == ::std::ranges:: end(_Parent->_Range);
            }

        public:
            using iterator_concept = conditional_t<forward_range<_BaseTy>, forward_iterator_tag, input_iterator_tag>;
            using difference_type  = range_difference_t<_BaseTy>;

            class value_type : public view_interface<value_type> {
            private:
                 _Outer_iter _First{};

            public:
                value_type() = default;
                constexpr explicit value_type(_Outer_iter _First_) noexcept(
                    is_nothrow_move_constructible_v<_Outer_iter>) 
                    : _First{::std:: move(_First_)} {}

                [[nodiscard]] constexpr auto begin() const {
                    return _Inner_iter<_Const>{_First};
                }

                [[nodiscard]] constexpr default_sentinel_t end() const noexcept {
                    return default_sentinel;
                }
            };

            _Outer_iter() = default;

            
            constexpr explicit _Outer_iter(_ParentTy& _Parent_) noexcept 
                requires (!forward_range<_BaseTy>) : _Parent{::std:: addressof(_Parent_)} {}
            

            constexpr _Outer_iter(_ParentTy& _Parent_, iterator_t<_BaseTy> _Current_) noexcept(
                is_nothrow_move_constructible_v<iterator_t<_BaseTy>>) 
                requires forward_range<_BaseTy>
                : _Mybase{::std:: move(_Current_)}, _Parent{::std:: addressof(_Parent_)} {}

            
            constexpr _Outer_iter(_Outer_iter<!_Const> _It)
                requires _Const && convertible_to<iterator_t<_Vw>, iterator_t<_BaseTy>>
                : _Mybase{::std:: move(_It._Current)}, _Parent{_It._Parent} {}
            

            [[nodiscard]] constexpr auto operator*() const noexcept(noexcept(value_type{*this}))  {
                return value_type{*this};
            }

            constexpr _Outer_iter& operator++() {
                const auto _End = ::std::ranges:: end(_Parent->_Range);
                auto& _Cur      = _Get_current();
                if (_Cur == _End) {
                    _Trailing_empty = false;
                    return *this;
                }

                const auto _Pat_first = ::std::ranges:: begin(_Parent->_Pattern);
                const auto _Pat_last  = ::std::ranges:: end(_Parent->_Pattern);
                if (_Pat_first == _Pat_last) {
                    ++_Cur;
                } else if constexpr (_Tiny_range<_Pat>) {
                    _Cur = ::std::ranges:: _Find_unchecked(::std:: move(_Cur), _End, *_Pat_first);
                    if (_Cur != _End) {
                        ++_Cur;
                        if (_Cur == _End) {
                            _Trailing_empty = true;
                        }
                    }
                } else {
                    do {
                        auto _Result = ::std::ranges:: mismatch(_Cur, _End, _Pat_first, _Pat_last);
                        if (_Result.in2 == _Pat_last) { 
                            _Cur = ::std:: move(_Result.in1);
                            if (_Cur == _End) {
                                _Trailing_empty = true;
                            }
                            break;
                        }
                    } while (++_Cur != _End);
                }
                return *this;
            }

            constexpr decltype(auto) operator++(int) {
                if constexpr (forward_range<_BaseTy>) {
                    auto _Tmp = *this;
                    ++*this;
                    return _Tmp;
                } else {
                    ++*this;
                }
            }

            [[nodiscard]] friend constexpr bool operator==(const _Outer_iter& _Left, const _Outer_iter& _Right) noexcept(
                noexcept(_Left._Current == _Right._Current))  requires forward_range<_BaseTy> {
                return _Left._Current == _Right._Current && _Left._Trailing_empty == _Right._Trailing_empty;
            }
            [[nodiscard]] friend constexpr bool operator==(const _Outer_iter& _Left, default_sentinel_t) noexcept(
                noexcept(_Left._At_end()))  {
                return _Left._At_end() && !_Left._Trailing_empty;
            }
        };

        template <class _BaseTy>
        class _Inner_iter_base {};

        template <forward_range _BaseTy>
        class _Inner_iter_base<_BaseTy> {
        private:
            using _BaseCategory = typename iterator_traits<iterator_t<_BaseTy>>::iterator_category;

        public:
            using iterator_category =
                conditional_t<derived_from<_BaseCategory, forward_iterator_tag>, forward_iterator_tag, _BaseCategory>;
        };

        template <bool _Const>
        class _Inner_iter : public _Inner_iter_base<_Maybe_const<_Const, _Vw>> {
        private:
            using _BaseTy = _Maybe_const<_Const, _Vw>;

            _Outer_iter<_Const> _It{};
            bool _Incremented = false;

            [[nodiscard]] constexpr bool _Equal(const _Inner_iter& _Right) const {
                return _It._Get_current() == _Right._It._Get_current();
            }

            [[nodiscard]] constexpr iterator_t<_BaseTy>& _Get_current() noexcept {
                return _It._Get_current();
            }

            [[nodiscard]] constexpr const iterator_t<_BaseTy>& _Get_current() const noexcept {
                return _It._Get_current();
            }

            [[nodiscard]] constexpr bool _At_end() const {
                auto _Pat_pos       = ::std::ranges:: begin(_It._Parent->_Pattern);
                const auto _Pat_end = ::std::ranges:: end(_It._Parent->_Pattern);
                auto _Last          = ::std::ranges:: end(_It._Parent->_Range);
                if constexpr (_Tiny_range<_Pat>) {
                    const auto& _Cur = _It._Get_current(); 
                                                           
                    if (_Cur == _Last) {
                        return true;
                    }

                    if (_Pat_pos == _Pat_end) {
                        return _Incremented;
                    }
                    return *_Cur == *_Pat_pos;
                } else {
                    auto _Cur = _It._Get_current(); 
                                                    
                    if (_Cur == _Last) {
                        return true;
                    }

                    if (_Pat_pos == _Pat_end) {
                        return _Incremented;
                    }

                    do {
                        if (*_Cur != *_Pat_pos) {
                            return false;
                        }

                        if (++_Pat_pos == _Pat_end) {
                            return true;
                        }
                    } while (++_Cur != _Last);
                    return false;
                }
            }


        public:
            using iterator_concept = typename _Outer_iter<_Const>::iterator_concept;
            using value_type       = range_value_t<_BaseTy>;
            using difference_type  = range_difference_t<_BaseTy>;

            _Inner_iter() = default;
            constexpr explicit _Inner_iter(_Outer_iter<_Const> _It_) noexcept(
                is_nothrow_move_constructible_v<_Outer_iter<_Const>>) 
                : _It{::std:: move(_It_)} {}

            [[nodiscard]] constexpr const iterator_t<_BaseTy>& base() const& noexcept {
                return _It._Get_current();
            }

            [[nodiscard]] constexpr iterator_t<_BaseTy> base() && noexcept(
                is_nothrow_move_constructible_v<iterator_t<_BaseTy>>) 
                requires forward_range<_Vw> {
                return ::std:: move(_It._Get_current());
            }

            [[nodiscard]] constexpr decltype(auto) operator*() const {
                return *_It._Get_current();
            }

            constexpr _Inner_iter& operator++() {
                _Incremented = true;
                if constexpr (!forward_range<_BaseTy>) {
                    if constexpr (_Pat::size() == 0) {
                        return *this;
                    }
                }
                ++_It._Get_current();
                return *this;
            }

            constexpr decltype(auto) operator++(int) {
                if constexpr (forward_range<_BaseTy>) {
                    auto _Tmp = *this;
                    ++*this;
                    return _Tmp;
                } else {
                    ++*this;
                }
            }

            [[nodiscard]] friend constexpr bool operator==(
                const _Inner_iter& _Left, const _Inner_iter& _Right) requires forward_range<_BaseTy> {
                return _Left._Equal(_Right);
            }

            [[nodiscard]] friend constexpr bool operator==(const _Inner_iter& _Left, default_sentinel_t) {
                return _Left._At_end();
            }

            [[nodiscard]] friend constexpr decltype(auto) iter_move(const _Inner_iter& _Iter) noexcept(
                noexcept(::std::ranges:: iter_move(_Iter._Get_current()))) {
                return ::std::ranges:: iter_move(_Iter._Get_current());
            }

            
            friend constexpr void iter_swap(const _Inner_iter& _Left, const _Inner_iter& _Right)
                noexcept(noexcept(::std::ranges:: iter_swap(_Left._Get_current(), _Right._Get_current())))
                requires indirectly_swappable<iterator_t<_BaseTy>> {
                
                ::std::ranges:: iter_swap(_Left._Get_current(), _Right._Get_current());
            }
        };

    public:
        
        lazy_split_view() requires default_initializable<_Vw> && default_initializable<_Pat> = default;
        

        constexpr lazy_split_view(_Vw _Range_, _Pat _Pattern_) noexcept(
            is_nothrow_move_constructible_v<_Vw>&& is_nothrow_move_constructible_v<_Pat>) 
            : _Range(::std:: move(_Range_)), _Pattern(::std:: move(_Pattern_)) {}

        
        template <input_range _Rng>
            requires constructible_from<_Vw, views::all_t<_Rng>>
                && constructible_from<_Pat, single_view<range_value_t<_Rng>>>
        constexpr lazy_split_view(_Rng&& _Range_, range_value_t<_Rng> _Elem)
            noexcept(noexcept(_Vw(views::all(::std:: forward<_Rng>(_Range_))))
                && noexcept(_Pat(views::single(::std:: move(_Elem))))) 
            : _Range(views::all(::std:: forward<_Rng>(_Range_))), _Pattern(views::single(::std:: move(_Elem))) {}
        

        [[nodiscard]] constexpr _Vw base() const& noexcept(is_nothrow_copy_constructible_v<_Vw>) 
            requires copy_constructible<_Vw> {
            return _Range;
        }
        [[nodiscard]] constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>)  {
            return ::std:: move(_Range);
        }

        [[nodiscard]] constexpr auto begin() {
            if constexpr (forward_range<_Vw>) {
                constexpr bool _Both_simple = _Simple_view<_Vw> && _Simple_view<_Pat>;
                return _Outer_iter<_Both_simple>{*this, ::std::ranges:: begin(_Range)};
            } else {
                this->_Current = ::std::ranges:: begin(_Range);
                return _Outer_iter<false>{*this};
            }
        }

        
        [[nodiscard]] constexpr auto begin() const requires forward_range<_Vw> && forward_range<const _Vw> {
            
            return _Outer_iter<true>{*this, ::std::ranges:: begin(_Range)};
        }

        
        [[nodiscard]] constexpr auto end() requires forward_range<_Vw> && common_range<_Vw> {
            
            constexpr bool _Both_simple = _Simple_view<_Vw> && _Simple_view<_Pat>;
            return _Outer_iter<_Both_simple>{*this, ::std::ranges:: end(_Range)};
        }

        [[nodiscard]] constexpr auto end() const {
            if constexpr (forward_range<_Vw> && forward_range<const _Vw> && common_range<const _Vw>) {
                return _Outer_iter<true>{*this, ::std::ranges:: end(_Range)};
            } else {
                return default_sentinel;
            }
        }
    };

    template <class _Rng, class _Pat>
    lazy_split_view(_Rng&&, _Pat&&) -> lazy_split_view<views::all_t<_Rng>, views::all_t<_Pat>>;

    template <input_range _Rng>
    lazy_split_view(_Rng&&, range_value_t<_Rng>)
        -> lazy_split_view<views::all_t<_Rng>, single_view<range_value_t<_Rng>>>;

    namespace views {
        struct _Lazy_split_fn {
            
            template <viewable_range _Rng, class _Pat>
            [[nodiscard]] constexpr auto operator()(_Rng&& _Range, _Pat&& _Pattern) const noexcept(noexcept(
                lazy_split_view(::std:: forward<_Rng>(_Range), ::std:: forward<_Pat>(_Pattern)))) requires requires {
                lazy_split_view(static_cast<_Rng&&>(_Range), static_cast<_Pat&&>(_Pattern));
            } {
                
                return lazy_split_view(::std:: forward<_Rng>(_Range), ::std:: forward<_Pat>(_Pattern));
            }

            
            template <class _Delim>
                requires constructible_from<decay_t<_Delim>, _Delim>
            [[nodiscard]] constexpr auto operator()(_Delim&& _Delimiter) const
                noexcept(is_nothrow_constructible_v<decay_t<_Delim>, _Delim>) {
                
                return _Range_closure<_Lazy_split_fn, decay_t<_Delim>>{::std:: forward<_Delim>(_Delimiter)};
            }
        };

        inline constexpr _Lazy_split_fn lazy_split;
    } 

    
    template <forward_range _Vw, forward_range _Pat>
        requires view<_Vw> && view<_Pat> && indirectly_comparable<iterator_t<_Vw>, iterator_t<_Pat>, ::std::ranges:: equal_to>
    class split_view : public view_interface<split_view<_Vw, _Pat>> {
        
    private:
         _Vw _Range{};
         _Pat _Pattern{};
        _Non_propagating_cache<subrange<iterator_t<_Vw>>> _Next{};

        class _Sentinel;

        class _Iterator {
        private:
            friend class _Sentinel;

            split_view* _Parent             = nullptr;
            iterator_t<_Vw> _Current        = {};
            subrange<iterator_t<_Vw>> _Next = {};
            bool _Trailing_empty            = false;

        public:
            using iterator_concept  = forward_iterator_tag;
            using iterator_category = input_iterator_tag;
            using value_type        = subrange<iterator_t<_Vw>>;
            using difference_type   = range_difference_t<_Vw>;

            _Iterator() = default;

            constexpr _Iterator(split_view& _Parent_, iterator_t<_Vw> _Current_, subrange<iterator_t<_Vw>> _Next_) 
                noexcept(is_nothrow_move_constructible_v<iterator_t<_Vw>>) 
                : _Parent{::std:: addressof(_Parent_)}, _Current{::std:: move(_Current_)}, _Next{::std:: move(_Next_)} {}

            [[nodiscard]] constexpr iterator_t<_Vw> base() const
                noexcept(is_nothrow_copy_constructible_v<iterator_t<_Vw>>)  {
                return _Current;
            }

            [[nodiscard]] constexpr value_type operator*() const
                noexcept(is_nothrow_copy_constructible_v<iterator_t<_Vw>>)  {
                return {_Current, _Next.begin()};
            }

            constexpr _Iterator& operator++() {
                const auto _Last = ::std::ranges:: end(_Parent->_Range);
                _Current         = _Next.begin();
                if (_Current == _Last) {
                    _Trailing_empty = false;
                    return *this;
                }

                _Current = _Next.end();
                if (_Current == _Last) {
                    _Trailing_empty = true;
                    _Next           = {_Current, _Current};
                    return *this;
                }


#line 3928 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                auto _Match = ::std::ranges:: search(subrange{_Current, _Last}, _Parent->_Pattern);
                auto _Begin = _Match.begin();
                auto _End = _Match.end();
#line 3932 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                if (_Begin != _Last && ::std::ranges:: empty(_Parent->_Pattern)) {
                    ++_Begin;
                    ++_End;
                }

                _Next = {::std:: move(_Begin), ::std:: move(_End)};
                return *this;
            }

            constexpr _Iterator operator++(int) {
                auto _Tmp = *this;
                ++*this;
                return _Tmp;
            }

            [[nodiscard]] friend constexpr bool operator==(const _Iterator& _Left, const _Iterator& _Right) noexcept(
                noexcept(_Left._Current == _Right._Current))  {
                return _Left._Current == _Right._Current && _Left._Trailing_empty == _Right._Trailing_empty;
            }
        };

        class _Sentinel {
        private:
             sentinel_t<_Vw> _Last{};

            [[nodiscard]] constexpr bool _Equal(const _Iterator& _It) const
                noexcept(noexcept(_Implicitly_convert_to<bool>(_It._Current == _Last))) {
                return !_It._Trailing_empty && _It._Current == _Last;
            }

        public:
            _Sentinel() = default;
            constexpr explicit _Sentinel(split_view& _Parent) noexcept(
                noexcept(::std::ranges:: end(_Parent._Range))
                && is_nothrow_move_constructible_v<sentinel_t<_Vw>>) 
                : _Last(::std::ranges:: end(_Parent._Range)) {}

            [[nodiscard]] friend constexpr bool operator==(const _Iterator& _It, const _Sentinel& _Se) noexcept(
                noexcept(_Se._Equal(_It)))  {
                return _Se._Equal(_It);
            }
        };

        constexpr subrange<iterator_t<_Vw>> _Find_next(iterator_t<_Vw> _It) {
            const auto _Last    = ::std::ranges:: end(_Range);


#line 3980 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
            auto _Match = ::std::ranges:: search(subrange{_It, _Last}, _Pattern);
            auto _Begin = _Match.begin();
            auto _End = _Match.end();
#line 3984 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
            if (_Begin != _Last && ::std::ranges:: empty(_Pattern)) {
                ++_Begin;
                ++_End;
            }

            return {::std:: move(_Begin), ::std:: move(_End)};
        }

    public:
        
        split_view() requires default_initializable<_Vw> && default_initializable<_Pat> = default;
        

        constexpr split_view(_Vw _Range_, _Pat _Pattern_) noexcept(
            is_nothrow_move_constructible_v<_Vw>&& is_nothrow_move_constructible_v<_Pat>) 
            : _Range(::std:: move(_Range_)), _Pattern(::std:: move(_Pattern_)) {}

        
        template <forward_range _Rng>
            requires constructible_from<_Vw, views::all_t<_Rng>>
                && constructible_from<_Pat, single_view<range_value_t<_Rng>>>
        constexpr split_view(_Rng&& _Range_, range_value_t<_Rng> _Elem)
            noexcept(is_nothrow_constructible_v<_Vw, views::all_t<_Rng>>
                && is_nothrow_constructible_v<_Pat, single_view<range_value_t<_Rng>>>
                && is_nothrow_move_constructible_v<range_value_t<_Rng>>) 
            : _Range(views::all(::std:: forward<_Rng>(_Range_))), _Pattern(views::single(::std:: move(_Elem))) {}
        

        [[nodiscard]] constexpr _Vw base() const& noexcept(is_nothrow_copy_constructible_v<_Vw>) 
            requires copy_constructible<_Vw> {
            return _Range;
        }
        [[nodiscard]] constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>)  {
            return ::std:: move(_Range);
        }

        [[nodiscard]] constexpr auto begin() {
            auto _First = ::std::ranges:: begin(_Range);
            if (!_Next) {
                _Next._Emplace(_Find_next(_First));
            }
            return _Iterator{*this, _First, *_Next};
        }

        [[nodiscard]] constexpr auto end() {
            if constexpr (common_range<_Vw>) {
                return _Iterator{*this, ::std::ranges:: end(_Range), {}};
            } else {
                return _Sentinel{*this};
            }
        }
    };

    template <class _Rng, class _Pat>
    split_view(_Rng&&, _Pat&&) -> split_view<views::all_t<_Rng>, views::all_t<_Pat>>;

    template <forward_range _Rng>
    split_view(_Rng&&, range_value_t<_Rng>) -> split_view<views::all_t<_Rng>, single_view<range_value_t<_Rng>>>;

    namespace views {
        struct _Split_fn {
            
            template <viewable_range _Rng, class _Pat>
            [[nodiscard]] constexpr auto operator()(_Rng&& _Range, _Pat&& _Pattern) const noexcept(noexcept(
                split_view(::std:: forward<_Rng>(_Range), ::std:: forward<_Pat>(_Pattern)))) requires requires {
                split_view(static_cast<_Rng&&>(_Range), static_cast<_Pat&&>(_Pattern));
            } {
                
                return split_view(::std:: forward<_Rng>(_Range), ::std:: forward<_Pat>(_Pattern));
            }

            
            template <class _Delim>
                requires constructible_from<decay_t<_Delim>, _Delim>
            [[nodiscard]] constexpr auto operator()(_Delim&& _Delimiter) const
                noexcept(is_nothrow_constructible_v<decay_t<_Delim>, _Delim>) {
                
                return _Range_closure<_Split_fn, decay_t<_Delim>>{::std:: forward<_Delim>(_Delimiter)};
            }
        };

        inline constexpr _Split_fn split;

        class _Counted_fn {
        private:
            enum class _St { _None, _Span, _Subrange, _Subrange_counted };

            template <class _It>
            [[nodiscard]] static consteval _Choice_t<_St> _Choose() noexcept {
                using _Decayed = decay_t<_It>;
                ;
                if constexpr (contiguous_iterator<_Decayed>) {
                    return {_St::_Span,
                        noexcept(span(::std:: to_address(::std:: declval<_It>()), iter_difference_t<_Decayed>{}))};
                } else if constexpr (random_access_iterator<_Decayed>) {
                    return {_St::_Subrange,
                        noexcept(subrange(::std:: declval<_It>(), ::std:: declval<_It>() + iter_difference_t<_Decayed>{}))};
                } else if constexpr (constructible_from<_Decayed, _It>) {
                    return {_St::_Subrange_counted,
                        noexcept(subrange(
                            counted_iterator(::std:: declval<_It>(), iter_difference_t<_Decayed>{}), default_sentinel))};
                } else {
                    return {_St::_None};
                }
            }

            template <class _It>
            static constexpr _Choice_t<_St> _Choice = _Choose<_It>();

        public:
            
            template <class _It>
                requires (input_or_output_iterator<decay_t<_It>> && _Choice<_It>._Strategy != _St::_None)
            [[nodiscard]] constexpr auto operator()(_It&& _First, const iter_difference_t<decay_t<_It>> _Count) const
                noexcept(_Choice<_It>._No_throw) {
                
                ;
                constexpr _St _Strat = _Choice<_It>._Strategy;

                if constexpr (_Strat == _St::_Span) {
                    return span(::std:: to_address(::std:: forward<_It>(_First)), static_cast<size_t>(_Count));
                } else if constexpr (_Strat == _St::_Subrange) {
                    return subrange(_First, _First + _Count);
                } else if constexpr (_Strat == _St::_Subrange_counted) {
                    return subrange(counted_iterator(::std:: forward<_It>(_First), _Count), default_sentinel);
                }
            }
        };

        inline constexpr _Counted_fn counted;
    } 

    
    template <view _Vw>
        requires (!common_range<_Vw> && copyable<iterator_t<_Vw>>)
    class common_view : public view_interface<common_view<_Vw>> {
        
    private:
         _Vw _Base{};

    public:
        
        common_view() requires default_initializable<_Vw> = default;
        

        constexpr explicit common_view(_Vw _Base_) noexcept(is_nothrow_move_constructible_v<_Vw>) 
            : _Base(::std:: move(_Base_)) {}

        [[nodiscard]] constexpr _Vw base() const& noexcept(
            is_nothrow_copy_constructible_v<_Vw>)  requires copy_constructible<_Vw> {
            return _Base;
        }
        [[nodiscard]] constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>)  {
            return ::std:: move(_Base);
        }

        [[nodiscard]] constexpr auto begin() noexcept(
            noexcept(::std::ranges:: begin(_Base)) && is_nothrow_move_constructible_v<iterator_t<_Vw>>)  {
            if constexpr (random_access_range<_Vw> && sized_range<_Vw>) {
                return ::std::ranges:: begin(_Base);
            } else {
                return common_iterator<iterator_t<_Vw>, sentinel_t<_Vw>>{::std::ranges:: begin(_Base)};
            }
        }

        [[nodiscard]] constexpr auto begin() const noexcept(
            noexcept(::std::ranges:: begin(_Base))
            && is_nothrow_move_constructible_v<iterator_t<const _Vw>>)  requires range<const _Vw> {
            if constexpr (random_access_range<const _Vw> && sized_range<const _Vw>) {
                return ::std::ranges:: begin(_Base);
            } else {
                return common_iterator<iterator_t<const _Vw>, sentinel_t<const _Vw>>{::std::ranges:: begin(_Base)};
            }
        }

        [[nodiscard]] constexpr auto end() {
            if constexpr (random_access_range<_Vw> && sized_range<_Vw>) {
                return ::std::ranges:: begin(_Base) + ::std::ranges:: size(_Base);
            } else {
                return common_iterator<iterator_t<_Vw>, sentinel_t<_Vw>>{::std::ranges:: end(_Base)};
            }
        }

        [[nodiscard]] constexpr auto end() const requires range<const _Vw> {
            if constexpr (random_access_range<const _Vw> && sized_range<const _Vw>) {
                return ::std::ranges:: begin(_Base) + ::std::ranges:: size(_Base);
            } else {
                return common_iterator<iterator_t<const _Vw>, sentinel_t<const _Vw>>{::std::ranges:: end(_Base)};
            }
        }

        [[nodiscard]] constexpr auto size() noexcept(
            noexcept(::std::ranges:: size(_Base)))  requires sized_range<_Vw> {
            return ::std::ranges:: size(_Base);
        }
        [[nodiscard]] constexpr auto size() const
            noexcept(noexcept(::std::ranges:: size(_Base)))  requires sized_range<const _Vw> {
            return ::std::ranges:: size(_Base);
        }
    };

    template <class _Rng>
    common_view(_Rng&&) -> common_view<views::all_t<_Rng>>;

    template <class _Rng>
    inline constexpr bool enable_borrowed_range<common_view<_Rng>> = enable_borrowed_range<_Rng>;

    namespace views {
        class _Common_fn : public _Pipe::_Base<_Common_fn> {
        private:
            enum class _St { _None, _All, _Common };

            template <class _Rng>
            [[nodiscard]] static consteval _Choice_t<_St> _Choose() noexcept {
                if constexpr (common_range<_Rng>) {
                    return {_St::_All, noexcept(views::all(::std:: declval<_Rng>()))};
                } else if constexpr (copyable<iterator_t<_Rng>>) {
                    return {_St::_Common, noexcept(common_view{::std:: declval<_Rng>()})};
                } else {
                    return {_St::_None};
                }
            }

            template <class _Rng>
            static constexpr _Choice_t<_St> _Choice = _Choose<_Rng>();

        public:
            
            template <viewable_range _Rng>
                requires (_Choice<_Rng>._Strategy != _St::_None)
            [[nodiscard]] constexpr auto operator()(_Rng&& _Range) const noexcept(_Choice<_Rng>._No_throw) {
                
                constexpr _St _Strat = _Choice<_Rng>._Strategy;

                if constexpr (_Strat == _St::_All) {
                    return views::all(::std:: forward<_Rng>(_Range));
                } else if constexpr (_Strat == _St::_Common) {
                    return common_view{::std:: forward<_Rng>(_Range)};
                } else {
                    static_assert(_Always_false<_Rng>, "Should be unreachable");
                }
            }
        };

        inline constexpr _Common_fn common;
    } 

    
    template <view _Vw>
        requires bidirectional_range<_Vw>
    class reverse_view : public _Cached_position_t<!common_range<_Vw>, _Vw, reverse_view<_Vw>> {
        
    private:
         _Vw _Range{};

        template <class _Rng>
        using _Rev_iter = reverse_iterator<iterator_t<_Rng>>;

    public:
        
        reverse_view() requires default_initializable<_Vw> = default;
        

        constexpr explicit reverse_view(_Vw _Range_) noexcept(is_nothrow_move_constructible_v<_Vw>) 
            : _Range(::std:: move(_Range_)) {}

        [[nodiscard]] constexpr _Vw base() const& noexcept(
            is_nothrow_copy_constructible_v<_Vw>)  requires copy_constructible<_Vw> {
            return _Range;
        }
        [[nodiscard]] constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>)  {
            return ::std:: move(_Range);
        }

        [[nodiscard]] constexpr _Rev_iter<_Vw> begin() {
            if constexpr (common_range<_Vw>) {
                return _Rev_iter<_Vw>{::std::ranges:: end(_Range)};
            } else {
                if (this->_Has_cache()) {
                    return _Rev_iter<_Vw>{this->_Get_cache(_Range)};
                }

                iterator_t<_Vw> _First;
                if constexpr (sized_range<_Vw>) {
                    _First = ::std::ranges:: next(::std::ranges:: begin(_Range), ::std::ranges:: distance(_Range));
                } else {
                    _First = ::std::ranges:: next(::std::ranges:: begin(_Range), ::std::ranges:: end(_Range));
                }
                this->_Set_cache(_Range, _First);
                return _Rev_iter<_Vw>{::std:: move(_First)};
            }
        }

        [[nodiscard]] constexpr auto begin() const noexcept(
            noexcept(_Rev_iter<const _Vw>{::std::ranges:: end(_Range)}))  requires common_range<const _Vw> {
            return _Rev_iter<const _Vw>{::std::ranges:: end(_Range)};
        }

        [[nodiscard]] constexpr _Rev_iter<_Vw> end() noexcept(
            noexcept(_Rev_iter<_Vw>{::std::ranges:: begin(_Range)}))  {
            return _Rev_iter<_Vw>{::std::ranges:: begin(_Range)};
        }
        [[nodiscard]] constexpr auto end() const noexcept(
            noexcept(_Rev_iter<const _Vw>{::std::ranges:: begin(_Range)}))  requires common_range<const _Vw> {
            return _Rev_iter<const _Vw>{::std::ranges:: begin(_Range)};
        }

        [[nodiscard]] constexpr auto size() noexcept(
            noexcept(::std::ranges:: size(_Range)))  requires sized_range<_Vw> {
            return ::std::ranges:: size(_Range);
        }
        [[nodiscard]] constexpr auto size() const
            noexcept(noexcept(::std::ranges:: size(_Range)))  requires sized_range<const _Vw> {
            return ::std::ranges:: size(_Range);
        }
    };

    template <class _Rng>
    reverse_view(_Rng&&) -> reverse_view<views::all_t<_Rng>>;

    template <class _Rng>
    inline constexpr bool enable_borrowed_range<reverse_view<_Rng>> = enable_borrowed_range<_Rng>;

    namespace views {
        template <class _Rng>
        concept _Can_extract_base = requires(_Rng&& __r) {
            static_cast<_Rng&&>(__r).base();
        };

        template <class _Rng>
        concept _Can_reverse = requires(_Rng&& __r) {
            reverse_view{static_cast<_Rng&&>(__r)};
        };

        class _Reverse_fn : public _Pipe::_Base<_Reverse_fn> {
        private:
            enum class _St { _None, _Base, _Subrange_unsized, _Subrange_sized, _Reverse };

            template <class>
            static constexpr auto _Reversed_subrange = -1;

            template <class _It, subrange_kind _Ki>
            static constexpr auto
                _Reversed_subrange<subrange<reverse_iterator<_It>, reverse_iterator<_It>, _Ki>> = static_cast<int>(_Ki);

            template <class _Rng>
            [[nodiscard]] static consteval _Choice_t<_St> _Choose() noexcept {
                using _Ty = remove_cvref_t<_Rng>;

                if constexpr (_Is_specialization_v<_Ty, reverse_view>) {
                    if constexpr (_Can_extract_base<_Rng>) {
                        return {_St::_Base, noexcept(::std:: declval<_Rng>().base())};
                    }
                } else if constexpr (_Reversed_subrange<_Ty> == 0) {
                    using _It = decltype(::std:: declval<_Rng&>().begin().base());
                    return {_St::_Subrange_unsized,
                        noexcept(subrange<_It, _It, subrange_kind::unsized>{
                            ::std:: declval<_Rng&>().end().base(), ::std:: declval<_Rng&>().begin().base()})};
                } else if constexpr (_Reversed_subrange<_Ty> == 1) {
                    using _It = decltype(::std:: declval<_Rng&>().begin().base());
                    return {_St::_Subrange_sized,
                        noexcept(subrange<_It, _It, subrange_kind::sized>{::std:: declval<_Rng&>().end().base(),
                            ::std:: declval<_Rng&>().begin().base(), ::std:: declval<_Rng&>().size()})};
                } else if constexpr (_Can_reverse<_Rng>) {
                    return {_St::_Reverse, noexcept(reverse_view{::std:: declval<_Rng>()})};
                }

                return {_St::_None};
            }

            template <class _Rng>
            static constexpr _Choice_t<_St> _Choice = _Choose<_Rng>();

        public:
            
            template <viewable_range _Rng>
                requires (_Choice<_Rng>._Strategy != _St::_None)
            [[nodiscard]] constexpr auto operator()(_Rng&& _Range) const noexcept(_Choice<_Rng>._No_throw) {
                
                constexpr _St _Strat = _Choice<_Rng>._Strategy;

                if constexpr (_Strat == _St::_Base) {
                    return ::std:: forward<_Rng>(_Range).base();
                } else if constexpr (_Strat == _St::_Subrange_unsized) {
                    return subrange{_Range.end().base(), _Range.begin().base()};
                } else if constexpr (_Strat == _St::_Subrange_sized) {
                    return subrange{_Range.end().base(), _Range.begin().base(), _Range.size()};
                } else if constexpr (_Strat == _St::_Reverse) {
                    return reverse_view{::std:: forward<_Rng>(_Range)};
                } else {
                    static_assert(_Always_false<_Rng>, "Should be unreachable");
                }
            }
        };

        inline constexpr _Reverse_fn reverse;
    } 

    template <class _Tuple, size_t _Index>
    concept _Has_tuple_element = requires(_Tuple __t) {
        typename tuple_size<_Tuple>::type;
        requires _Index < tuple_size_v<_Tuple>;
        typename tuple_element_t<_Index, _Tuple>;
        
        { ::std:: get<_Index>(__t) } -> convertible_to<const tuple_element_t<_Index, _Tuple>&>;
        
    };

    template <class _Tuple, size_t _Index>
    concept _Returnable_element = is_reference_v<_Tuple> || move_constructible<tuple_element_t<_Index, _Tuple>>;

    
    template <input_range _Vw, size_t _Index>
        requires view<_Vw> && _Has_tuple_element<range_value_t<_Vw>, _Index>
            && _Has_tuple_element<remove_reference_t<range_reference_t<_Vw>>, _Index>
            && _Returnable_element<range_reference_t<_Vw>, _Index>
    class elements_view : public view_interface<elements_view<_Vw, _Index>> {
        
    private:
         _Vw _Range{};

        template <bool _Const>
        class _Sentinel;

        template <class _Base>
        struct _Category_base {};

        template <forward_range _Base>
        struct _Category_base<_Base> {
            using iterator_category =
                conditional_t<!is_lvalue_reference_v<decltype(::std:: get<_Index>(*::std:: declval<iterator_t<_Base>>()))>,
                    input_iterator_tag,
                    conditional_t<derived_from<_Iter_cat_t<iterator_t<_Base>>, random_access_iterator_tag>,
                        random_access_iterator_tag, _Iter_cat_t<iterator_t<_Base>>>>;
        };

        template <bool _Const>
        class _Iterator : public _Category_base<_Maybe_const<_Const, _Vw>> {
        private:
            template <bool>
            friend class _Iterator;
            template <bool>
            friend class _Sentinel;

            using _Base = _Maybe_const<_Const, _Vw>;

            iterator_t<_Base> _Current{};

        public:
            using iterator_concept = conditional_t<random_access_range<_Base>, random_access_iterator_tag,
                conditional_t<bidirectional_range<_Base>, bidirectional_iterator_tag,
                    conditional_t<forward_range<_Base>, forward_iterator_tag, input_iterator_tag>>>;
            using value_type       = remove_cvref_t<tuple_element_t<_Index, range_value_t<_Base>>>;
            using difference_type  = range_difference_t<_Base>;

            
            _Iterator() requires default_initializable<iterator_t<_Base>> = default;
            

            constexpr explicit _Iterator(iterator_t<_Base> _Current_) noexcept(
                is_nothrow_move_constructible_v<iterator_t<_Base>>) 
                : _Current{::std:: move(_Current_)} {}

            
            constexpr _Iterator(_Iterator<!_Const> _It) noexcept(
                is_nothrow_constructible_v<iterator_t<_Base>, iterator_t<_Vw>>) 
                requires _Const && convertible_to<iterator_t<_Vw>, iterator_t<_Base>>
                : _Current{::std:: move(_It._Current)} {}
            

            [[nodiscard]] constexpr const iterator_t<_Base>& base() const& noexcept {
                return _Current;
            }

            [[nodiscard]] constexpr iterator_t<_Base> base() && noexcept(
                is_nothrow_move_constructible_v<iterator_t<_Base>>)  {
                return ::std:: move(_Current);
            }

            [[nodiscard]] constexpr decltype(auto) operator*() const
                noexcept(noexcept(::std:: get<_Index>(*_Current))) 
                requires is_reference_v<range_reference_t<_Base>> {
                return ::std:: get<_Index>(*_Current);
            }

            [[nodiscard]] constexpr decltype(auto) operator*() const
                noexcept(is_nothrow_move_constructible_v<tuple_element_t<_Index, range_reference_t<_Base>>> 
                        && noexcept(::std:: get<_Index>(*_Current)))  {
                using _ElemTy = remove_cv_t<tuple_element_t<_Index, range_reference_t<_Base>>>;
                return static_cast<_ElemTy>(::std:: get<_Index>(*_Current));
            }

            constexpr _Iterator& operator++() noexcept(noexcept(++_Current))  {
                ++_Current;
                return *this;
            }

            constexpr void operator++(int) noexcept(noexcept(++_Current))  {
                ++_Current;
            }

            constexpr _Iterator operator++(int) noexcept(
                noexcept(++_Current) && is_nothrow_copy_constructible_v<iterator_t<_Base>>) 
                requires forward_range<_Base> {
                auto _Tmp = *this;
                ++_Current;
                return _Tmp;
            }

            constexpr _Iterator& operator--() noexcept(noexcept(--_Current)) 
                requires bidirectional_range<_Base> {
                --_Current;
                return *this;
            }

            constexpr _Iterator operator--(int) noexcept(
                noexcept(--_Current) && is_nothrow_copy_constructible_v<iterator_t<_Base>>) 
                requires bidirectional_range<_Base> {
                auto _Tmp = *this;
                --_Current;
                return _Tmp;
            }

            constexpr void _Verify_offset(const difference_type _Off) const requires random_access_range<_Base> {


#line 4511 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                if constexpr (_Offset_verifiable_v<iterator_t<_Base>>) {
                    _Current._Verify_offset(_Off);
                }
#line 4515 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
            }

            constexpr _Iterator& operator+=(const difference_type _Off) noexcept(
                noexcept(_Current += _Off))  requires random_access_range<_Base> {


#line 4522 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                _Current += _Off;
                return *this;
            }
            constexpr _Iterator& operator-=(const difference_type _Off) noexcept(
                noexcept(_Current -= _Off))  requires random_access_range<_Base> {


#line 4530 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                _Current -= _Off;
                return *this;
            }

            [[nodiscard]] constexpr decltype(auto) operator[](const difference_type _Idx) const
                noexcept(noexcept(::std:: get<_Index>(*(_Current + _Idx)))) 
                requires random_access_range<_Base> && is_reference_v<range_reference_t<_Base>> {


#line 4540 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                return ::std:: get<_Index>(*(_Current + _Idx));
            }

            [[nodiscard]] constexpr decltype(auto) operator[](const difference_type _Idx) const
                noexcept(is_nothrow_move_constructible_v<tuple_element_t<_Index, range_reference_t<_Base>>> 
                        && noexcept(::std:: get<_Index>(*(_Current + _Idx)))) 
                requires random_access_range<_Base> {


#line 4550 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                using _ElemTy = remove_cv_t<tuple_element_t<_Index, range_reference_t<_Base>>>;
                return static_cast<_ElemTy>(::std:: get<_Index>(*(_Current + _Idx)));
            }

            [[nodiscard]] friend constexpr bool operator==(const _Iterator& _Left, const _Iterator& _Right) noexcept(
                noexcept(_Left._Current == _Right._Current)) 
                requires equality_comparable<iterator_t<_Base>> {
                return _Left._Current == _Right._Current;
            }

            [[nodiscard]] friend constexpr bool operator<(const _Iterator& _Left, const _Iterator& _Right) noexcept(
                noexcept(_Left._Current < _Right._Current))  requires random_access_range<_Base> {
                return _Left._Current < _Right._Current;
            }
            [[nodiscard]] friend constexpr bool operator>(const _Iterator& _Left, const _Iterator& _Right) noexcept(
                noexcept(_Left._Current < _Right._Current))  requires random_access_range<_Base> {
                return _Right < _Left;
            }
            [[nodiscard]] friend constexpr bool operator<=(const _Iterator& _Left, const _Iterator& _Right) noexcept(
                noexcept(_Left._Current < _Right._Current))  requires random_access_range<_Base> {
                return !(_Right < _Left);
            }
            [[nodiscard]] friend constexpr bool operator>=(const _Iterator& _Left, const _Iterator& _Right) noexcept(
                noexcept(_Left._Current < _Right._Current))  requires random_access_range<_Base> {
                return !(_Left < _Right);
            }

            
            [[nodiscard]] friend constexpr auto operator<=>(const _Iterator& _Left, const _Iterator& _Right) noexcept(
                noexcept(_Left._Current <=> _Right._Current)) 
                requires random_access_range<_Base> && three_way_comparable<iterator_t<_Base>> {
                
                return _Left._Current <=> _Right._Current;
            }

            [[nodiscard]] friend constexpr _Iterator operator+(const _Iterator& _It, const difference_type _Off) noexcept(
                noexcept(::std:: declval<iterator_t<_Base>&>() += _Off)
                && is_nothrow_copy_constructible_v<iterator_t<_Base>>) 
                requires random_access_range<_Base> {


#line 4592 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                auto _Copy = _It;
                _Copy._Current += _Off;
                return _Copy;
            }

            [[nodiscard]] friend constexpr _Iterator operator+(const difference_type _Off, const _Iterator& _It) noexcept(
                noexcept(::std:: declval<iterator_t<_Base>&>() += _Off)
                && is_nothrow_copy_constructible_v<iterator_t<_Base>>) 
                requires random_access_range<_Base> {


#line 4604 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                auto _Copy = _It;
                _Copy._Current += _Off;
                return _Copy;
            }

            [[nodiscard]] friend constexpr _Iterator operator-(const _Iterator& _It, const difference_type _Off) noexcept(
                noexcept(::std:: declval<iterator_t<_Base>&>() -= _Off)
                && is_nothrow_copy_constructible_v<iterator_t<_Base>>) 
                requires random_access_range<_Base> {


#line 4616 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
                auto _Copy = _It;
                _Copy._Current -= _Off;
                return _Copy;
            }

            [[nodiscard]] friend constexpr difference_type operator-(const _Iterator& _Left,
                const _Iterator& _Right) noexcept(noexcept(_Left._Current - _Right._Current)) 
                requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>> {
                return _Left._Current - _Right._Current;
            }
        };

        template <bool _Const>
        class _Sentinel {
        private:
            template <bool>
            friend class _Sentinel;

            using _Base = _Maybe_const<_Const, _Vw>;
            template <bool _OtherConst>
            using _Maybe_const_iter = iterator_t<_Maybe_const<_OtherConst, _Vw>>;

            sentinel_t<_Base> _Last{};

            template <bool _OtherConst>
            [[nodiscard]] static constexpr const _Maybe_const_iter<_OtherConst>& _Get_current(
                const _Iterator<_OtherConst>& _It) noexcept {
                return _It._Current;
            }

        public:
            _Sentinel() = default;
            constexpr explicit _Sentinel(sentinel_t<_Base> _Last_) noexcept(
                is_nothrow_move_constructible_v<sentinel_t<_Base>>) 
                : _Last(::std:: move(_Last_)) {}

            
            constexpr _Sentinel(_Sentinel<!_Const> _Se)
                noexcept(is_nothrow_constructible_v<sentinel_t<_Base>, sentinel_t<_Vw>>) 
                requires _Const && convertible_to<sentinel_t<_Vw>, sentinel_t<_Base>>
                : _Last(::std:: move(_Se._Last)) {}
            

            [[nodiscard]] constexpr sentinel_t<_Base> base() const
                noexcept(is_nothrow_copy_constructible_v<sentinel_t<_Base>>)  {
                return _Last;
            }

            
            template <bool _OtherConst>
                requires sentinel_for<sentinel_t<_Base>, _Maybe_const_iter<_OtherConst>>
            [[nodiscard]] friend constexpr bool operator==(const _Iterator<_OtherConst>& _Left,
                const _Sentinel& _Right) noexcept(noexcept(_Get_current(_Left) == _Right._Last))  {
                
                return _Get_current(_Left) == _Right._Last;
            }

            
            template <bool _OtherConst>
                requires sized_sentinel_for<sentinel_t<_Base>, _Maybe_const_iter<_OtherConst>>
            [[nodiscard]] friend constexpr range_difference_t<_Maybe_const<_OtherConst, _Vw>> operator-(
                const _Iterator<_OtherConst>& _Left, const _Sentinel& _Right) noexcept(
                noexcept(_Get_current(_Left) - _Right._Last))  {
                
                return _Get_current(_Left) - _Right._Last;
            }

            
            template <bool _OtherConst>
                requires sized_sentinel_for<sentinel_t<_Base>, _Maybe_const_iter<_OtherConst>>
            [[nodiscard]] friend constexpr range_difference_t<_Maybe_const<_OtherConst, _Vw>> operator-(
                const _Sentinel& _Left, const _Iterator<_OtherConst>& _Right) noexcept(
                noexcept(_Left._Last - _Get_current(_Right)))  {
                
                return _Left._Last - _Get_current(_Right);
            }
        };

    public:
        
        elements_view() requires default_initializable<_Vw> = default;
        

        constexpr explicit elements_view(_Vw _Range_) noexcept(is_nothrow_move_constructible_v<_Vw>) 
            : _Range(::std:: move(_Range_)) {}

        [[nodiscard]] constexpr _Vw base() const& noexcept(is_nothrow_copy_constructible_v<_Vw>) 
            requires copy_constructible<_Vw> {
            return _Range;
        }

        [[nodiscard]] constexpr _Vw base() && noexcept(is_nothrow_move_constructible_v<_Vw>)  {
            return ::std:: move(_Range);
        }

        
        [[nodiscard]] constexpr _Iterator<false> begin() noexcept(
            noexcept(::std::ranges:: begin(_Range)) && is_nothrow_move_constructible_v<iterator_t<_Vw>>) 
            requires (!_Simple_view<_Vw>) {
            
            return _Iterator<false>{::std::ranges:: begin(_Range)};
        }

        [[nodiscard]] constexpr _Iterator<true> begin() const
            noexcept(noexcept(::std::ranges:: begin(_Range))
                     && is_nothrow_move_constructible_v<iterator_t<const _Vw>>) 
            requires range<const _Vw> {
            return _Iterator<true>{::std::ranges:: begin(_Range)};
        }

        
        [[nodiscard]] constexpr auto end() noexcept(noexcept(
            ::std::ranges:: end(_Range)) && is_nothrow_move_constructible_v<sentinel_t<_Vw>>) 
            requires (!_Simple_view<_Vw>) {
            
            if constexpr (common_range<_Vw>) {
                return _Iterator<false>{::std::ranges:: end(_Range)};
            } else {
                return _Sentinel<false>{::std::ranges:: end(_Range)};
            }
        }

        
        [[nodiscard]] constexpr auto end() const noexcept(noexcept(
            ::std::ranges:: end(_Range)) && is_nothrow_move_constructible_v<sentinel_t<const _Vw>>) 
            requires range<const _Vw> {
            
            if constexpr (common_range<const _Vw>) {
                return _Iterator<true>{::std::ranges:: end(_Range)};
            } else {
                return _Sentinel<true>{::std::ranges:: end(_Range)};
            }
        }

        [[nodiscard]] constexpr auto size() noexcept(noexcept(::std::ranges:: size(_Range))) 
            requires sized_range<_Vw> {
            return ::std::ranges:: size(_Range);
        }
        [[nodiscard]] constexpr auto size() const noexcept(noexcept(::std::ranges:: size(_Range))) 
            requires sized_range<const _Vw> {
            return ::std::ranges:: size(_Range);
        }
    };

    template <class _Rng, size_t _Index>
    inline constexpr bool enable_borrowed_range<elements_view<_Rng, _Index>> = enable_borrowed_range<_Rng>;

    template <class _Rng>
    using keys_view = elements_view<_Rng, 0>;
    template <class _Rng>
    using values_view = elements_view<_Rng, 1>;

    namespace views {
        template <size_t _Index>
        class _Elements_fn : public _Pipe::_Base<_Elements_fn<_Index>> {
        public:
            template <viewable_range _Rng>
            [[nodiscard]] constexpr auto operator()(_Rng&& _Range) const noexcept(
                noexcept(elements_view<views::all_t<_Rng>, _Index>{::std:: forward<_Rng>(_Range)})) requires requires {
                elements_view<views::all_t<_Rng>, _Index>{static_cast<_Rng&&>(_Range)};
            }
            { return elements_view<views::all_t<_Rng>, _Index>{::std:: forward<_Rng>(_Range)}; }
        };

        template <size_t _Index>
        inline constexpr _Elements_fn<_Index> elements;
        inline constexpr auto keys   = elements<0>;
        inline constexpr auto values = elements<1>;
    } 
} 

namespace views = ranges::views;

}


#pragma warning(pop)
#pragma pack(pop)
#line 4796 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
#line 4797 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
#line 4798 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ranges"
#line 70 "all-std.cxx"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\execution"


#pragma once


#line 15 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\execution"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\numeric"


#pragma once


#line 16 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\numeric"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
template <class _InIt, class _Ty, class _Fn>
[[nodiscard]] constexpr _Ty accumulate(const _InIt _First, const _InIt _Last, _Ty _Val, _Fn _Reduce_op) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    for (; _UFirst != _ULast; ++_UFirst) {

        _Val = _Reduce_op(::std:: move(_Val), *_UFirst);


#line 36 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\numeric"
    }
    return _Val;
}

template <class _InIt, class _Ty>
[[nodiscard]] constexpr _Ty accumulate(const _InIt _First, const _InIt _Last, _Ty _Val) {
    
    return ::std:: accumulate(_First, _Last, _Val, plus<>{});
}


template <class _InIt, class _Ty, class _BinOp>
inline constexpr bool _Plus_on_arithmetic_ranges_reduction_v =
    conjunction_v<is_arithmetic<_Ty>, is_arithmetic<remove_pointer_t<_InIt>>, is_same<plus<>, _BinOp>>;

#pragma float_control(precise, off, push)
template <class _InIt, class _Ty>
_Ty _Reduce_plus_arithmetic_ranges(_InIt _First, const _InIt _Last, _Ty _Val) {
    
#pragma loop(ivdep)
    for (; _First != _Last; ++_First) {
        _Val += *_First;
    }

    return _Val;
}
#pragma float_control(pop)


#line 69 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\numeric"

template <class _InIt, class _Ty, class _BinOp>
[[nodiscard]] constexpr _Ty reduce(const _InIt _First, const _InIt _Last, _Ty _Val, _BinOp _Reduce_op) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    if constexpr (_Plus_on_arithmetic_ranges_reduction_v<_Unwrapped_t<const _InIt&>, _Ty, _BinOp>) {

        if (!::std:: is_constant_evaluated())
#line 80 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\numeric"
        {
            return _Reduce_plus_arithmetic_ranges(_UFirst, _ULast, _Val);
        }
    }

    for (; _UFirst != _ULast; ++_UFirst) {
        _Val = _Reduce_op(::std:: move(_Val), *_UFirst); 
    }

    return _Val;
}

template <class _InIt, class _Ty>
[[nodiscard]] constexpr _Ty reduce(const _InIt _First, const _InIt _Last, _Ty _Val) {
    
    return ::std:: reduce(_First, _Last, ::std:: move(_Val), plus{});
}

template <class _InIt>
[[nodiscard]] constexpr _Iter_value_t<_InIt> reduce(const _InIt _First, const _InIt _Last) {
    
    
    return ::std:: reduce(_First, _Last, _Iter_value_t<_InIt>{}, plus{});
}

template <class _ExPo, class _FwdIt, class _Ty, class _BinOp, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _Ty reduce(_ExPo&& _Exec, _FwdIt _First, _FwdIt _Last, _Ty _Val, _BinOp _Reduce_op) noexcept; 

template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _Ty reduce(_ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last, _Ty _Val) noexcept  {
    
    static_assert(_Is_fwd_iter_v<_FwdIt>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: reduce(::std:: forward<_ExPo>(_Exec), _First, _Last, ::std:: move(_Val), plus{});
}

template <class _ExPo, class _FwdIt, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _Iter_value_t<_FwdIt> reduce(_ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last) noexcept
 {
    
    
    static_assert(_Is_fwd_iter_v<_FwdIt>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: reduce(::std:: forward<_ExPo>(_Exec), _First, _Last, _Iter_value_t<_FwdIt>{}, plus{});
}
#line 124 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\numeric"

template <class _InIt1, class _InIt2, class _Ty, class _BinOp1, class _BinOp2>
[[nodiscard]] constexpr _Ty inner_product(
    _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val, _BinOp1 _Reduce_op, _BinOp2 _Transform_op) {
    
    
    _Adl_verify_range(_First1, _Last1);
    auto _UFirst1      = _Get_unwrapped(_First1);
    const auto _ULast1 = _Get_unwrapped(_Last1);
    auto _UFirst2      = _Get_unwrapped_n(_First2, _Idl_distance<_InIt1>(_UFirst1, _ULast1));
    for (; _UFirst1 != _ULast1; ++_UFirst1, (void) ++_UFirst2) {

        _Val = _Reduce_op(::std:: move(_Val), _Transform_op(*_UFirst1, *_UFirst2)); 


#line 140 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\numeric"
    }

    return _Val;
}

template <class _InIt1, class _InIt2, class _Ty>
[[nodiscard]] constexpr _Ty inner_product(const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, _Ty _Val) {
    
    return ::std:: inner_product(_First1, _Last1, _First2, ::std:: move(_Val), plus<>{}, multiplies<>{});
}


template <class _InIt1, class _InIt2, class _Ty, class _BinOp1, class _BinOp2>
inline constexpr bool _Default_ops_transform_reduce_v =
    conjunction_v<is_arithmetic<_Ty>, is_arithmetic<remove_pointer_t<_InIt1>>, is_arithmetic<remove_pointer_t<_InIt2>>,
        is_same<plus<>, _BinOp1>, is_same<multiplies<>, _BinOp2>>;

#pragma float_control(precise, off, push)
template <class _InIt1, class _InIt2, class _Ty>
_Ty _Transform_reduce_arithmetic_defaults(_InIt1 _First1, const _InIt1 _Last1, _InIt2 _First2, _Ty _Val) {
    
#pragma loop(ivdep)
    for (; _First1 != _Last1; ++_First1, (void) ++_First2) {
        _Val += *_First1 * *_First2;
    }

    return _Val;
}
#pragma float_control(pop)


#line 174 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\numeric"

template <class _InIt1, class _InIt2, class _Ty, class _BinOp1, class _BinOp2>
[[nodiscard]] constexpr _Ty transform_reduce(
    _InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val, _BinOp1 _Reduce_op, _BinOp2 _Transform_op) {
    
    
    _Adl_verify_range(_First1, _Last1);
    auto _UFirst1      = _Get_unwrapped(_First1);
    const auto _ULast1 = _Get_unwrapped(_Last1);
    auto _UFirst2      = _Get_unwrapped_n(_First2, _Idl_distance<_InIt1>(_UFirst1, _ULast1));
    if constexpr (_Default_ops_transform_reduce_v<_Unwrapped_t<const _InIt1&>, _Unwrapped_t<const _InIt2&>, _Ty,
                      _BinOp1, _BinOp2>) {

        
        if (!::std:: is_constant_evaluated())
#line 190 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\numeric"
        {
            return _Transform_reduce_arithmetic_defaults(_UFirst1, _ULast1, _UFirst2, ::std:: move(_Val));
        }
    }

    for (; _UFirst1 != _ULast1; ++_UFirst1, (void) ++_UFirst2) {
        _Val = _Reduce_op(::std:: move(_Val), _Transform_op(*_UFirst1, *_UFirst2)); 
    }
    return _Val;
}

template <class _InIt1, class _InIt2, class _Ty>
[[nodiscard]] constexpr _Ty transform_reduce(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Ty _Val) {
    
    return ::std:: transform_reduce(_First1, _Last1, _First2, ::std:: move(_Val), plus{}, multiplies{});
}

template <class _InIt, class _Ty, class _BinOp, class _UnaryOp>
[[nodiscard]] constexpr _Ty transform_reduce(
    const _InIt _First, const _InIt _Last, _Ty _Val, _BinOp _Reduce_op, _UnaryOp _Transform_op) {
    
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    for (; _UFirst != _ULast; ++_UFirst) {
        _Val = _Reduce_op(::std:: move(_Val), _Transform_op(*_UFirst)); 
    }

    return _Val;
}

template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp1, class _BinOp2,
    _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _Ty transform_reduce(_ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Ty _Val,
    _BinOp1 _Reduce_op, _BinOp2 _Transform_op) noexcept; 

template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _Ty transform_reduce(_ExPo&& _Exec, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Ty _Val) noexcept
 {
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    return ::std:: transform_reduce(
        ::std:: forward<_ExPo>(_Exec), _First1, _Last1, _First2, ::std:: move(_Val), plus{}, multiplies{});
}

template <class _ExPo, class _FwdIt, class _Ty, class _BinOp, class _UnaryOp, _Enable_if_execution_policy_t<_ExPo> = 0>
[[nodiscard]] _Ty transform_reduce(_ExPo&& _Exec, const _FwdIt _First1, const _FwdIt _Last1, _Ty _Val, _BinOp _Reduce_op,
    _UnaryOp _Transform_op) noexcept; 
#line 241 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\numeric"

template <class _InIt, class _OutIt, class _BinOp>
constexpr _OutIt partial_sum(const _InIt _First, const _InIt _Last, _OutIt _Dest, _BinOp _Reduce_op) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    auto _UDest       = _Get_unwrapped_n(_Dest, _Idl_distance<_InIt>(_UFirst, _ULast));

    if (_UFirst != _ULast) {
        _Iter_value_t<_InIt> _Val(*_UFirst);
        for (;;) {
            *_UDest = _Val;
            ++_UDest;
            ++_UFirst;
            if (_UFirst == _ULast) {
                break;
            }

            _Val = _Reduce_op(::std:: move(_Val), *_UFirst);


#line 264 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\numeric"
        }
    }

    _Seek_wrapped(_Dest, _UDest);
    return _Dest;
}

template <class _InIt, class _OutIt>
constexpr _OutIt partial_sum(_InIt _First, _InIt _Last, _OutIt _Dest) {
    
    return ::std:: partial_sum(_First, _Last, _Dest, plus<>{});
}


template <class _InIt, class _OutIt, class _Ty, class _BinOp>
constexpr _OutIt exclusive_scan(const _InIt _First, const _InIt _Last, _OutIt _Dest, _Ty _Val, _BinOp _Reduce_op) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    auto _UDest       = _Get_unwrapped_n(_Dest, _Idl_distance<_InIt>(_UFirst, _ULast));
    if (_UFirst != _ULast) {
        for (;;) {
            _Ty _Tmp(_Reduce_op(_Val, *_UFirst)); 
            *_UDest = _Val;
            ++_UDest;
            ++_UFirst;
            if (_UFirst == _ULast) {
                break;
            }

            _Val = ::std:: move(_Tmp); 
        }
    }

    _Seek_wrapped(_Dest, _UDest);
    return _Dest;
}

template <class _InIt, class _OutIt, class _Ty>
constexpr _OutIt exclusive_scan(const _InIt _First, const _InIt _Last, const _OutIt _Dest, _Ty _Val) {
    
    return ::std:: exclusive_scan(_First, _Last, _Dest, ::std:: move(_Val), plus{});
}

template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt2 exclusive_scan(_ExPo&& _Exec, const _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _Ty _Val,
    _BinOp _Reduce_op) noexcept; 

template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt2 exclusive_scan(_ExPo&& _Exec, const _FwdIt1 _First, const _FwdIt1 _Last, const _FwdIt2 _Dest, _Ty _Val) noexcept
 {
    
    return ::std:: exclusive_scan(::std:: forward<_ExPo>(_Exec), _First, _Last, _Dest, ::std:: move(_Val), plus{});
}

template <class _InIt, class _OutIt, class _Ty, class _BinOp>
constexpr _OutIt inclusive_scan(const _InIt _First, const _InIt _Last, _OutIt _Dest, _BinOp _Reduce_op, _Ty _Val) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    auto _UDest       = _Get_unwrapped_n(_Dest, _Idl_distance<_InIt>(_UFirst, _ULast));
    for (; _UFirst != _ULast; ++_UFirst) {
        _Val    = _Reduce_op(::std:: move(_Val), *_UFirst); 
        *_UDest = _Val;
        ++_UDest;
    }

    _Seek_wrapped(_Dest, _UDest);
    return _Dest;
}

template <class _InIt, class _OutIt, class _BinOp>
constexpr _OutIt inclusive_scan(const _InIt _First, const _InIt _Last, _OutIt _Dest, _BinOp _Reduce_op) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    auto _UDest       = _Get_unwrapped_n(_Dest, _Idl_distance<_InIt>(_UFirst, _ULast));
    if (_UFirst != _ULast) {
        _Iter_value_t<_InIt> _Val = *_UFirst; 
        for (;;) {
            *_UDest = _Val;
            ++_UDest;
            ++_UFirst;
            if (_UFirst == _ULast) {
                break;
            }

            _Val = _Reduce_op(::std:: move(_Val), *_UFirst); 
        }
    }

    _Seek_wrapped(_Dest, _UDest);
    return _Dest;
}

template <class _InIt, class _OutIt>
constexpr _OutIt inclusive_scan(const _InIt _First, const _InIt _Last, const _OutIt _Dest) {
    
    return ::std:: inclusive_scan(_First, _Last, _Dest, plus{});
}

template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp, class _Ty, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt2 inclusive_scan(
    _ExPo&& _Exec, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op, _Ty _Val) noexcept; 

template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt2 inclusive_scan(
    _ExPo&& _Exec, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op) noexcept; 

template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt2 inclusive_scan(_ExPo&& _Exec, const _FwdIt1 _First, const _FwdIt1 _Last, const _FwdIt2 _Dest) noexcept
 {
    
    return ::std:: inclusive_scan(::std:: forward<_ExPo>(_Exec), _First, _Last, _Dest, plus{});
}

template <class _InIt, class _OutIt, class _Ty, class _BinOp, class _UnaryOp>
constexpr _OutIt transform_exclusive_scan(
    const _InIt _First, const _InIt _Last, _OutIt _Dest, _Ty _Val, _BinOp _Reduce_op, _UnaryOp _Transform_op) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    auto _UDest       = _Get_unwrapped_n(_Dest, _Idl_distance<_InIt>(_UFirst, _ULast));
    if (_UFirst != _ULast) {
        for (;;) {
            _Ty _Tmp(_Reduce_op(_Val, _Transform_op(*_UFirst))); 
            *_UDest = _Val;
            ++_UDest;
            ++_UFirst;
            if (_UFirst == _ULast) {
                break;
            }

            _Val = ::std:: move(_Tmp); 
        }
    }

    _Seek_wrapped(_Dest, _UDest);
    return _Dest;
}

template <class _ExPo, class _FwdIt1, class _OutIt, class _Ty, class _BinOp, class _UnaryOp,
    _Enable_if_execution_policy_t<_ExPo> = 0>
_OutIt transform_exclusive_scan(_ExPo&& _Exec, const _FwdIt1 _First, const _FwdIt1 _Last, _OutIt _Dest, _Ty _Val,
    _BinOp _Reduce_op, _UnaryOp _Transform_op) noexcept; 

template <class _InIt, class _OutIt, class _Ty, class _BinOp, class _UnaryOp>
constexpr _OutIt transform_inclusive_scan(
    const _InIt _First, const _InIt _Last, _OutIt _Dest, _BinOp _Reduce_op, _UnaryOp _Transform_op, _Ty _Val) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    auto _UDest       = _Get_unwrapped_n(_Dest, _Idl_distance<_InIt>(_UFirst, _ULast));
    for (; _UFirst != _ULast; ++_UFirst) {
        _Val    = _Reduce_op(::std:: move(_Val), _Transform_op(*_UFirst)); 
        *_UDest = _Val;
        ++_UDest;
    }

    _Seek_wrapped(_Dest, _UDest);
    return _Dest;
}

template <class _InIt, class _OutIt, class _BinOp, class _UnaryOp>
constexpr _OutIt transform_inclusive_scan(
    const _InIt _First, const _InIt _Last, _OutIt _Dest, _BinOp _Reduce_op, _UnaryOp _Transform_op) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    auto _UDest       = _Get_unwrapped_n(_Dest, _Idl_distance<_InIt>(_UFirst, _ULast));
    if (_UFirst != _ULast) {
        auto _Val = _Transform_op(*_UFirst); 
        for (;;) {
            *_UDest = _Val;
            ++_UDest;
            ++_UFirst;
            if (_UFirst == _ULast) {
                break;
            }

            _Val = _Reduce_op(::std:: move(_Val), _Transform_op(*_UFirst)); 
        }
    }

    _Seek_wrapped(_Dest, _UDest);
    return _Dest;
}

template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp, class _UnaryOp,
    _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt2 transform_inclusive_scan(_ExPo&& _Exec, const _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest,
    _BinOp _Reduce_op, _UnaryOp _Transform_op, _Ty _Val) noexcept; 

template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp, class _UnaryOp,
    _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt2 transform_inclusive_scan(_ExPo&& _Exec, const _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest,
    _BinOp _Reduce_op, _UnaryOp _Transform_op) noexcept; 
#line 468 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\numeric"

template <class _InIt, class _OutIt, class _BinOp>
constexpr _OutIt adjacent_difference(const _InIt _First, const _InIt _Last, _OutIt _Dest, _BinOp _Func) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    auto _UDest       = _Get_unwrapped_n(_Dest, _Idl_distance<_InIt>(_UFirst, _ULast));
    if (_UFirst != _ULast) {
        _Iter_value_t<_InIt> _Val = *_UFirst;
        *_UDest                   = _Val;
        while (++_UFirst != _ULast) { 
            _Iter_value_t<_InIt> _Tmp = *_UFirst;

            *++_UDest = _Func(_Tmp, ::std:: move(_Val));


#line 486 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\numeric"
            _Val = ::std:: move(_Tmp);
        }

        ++_UDest;
    }

    _Seek_wrapped(_Dest, _UDest);
    return _Dest;
}

template <class _InIt, class _OutIt>
constexpr _OutIt adjacent_difference(const _InIt _First, const _InIt _Last, const _OutIt _Dest) {
    
    return ::std:: adjacent_difference(_First, _Last, _Dest, minus<>{});
}


template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt2 adjacent_difference(
    _ExPo&& _Exec, const _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Diff_op) noexcept; 

template <class _ExPo, class _FwdIt1, class _FwdIt2, _Enable_if_execution_policy_t<_ExPo> = 0>
_FwdIt2 adjacent_difference(_ExPo&& _Exec, const _FwdIt1 _First, const _FwdIt1 _Last, const _FwdIt2 _Dest) noexcept
 {
    
    return ::std:: adjacent_difference(::std:: forward<_ExPo>(_Exec), _First, _Last, _Dest, minus{});
}
#line 514 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\numeric"

template <class _FwdIt, class _Ty>
constexpr void iota(_FwdIt _First, _FwdIt _Last, _Ty _Val) {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    for (; _UFirst != _ULast; ++_UFirst, (void) ++_Val) {
        *_UFirst = _Val;
    }
}


template <class _Integral>
[[nodiscard]] constexpr auto _Abs_u(const _Integral _Val) noexcept {
    
    
    static_assert(is_integral_v<_Integral>);

    if constexpr (is_signed_v<_Integral>) {
        using _Unsigned = make_unsigned_t<_Integral>;
        if (_Val < 0) {
            
            return static_cast<_Unsigned>(_Unsigned{0} - static_cast<_Unsigned>(_Val));
        }

        return static_cast<_Unsigned>(_Val);
    } else {
        return _Val;
    }
}

template <class _Mt, class _Nt>
[[nodiscard]] constexpr common_type_t<_Mt, _Nt> gcd(const _Mt _Mx, const _Nt _Nx) noexcept  {
    
    static_assert(_Is_nonbool_integral<_Mt> && _Is_nonbool_integral<_Nt>, "GCD requires nonbool integral types");

    using _Common          = common_type_t<_Mt, _Nt>;
    using _Common_unsigned = make_unsigned_t<_Common>;

    return _Select_countr_zero_impl<_Common_unsigned>([=](auto _Countr_zero_impl) {
        _Common_unsigned _Mx_magnitude = _Abs_u(_Mx);
        _Common_unsigned _Nx_magnitude = _Abs_u(_Nx);
        if (_Mx_magnitude == 0U) {
            return static_cast<_Common>(_Nx_magnitude);
        }

        if (_Nx_magnitude == 0U) {
            return static_cast<_Common>(_Mx_magnitude);
        }

        const auto _Mx_trailing_zeroes = static_cast<unsigned long>(_Countr_zero_impl(_Mx_magnitude));
        const auto _Common_factors_of_2 =
            (::std:: min)(_Mx_trailing_zeroes, static_cast<unsigned long>(_Countr_zero_impl(_Nx_magnitude)));
        _Nx_magnitude >>= _Common_factors_of_2;
        _Mx_magnitude >>= _Mx_trailing_zeroes;
        do {
            _Nx_magnitude >>= static_cast<unsigned long>(_Countr_zero_impl(_Nx_magnitude));
            if (_Mx_magnitude > _Nx_magnitude) {
                _Common_unsigned _Temp = _Mx_magnitude;
                _Mx_magnitude          = _Nx_magnitude;
                _Nx_magnitude          = _Temp;
            }

            _Nx_magnitude -= _Mx_magnitude;
        } while (_Nx_magnitude != 0U);
        return static_cast<_Common>(_Mx_magnitude << _Common_factors_of_2);
    });
}

template <class _Mt, class _Nt>
[[nodiscard]] constexpr common_type_t<_Mt, _Nt> lcm(const _Mt _Mx, const _Nt _Nx) noexcept  {
    
    static_assert(_Is_nonbool_integral<_Mt> && _Is_nonbool_integral<_Nt>, "LCM requires nonbool integral types");
    using _Common                        = common_type_t<_Mt, _Nt>;
    using _Common_unsigned               = make_unsigned_t<_Common>;
    const _Common_unsigned _Mx_magnitude = _Abs_u(_Mx);
    const _Common_unsigned _Nx_magnitude = _Abs_u(_Nx);
    if (_Mx_magnitude == 0 || _Nx_magnitude == 0) {
        return 0;
    }

    return static_cast<_Common>((_Mx_magnitude / ::std:: gcd(_Mx_magnitude, _Nx_magnitude)) * _Nx_magnitude);
}
#line 599 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\numeric"


template <class _Ty, enable_if_t<is_arithmetic_v<_Ty> && !is_same_v<remove_cv_t<_Ty>, bool>, int> = 0>
[[nodiscard]] constexpr _Ty midpoint(const _Ty _Val1, const _Ty _Val2) noexcept {
    if constexpr (is_floating_point_v<_Ty>) {
        if (::std:: is_constant_evaluated()) {
            if (_Is_nan(_Val1)) {
                return _Val1;
            }

            if (_Is_nan(_Val2)) {
                return _Val2;
            }
        } else {
            if (_Is_nan(_Val1) || _Is_nan(_Val2)) {
                
                return _Val1 + _Val2;
            }
        }

        constexpr _Ty _High_limit = (numeric_limits<_Ty>::max)() / 2;
        const auto _Val1_a        = _Float_abs(_Val1);
        const auto _Val2_a        = _Float_abs(_Val2);
        if (_Val1_a <= _High_limit && _Val2_a <= _High_limit) {
            

            return (_Val1 + _Val2) / 2;
        }

        
        constexpr _Ty _Low_limit = (numeric_limits<_Ty>::min)() * 2;
        if (_Val1_a < _Low_limit) {
            return _Val1 + _Val2 / 2;
        }

        if (_Val2_a < _Low_limit) {
            
            return _Val1 / 2 + _Val2;
        }

        return _Val1 / 2 + _Val2 / 2;
    } else {
        using _Unsigned    = make_unsigned_t<_Ty>;
        const auto _Val1_u = static_cast<_Unsigned>(_Val1);
        const auto _Val2_u = static_cast<_Unsigned>(_Val2);
        if (_Val1 > _Val2) {
            return static_cast<_Ty>(_Val1 - static_cast<_Ty>(static_cast<_Unsigned>(_Val1_u - _Val2_u) / 2));
        } else {
            return static_cast<_Ty>(_Val1 + static_cast<_Ty>(static_cast<_Unsigned>(_Val2_u - _Val1_u) / 2));
        }
    }
}

template <class _Ty, enable_if_t<is_object_v<_Ty>, int> = 0>
[[nodiscard]] constexpr _Ty* midpoint(_Ty* const _Val1, _Ty* const _Val2) noexcept  {
    if (_Val1 > _Val2) {
        return _Val1 - ((_Val1 - _Val2) >> 1); 
    } else {
        return _Val1 + ((_Val2 - _Val1) >> 1); 
    }
}
#line 675 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\numeric"
}


#pragma warning(pop)
#pragma pack(pop)
#line 681 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\numeric"
#line 682 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\numeric"
#line 20 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\execution"


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


extern "C" {


struct __std_TP_WORK; 
struct __std_TP_CALLBACK_INSTANCE; 
struct __std_TP_CALLBACK_ENVIRON; 
#line 41 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\execution"

using __std_PTP_WORK              = __std_TP_WORK*;
using __std_PTP_CALLBACK_INSTANCE = __std_TP_CALLBACK_INSTANCE*;
using __std_PTP_CALLBACK_ENVIRON  = __std_TP_CALLBACK_ENVIRON*;

[[nodiscard]] unsigned int __stdcall __std_parallel_algorithms_hw_threads() noexcept;

using __std_PTP_WORK_CALLBACK = void(__stdcall*)(
      __std_PTP_CALLBACK_INSTANCE,   void*,   __std_PTP_WORK);

[[nodiscard]] __std_PTP_WORK __stdcall __std_create_threadpool_work(
      __std_PTP_WORK_CALLBACK,   void*,   __std_PTP_CALLBACK_ENVIRON) noexcept;

void __stdcall __std_submit_threadpool_work(  __std_PTP_WORK) noexcept;

void __stdcall __std_bulk_submit_threadpool_work(  __std_PTP_WORK,   size_t) noexcept;

void __stdcall __std_close_threadpool_work(  __std_PTP_WORK) noexcept;

void __stdcall __std_wait_for_threadpool_work_callbacks(  __std_PTP_WORK,   int) noexcept;

void __stdcall __std_execution_wait_on_uchar(
      const volatile unsigned char* _Address,   unsigned char _Compare) noexcept;

void __stdcall __std_execution_wake_by_address_all(  const volatile void* _Address) noexcept;
}

namespace std {
constexpr size_t _Oversubscription_multiplier = 32;
constexpr size_t _Oversubmission_multiplier   = 4;
constexpr size_t _Still_active                = static_cast<size_t>(-1);

namespace execution {
    class sequenced_policy {
        
    public:
        using _Standard_execution_policy   = int;
        static constexpr bool _Parallelize = false;
        static constexpr bool _Ivdep       = false;
    };

    inline constexpr sequenced_policy seq{};

    class parallel_policy {
        
        
    public:
        using _Standard_execution_policy   = int;
        static constexpr bool _Parallelize = true;
        static constexpr bool _Ivdep       = true;
    };

    inline constexpr parallel_policy par{};

    class parallel_unsequenced_policy {
        
        
    public:
        using _Standard_execution_policy   = int;
        static constexpr bool _Parallelize = true;
        static constexpr bool _Ivdep       = true;
    };

    inline constexpr parallel_unsequenced_policy par_unseq{};


    class unsequenced_policy {
        
        
    public:
        using _Standard_execution_policy   = int;
        static constexpr bool _Parallelize = false;
        static constexpr bool _Ivdep       = true;
    };

    inline constexpr unsequenced_policy unseq{};
#line 122 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\execution"

} 


template <>
struct is_execution_policy<execution::sequenced_policy> : true_type {};

template <>
struct is_execution_policy<execution::parallel_policy> : true_type {};

template <>
struct is_execution_policy<execution::parallel_unsequenced_policy> : true_type {};


template <>
struct is_execution_policy<execution::unsequenced_policy> : true_type {};
#line 139 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\execution"

struct _Parallelism_resources_exhausted : exception {
    [[nodiscard]] const char*  what() const noexcept override {
        
        return "Insufficient resources were available to use additional parallelism.";
    }


#line 152 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\execution"
};

[[noreturn]] inline void _Throw_parallelism_resources_exhausted() {
    throw _Parallelism_resources_exhausted{};
}

enum class _Cancellation_status : bool { _Running, _Canceled };

struct _Cancellation_token {
    atomic<_Cancellation_status> _Is_canceled_impl{_Cancellation_status::_Running};

    bool _Is_canceled() const {
        return _Is_canceled_impl.load() == _Cancellation_status::_Canceled;
    }

    bool _Is_canceled_relaxed() const {
        return _Is_canceled_impl.load(memory_order_relaxed) == _Cancellation_status::_Canceled;
    }

    void _Cancel() {
        _Is_canceled_impl.store(_Cancellation_status::_Canceled);
    }

    _Cancellation_status _Status() const {
        return _Is_canceled_impl.load();
    }
};

class _Work_ptr {
public:
    template <class _Work, enable_if_t<!is_same_v<remove_cv_t<_Work>, _Work_ptr>, int> = 0>
    explicit _Work_ptr(_Work& _Operation)
        : _Ptp_work(__std_create_threadpool_work(&_Work::_Threadpool_callback, ::std:: addressof(_Operation), nullptr)) {
        
        
        static_assert(noexcept(_Work::_Threadpool_callback(::std:: declval<__std_PTP_CALLBACK_INSTANCE>(),
                          ::std:: declval<void*>(), ::std:: declval<__std_PTP_WORK>())),
            "Threadpool callbacks must be noexcept to enforce termination");
        if (!_Ptp_work) {
            
            _Throw_parallelism_resources_exhausted();
        }
    }

    _Work_ptr(const _Work_ptr&) = delete;
    _Work_ptr& operator=(const _Work_ptr&) = delete;

    ~_Work_ptr() noexcept {
        __std_wait_for_threadpool_work_callbacks(_Ptp_work, true);
        __std_close_threadpool_work(_Ptp_work);
    }

    void _Submit() const noexcept {
        __std_submit_threadpool_work(_Ptp_work);
    }

    void _Submit(const size_t _Submissions) const noexcept {
        __std_bulk_submit_threadpool_work(_Ptp_work, _Submissions);
    }

    void _Submit_for_chunks(const size_t _Hw_threads, const size_t _Chunks) const noexcept {
        _Submit((::std:: min)(_Hw_threads * _Oversubmission_multiplier, _Chunks));
    }

private:
    __std_PTP_WORK _Ptp_work;
};

template <class _Work>
void _Run_available_chunked_work(_Work& _Operation) {
    while (_Operation._Process_chunk() == _Cancellation_status::_Running) { 
    }
}

template <class _Work>
void _Run_chunked_parallel_work(const size_t _Hw_threads, _Work& _Operation) {
    
    const _Work_ptr _Work_op{_Operation};
    
    _Work_op._Submit_for_chunks(_Hw_threads, _Operation._Team._Chunks);
    _Run_available_chunked_work(_Operation);
}


template <class _Diff>
constexpr size_t _Get_chunked_work_chunk_count(const size_t _Hw_threads, const _Diff _Count) {
    
    const auto _Size_count = static_cast<size_t>(_Count); 
    
    return (::std:: min)(_Hw_threads * _Oversubscription_multiplier, _Size_count);
}

template <class _Diff>
constexpr size_t _Get_least2_chunked_work_chunk_count(const size_t _Hw_threads, const _Diff _Count) {
    
    const auto _Size_count = static_cast<size_t>(_Count); 
    
    return _Get_chunked_work_chunk_count(_Hw_threads, _Size_count / 2);
}

struct _Parallelism_allocate_traits {
    __declspec(allocator) static void* _Allocate(const size_t _Bytes) {
        void* _Result = ::operator new(_Bytes, nothrow);
        if (!_Result) {
            _Throw_parallelism_resources_exhausted();
        }

        return _Result;
    }


    __declspec(allocator) static void* _Allocate_aligned(const size_t _Bytes, const size_t _Align) {
        void* _Result = ::operator new (_Bytes, align_val_t{_Align}, nothrow);
        if (!_Result) {
            _Throw_parallelism_resources_exhausted();
        }

        return _Result;
    }
#line 280 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\execution"
};

template <class _Ty = void>
struct _Parallelism_allocator {
    using value_type = _Ty;

    _Parallelism_allocator() = default;

    template <class _Other>
    constexpr _Parallelism_allocator(const _Parallelism_allocator<_Other>&) noexcept {}

    _Ty* allocate(const size_t _Count) {
        return static_cast<_Ty*>(
            _Allocate<_New_alignof<_Ty>, _Parallelism_allocate_traits>(_Get_size_of_n<sizeof(_Ty)>(_Count)));
    }

    void deallocate(_Ty* const _Ptr, const size_t _Count) {
        
        _Deallocate<_New_alignof<_Ty>>(_Ptr, sizeof(_Ty) * _Count);
    }

    template <class _Other>
    bool operator==(const _Parallelism_allocator<_Other>&) const noexcept {
        return true;
    }

    template <class _Other>
    bool operator!=(const _Parallelism_allocator<_Other>&) const noexcept {
        return false;
    }
};

template <class _Ty>
using _Parallel_vector = vector<_Ty, _Parallelism_allocator<_Ty>>;

template <class _Ty>
struct _Generalized_sum_drop { 
    _Ty* _Data;
    size_t _Slots;
    atomic<size_t> _Frontier;

    explicit _Generalized_sum_drop(const size_t _Slots)
        : _Data(static_cast<_Ty*>(
            _Allocate<_New_alignof<_Ty>, _Parallelism_allocate_traits>(_Get_size_of_n<sizeof(_Ty)>(_Slots)))),
          _Slots(_Slots), _Frontier(0) {}

    ~_Generalized_sum_drop() noexcept {
        
        _Destroy_range(begin(), end());
        
        _Deallocate<_New_alignof<_Ty>>(_Data, sizeof(_Ty) * _Slots);
    }

    template <class... _Args>
    void _Add_result(_Args&&... _Vals) noexcept  {
        
        
        const size_t _Target = _Frontier++;
        _Construct_in_place(_Data[_Target], ::std:: forward<_Args>(_Vals)...);
    }

    _Ty* begin() {
        return _Data;
    }

    _Ty* end() {
        return _Data + _Frontier.load(memory_order_relaxed);
    }
};

template <class _Ty>
struct _Atomic_is_usually_lock_free : bool_constant<atomic<_Ty>::is_always_lock_free> {
    
};

template <class _FwdIt>
inline constexpr bool _Use_atomic_iterator = conjunction_v<bool_constant<_Is_random_iter_v<_FwdIt>>,
    is_trivially_copyable<_FwdIt>, _Atomic_is_usually_lock_free<_FwdIt>>;

template <class _Ty>
struct _Parallel_choose_min_result { 
    _Ty _Last;
    atomic<_Ty> _Result;

    explicit _Parallel_choose_min_result(_Ty _Last_) : _Last{_Last_}, _Result{_Last} {}

    _Ty _Get_result() const { 
        return _Result.load(memory_order_relaxed);
    }

    bool _Complete() const { 
        return _Result.load(memory_order_relaxed) != _Last;
    }

    void _Imbue(size_t, const _Ty _Local_result) { 
        _Ty _Expected{_Last};
        while (!_Result.compare_exchange_weak(_Expected, _Local_result) && _Expected > _Local_result) { 
        }
    }
};

template <class _Ty>
struct _Parallel_choose_max_result { 
    _Ty _Last;
    atomic<_Ty> _Result;

    explicit _Parallel_choose_max_result(_Ty _Last_) : _Last{_Last_}, _Result{_Last} {}

    _Ty _Get_result() const { 
        return _Result.load(memory_order_relaxed);
    }

    bool _Complete() const { 
        return _Result.load(memory_order_relaxed) != _Last;
    }

    void _Imbue(size_t, const _Ty _Local_result) { 
        _Ty _Expected{_Last};
        if (_Result.compare_exchange_strong(_Expected, _Local_result)) {
            return;
        }

        while (_Expected < _Local_result && !_Result.compare_exchange_weak(_Expected, _Local_result)) { 
        }
    }
};

template <class _Ty>
struct _Parallel_choose_min_chunk {
    
    _Ty _Result;
    atomic<size_t> _Selected_chunk;
    mutex _Mtx;

    explicit _Parallel_choose_min_chunk(_Ty _Last) : _Result(_Last), _Selected_chunk{_Still_active}, _Mtx{} {}

    _Ty _Get_result() const { 
        return _Result;
    }

    bool _Complete() const { 
        return _Selected_chunk.load(memory_order_relaxed) != _Still_active;
    }

    void _Imbue(const size_t _Chunk, const _Ty _Local_result) {
        
        size_t _Expected = _Still_active;
        while (!_Selected_chunk.compare_exchange_weak(_Expected, _Chunk)) {
            
            if (_Chunk > _Expected) {
                return;
            }
        }

        lock_guard _Lck(_Mtx);
        if (_Selected_chunk.load(memory_order_relaxed) == _Chunk) {
            _Result = _Local_result;
        }
    }
};

template <class _Ty>
struct _Parallel_choose_max_chunk {
    
    _Ty _Result;
    atomic<size_t> _Selected_chunk;
    mutex _Mtx;

    explicit _Parallel_choose_max_chunk(_Ty _Last) : _Result(_Last), _Selected_chunk{_Still_active}, _Mtx{} {}

    _Ty _Get_result() const { 
        return _Result;
    }

    bool _Complete() const { 
        return _Selected_chunk.load(memory_order_relaxed) != _Still_active;
    }

    void _Imbue(const size_t _Chunk, const _Ty _Local_result) {
        
        size_t _Expected = _Still_active;
        while (!_Selected_chunk.compare_exchange_weak(_Expected, _Chunk)) {
            
            if (_Chunk + 1 < _Expected + 1) {
                return;
            }
        }

        lock_guard _Lck(_Mtx);
        if (_Selected_chunk.load(memory_order_relaxed) == _Chunk) {
            _Result = _Local_result;
        }
    }
};

template <class _Ty>
struct alignas(_Ty) alignas(size_t) alignas(_Atomic_counter_t) _Circular_buffer { 
    static_assert(is_trivial_v<_Ty>, "Work stealing deques work only with trivial operations");

    size_t _Log_size;
    _Atomic_counter_t _Ref_count;

    void _Release() {
        static_assert(is_trivially_destructible_v<_Circular_buffer>, "global delete requires trivial destruction");
        if (_InterlockedDecrement(reinterpret_cast<volatile long*>(&_Ref_count)) == 0) {
            ::operator delete(this);
        }
    }

    static _Circular_buffer* _Allocate_circular_buffer(const size_t _New_log_size) {
        
        if (_New_log_size >= 32) {
            _Throw_parallelism_resources_exhausted();
        }

        const size_t _Count         = static_cast<size_t>(1) << _New_log_size;
        constexpr size_t _Max_bytes = static_cast<size_t>(-1) - sizeof(_Circular_buffer);
        if (_Max_bytes / sizeof(_Ty) < _Count) {
            _Throw_parallelism_resources_exhausted();
        }

        const size_t _Result_bytes = _Count * sizeof(_Ty) + sizeof(_Circular_buffer);
        static_assert(alignof(_Ty) <= alignof(max_align_t), "incapable of supporting the requested alignment");
        const auto _Result  = static_cast<_Circular_buffer*>(::operator new(_Result_bytes));
        _Result->_Log_size  = _New_log_size;
        _Result->_Ref_count = 1;
        return _Result;
    }

    static _Circular_buffer* _New_circular_buffer() { 
        return _Allocate_circular_buffer(6); 
    }

    _Ty* _Get_base() { 
        return reinterpret_cast<_Ty*>(this + 1);
    }

    const _Ty* _Get_base() const { 
        return reinterpret_cast<const _Ty*>(this + 1);
    }

    _Ty& _Subscript(const size_t _Idx) { 
        const auto _Mask = (static_cast<size_t>(1) << _Log_size) - static_cast<size_t>(1);
        return _Get_base()[_Idx & _Mask];
    }

    const _Ty& _Subscript(const size_t _Idx) const { 
        const auto _Mask = (static_cast<size_t>(1) << _Log_size) - static_cast<size_t>(1);
        return _Get_base()[_Idx & _Mask];
    }

    _Circular_buffer* _Grow(const size_t _Bottom, const size_t _Top) const {
        
        const size_t _New_log_size = _Log_size + 1;
        _Circular_buffer* _Result  = _Allocate_circular_buffer(_New_log_size);
        for (size_t _Idx = _Top; _Idx < _Bottom; ++_Idx) {
            _Result->_Subscript(_Idx) = _Subscript(_Idx);
        }

        return _Result;
    }
};

#pragma warning(push)
#pragma warning(disable : 4324) 
template <class _Ty>
class alignas(hardware_destructive_interference_size) _Work_stealing_deque {
    
    
public:
    _Work_stealing_deque()                            = default;
    _Work_stealing_deque(const _Work_stealing_deque&) = delete;
    _Work_stealing_deque& operator=(const _Work_stealing_deque&) = delete;

    ~_Work_stealing_deque() noexcept {
        _Segment->_Release();
    }

    void _Push_bottom(_Ty& _Val) {
        
        
        const auto _Local_b = _Bottom.load();
        if (_Local_b == 0xffffffffui32) {
            
            
            _Throw_parallelism_resources_exhausted();
        }

        const auto _Local_t = _Top.load();
        const auto _Size    = _Local_b - _Local_t;
        if (_Size >= (static_cast<size_t>(1) << _Segment->_Log_size)) {
            auto _New_segment = _Segment->_Grow(_Local_b, _Local_t);
            _Circular_buffer<_Ty>* _Detached_segment;
            {
                lock_guard _Lck(_Segment_lock);
                _Detached_segment = ::std:: exchange(_Segment, _New_segment);
            } 

            _Detached_segment->_Release();
        }

        _Segment->_Subscript(_Local_b) = _Val;
        _Bottom.store(_Local_b + 1U);
    }

    bool _Steal(_Ty& _Val) noexcept {
        
        
        auto _Local_t = _Top.load();
        size_t _Desired_t;
        do {
            if (_Bottom.load() <= _Local_t) { 
                return false;
            }

            _Circular_buffer<_Ty>* _Stealing_segment;
            {
                lock_guard _Lck(_Segment_lock);
                _Stealing_segment = _Segment;
                _InterlockedIncrement(reinterpret_cast<volatile long*>(&_Stealing_segment->_Ref_count));
            }

            _Val = _Stealing_segment->_Subscript(_Local_t); 
            _Stealing_segment->_Release();
            
            
            _Desired_t = _Local_t + 1U;
        } while (!_Top.compare_exchange_strong(_Local_t, _Desired_t)); 

        return true;
    }

    bool _Try_pop_bottom(_Ty& _Val) noexcept {
        
        
        auto _Local_b = _Bottom.load();
        if (_Local_b == 0) { 
            return false;
        }

        --_Local_b;
        _Bottom.store(_Local_b);
        auto _Local_t = _Top.load();
        if (_Local_b < _Local_t) { 
            _Bottom.store(_Local_t);
            return false;
        }

        
        _Val = _Segment->_Subscript(_Local_b);

        if (_Local_b > _Local_t) {
            
            return true;
        }

        
        const auto _Desired_top = _Local_t + 1U;
        if (_Top.compare_exchange_strong(_Local_t, _Desired_top)) {
            _Bottom.store(_Desired_top);
            return true;
        } else {
            _Bottom.store(_Local_t);
            return false;
        }
    }

private:
    atomic<size_t> _Bottom{0}; 
    atomic<size_t> _Top{0}; 
     _Circular_buffer<_Ty>* _Segment{_Circular_buffer<_Ty>::_New_circular_buffer()};
    mutex _Segment_lock{};
};
#pragma warning(pop)

enum class _Steal_result { _Success, _Abort, _Done };

template <class _Ty>
struct _Work_stealing_team;

template <class _Ty>
struct _Work_stealing_membership { 
    using _Diff = typename _Ty::difference_type;

    size_t _Id;
    _Work_stealing_team<_Ty>* _Team;
    _Diff _Work_complete;

    void _Push_bottom(_Ty& _Val) {
        _Team->_Queues[_Id]._Push_bottom(_Val);
    }

    bool _Try_pop_bottom(_Ty& _Val) noexcept {
        return _Team->_Queues[_Id]._Try_pop_bottom(_Val);
    }

    _Steal_result _Steal(_Ty& _Val) noexcept {
        _Diff _Remaining;
        const auto _Completed_this_time = ::std:: exchange(_Work_complete, {});
        if (_Completed_this_time == 0) {
            _Remaining = _Team->_Remaining_work.load();
        } else {
            _Remaining = _Team->_Remaining_work -= _Completed_this_time;
        }

        if (_Remaining == 0) {
            return _Steal_result::_Done;
        }

        const size_t _High = _Team->_Queues_used.load() + 1;
        size_t _Idx        = _Id;
        for (;;) {
            if (_Idx == 0) {
                _Idx = _High;
            }

            --_Idx;
            if (_Idx == _Id) {
                return _Steal_result::_Abort;
            }

            if (_Team->_Queues[_Idx]._Steal(_Val)) {
                return _Steal_result::_Success;
            }
        }
    }

    void _Leave() noexcept {
        _Team->_Leave_team(_Id);
    }
};

template <class _Ty>
struct _Work_stealing_team { 
    using _Diff = typename _Ty::difference_type;

    static _Parallel_vector<size_t> _Get_queues(const size_t _Queue_count) {
        _Parallel_vector<size_t> _Result(_Queue_count);
        ::std:: iota(_Result.begin(), _Result.end(), size_t{});
        return _Result;
    }

    _Work_stealing_team(size_t _Threads, _Diff _Total_work)
        : _Queues(_Threads), _Queues_used(0), _Remaining_work(_Total_work), _Available_mutex(),
          _Available_queues(greater{}, _Get_queues(_Threads)) {} 

    _Work_stealing_membership<_Ty> _Join_team() noexcept {
        size_t _Id;
        {
            lock_guard _Lck(_Available_mutex);
            _Id = _Available_queues.top();
            _Available_queues.pop();
        } 

        
        size_t _High_water = _Queues_used.load();
        while (_High_water < _Id && !_Queues_used.compare_exchange_weak(_High_water, _Id)) { 
        }

        return _Work_stealing_membership<_Ty>{_Id, this, 0};
    }

    void _Leave_team(size_t _Id) noexcept {
        lock_guard _Lck(_Available_mutex);
        _Available_queues.push(_Id);
    }

    _Parallel_vector<_Work_stealing_deque<_Ty>> _Queues;
    atomic<size_t> _Queues_used;
    atomic<_Diff> _Remaining_work;

    mutex _Available_mutex;
    priority_queue<size_t, _Parallel_vector<size_t>, greater<>> _Available_queues;
};

template <class _Diff>
struct _Static_partition_key { 
    size_t _Chunk_number; 
    _Diff _Start_at;
    _Diff _Size;

    explicit operator bool() const { 
        return _Chunk_number != static_cast<size_t>(-1);
    }
};

template <class _Diff>
struct _Static_partition_team { 
    atomic<size_t> _Consumed_chunks;
    size_t _Chunks;
    _Diff _Count;
    _Diff _Chunk_size;
    _Diff _Unchunked_items;

    _Static_partition_team(const _Diff _Count_, const size_t _Chunks_)
        : _Consumed_chunks{0}, _Chunks{_Chunks_}, _Count{_Count_}, _Chunk_size{static_cast<_Diff>(
                                                                       _Count_ / static_cast<_Diff>(_Chunks_))},
          _Unchunked_items{static_cast<_Diff>(_Count_ % static_cast<_Diff>(_Chunks_))} {
        
        
    }

    _Static_partition_key<_Diff> _Get_chunk_key(const size_t _This_chunk) const {
        const auto _This_chunk_diff = static_cast<_Diff>(_This_chunk);
        auto _This_chunk_size       = _Chunk_size;
        auto _This_chunk_start_at   = static_cast<_Diff>(_This_chunk_diff * _This_chunk_size);
        if (_This_chunk_diff < _Unchunked_items) {
            
            
            _This_chunk_start_at += _This_chunk_diff;
            ++_This_chunk_size;
        } else { 
            _This_chunk_start_at += _Unchunked_items;
        }

        return {_This_chunk, _This_chunk_start_at, _This_chunk_size};
    }

    _Diff _Get_chunk_offset(const size_t _This_chunk) const {
        const auto _This_chunk_diff = static_cast<_Diff>(_This_chunk);
        return _This_chunk_diff * _Chunk_size + (::std:: min)(_This_chunk_diff, _Unchunked_items);
    }

    _Static_partition_key<_Diff> _Get_next_key() {
        
        
        const auto _This_chunk = _Consumed_chunks++;
        if (_This_chunk < _Chunks) {
            return _Get_chunk_key(_This_chunk);
        }

        return {static_cast<size_t>(-1), 0, 0};
    }
};

template <class _FwdIt>
struct _Iterator_range { 
    _FwdIt _First;
    _FwdIt _Last;
};

template <class _FwdIt, class _Diff = _Iter_diff_t<_FwdIt>, bool = _Is_random_iter_v<_FwdIt>>
struct _Static_partition_range;

template <class _RanIt, class _Diff>
struct _Static_partition_range<_RanIt, _Diff, true> {
    using _Target_diff = _Iter_diff_t<_RanIt>;
    using _URanIt      = _Unwrapped_t<const _RanIt&>;
    _URanIt _Start_at;
    using _Chunk_type = _Iterator_range<_URanIt>;

    _RanIt _Populate(const _Static_partition_team<_Diff>& _Team, _RanIt _First) {
        
        
        auto _Result = _First + static_cast<_Target_diff>(_Team._Count); 
        _Start_at    = _Get_unwrapped(_First);
        return _Result;
    }

    bool _Populate(const _Static_partition_team<_Diff>& _Team, _RanIt _First, _RanIt _Last) {
        
        
        _Adl_verify_range(_First, _Last);
        _Start_at = _Get_unwrapped(_First);
        return _Team._Count == _Last - _First;
    }

    _URanIt _Get_first(size_t , const _Diff _Offset) {
        
        return _Start_at + static_cast<_Target_diff>(_Offset);
    }

    _Chunk_type _Get_chunk(const _Static_partition_key<_Diff> _Key) const {
        
        
        const auto _First = _Start_at + static_cast<_Target_diff>(_Key._Start_at);
        return {_First, _First + static_cast<_Target_diff>(_Key._Size)};
    }
};

template <class _FwdIt, class _Diff>
struct _Static_partition_range<_FwdIt, _Diff, false> {
    using _Target_diff = _Iter_diff_t<_FwdIt>;
    using _UFwdIt      = _Unwrapped_t<const _FwdIt&>;
    _Parallel_vector<_UFwdIt> _Division_points;
    using _Chunk_type = _Iterator_range<_UFwdIt>;

    _FwdIt _Populate(const _Static_partition_team<_Diff>& _Team, _FwdIt _First) {
        
        
        const auto _Chunks = _Team._Chunks;
        _Division_points.resize(_Chunks + 1);
        
        
        const auto _Chunk_size      = static_cast<_Target_diff>(_Team._Chunk_size);
        const auto _Unchunked_items = _Team._Unchunked_items;
        auto _Result                = _Division_points.begin();
        *_Result                    = _Get_unwrapped(_First);
        for (_Diff _Idx{}; _Idx < _Unchunked_items; ++_Idx) { 
            ::std:: advance(_First, static_cast<_Target_diff>(_Chunk_size + 1));
            *++_Result = _Get_unwrapped(_First);
        }

        const auto _Diff_chunks = static_cast<_Diff>(_Chunks);
        for (_Diff _Idx = _Unchunked_items; _Idx < _Diff_chunks; ++_Idx) { 
            ::std:: advance(_First, _Chunk_size);
            *++_Result = _Get_unwrapped(_First);
        }

        return _First;
    }

    bool _Populate(const _Static_partition_team<_Diff>& _Team, _FwdIt _First, _FwdIt _Last) {
        
        
        const auto _Chunks = _Team._Chunks;
        _Division_points.resize(_Chunks + 1);
        const auto _Chunk_size      = _Team._Chunk_size;
        const auto _Unchunked_items = _Team._Unchunked_items;
        auto _Result                = _Division_points.begin();
        *_Result                    = _Get_unwrapped(_First);
        for (_Diff _Idx{}; _Idx < _Unchunked_items; ++_Idx) { 
            for (_Diff _This_chunk_size = _Chunk_size + 1; 0 < _This_chunk_size--;) {
                if (_First == _Last) {
                    return false;
                }

                ++_First;
            }

            *++_Result = _Get_unwrapped(_First);
        }

        const auto _Diff_chunks = static_cast<_Diff>(_Chunks);
        for (_Diff _Idx = _Unchunked_items; _Idx < _Diff_chunks; ++_Idx) { 
            for (_Diff _This_chunk_size = _Chunk_size; 0 < _This_chunk_size--;) {
                if (_First == _Last) {
                    return false;
                }

                ++_First;
            }

            *++_Result = _Get_unwrapped(_First);
        }

        return _First == _Last;
    }

    _UFwdIt _Get_first(const size_t _Chunk_number, _Diff ) {
        
        return _Division_points[_Chunk_number];
    }

    _Chunk_type _Get_chunk(const _Static_partition_key<_Diff> _Key) const {
        
        
        return {_Division_points[_Key._Chunk_number], _Division_points[_Key._Chunk_number + 1]};
    }
};

template <class _BidIt, class _Diff = _Iter_diff_t<_BidIt>, bool = _Is_random_iter_v<_BidIt>>
struct _Static_partition_range_backward;

template <class _RanIt, class _Diff>
struct _Static_partition_range_backward<_RanIt, _Diff, true> {
    using _Target_diff = _Iter_diff_t<_RanIt>;
    _Unwrapped_t<const _RanIt&> _Start_at;
    using _Chunk_type = _Iterator_range<_Unwrapped_t<const _RanIt&>>;

    void _Populate(const _Static_partition_team<_Diff>& _Team, _RanIt _Last) {
        
        
        _Start_at = _Get_unwrapped_n(_Last, -static_cast<_Target_diff>(_Team._Count));
    }

    _Chunk_type _Get_chunk(const _Static_partition_key<_Diff> _Key) const {
        
        
        const auto _Last = _Start_at - static_cast<_Target_diff>(_Key._Start_at);
        return {_Last - static_cast<_Target_diff>(_Key._Size), _Last};
    }
};

template <class _BidIt, class _Diff>
struct _Static_partition_range_backward<_BidIt, _Diff, false> {
    using _Target_diff = _Iter_diff_t<_BidIt>;
    _Parallel_vector<_Unwrapped_t<const _BidIt&>> _Division_points;
    using _Chunk_type = _Iterator_range<_Unwrapped_t<const _BidIt&>>;

    void _Populate(const _Static_partition_team<_Diff>& _Team, _BidIt _Last) {
        
        
        const auto _Chunks = _Team._Chunks;
        _Division_points.resize(_Chunks + 1);
        const auto _Neg_chunk_size  = static_cast<_Target_diff>(-_Team._Chunk_size);
        const auto _Unchunked_items = _Team._Unchunked_items;
        auto _Result = _Division_points.begin(); 
        *_Result     = _Get_unwrapped(_Last);
        for (_Diff _Idx{}; _Idx < _Unchunked_items; ++_Idx) {
            ::std:: advance(_Last, static_cast<_Target_diff>(_Neg_chunk_size - 1));
            *++_Result = _Get_unwrapped(_Last);
        }

        const auto _Diff_chunks = static_cast<_Diff>(_Chunks);
        for (_Diff _Idx = _Unchunked_items; _Idx < _Diff_chunks; ++_Idx) {
            ::std:: advance(_Last, _Neg_chunk_size);
            *++_Result = _Get_unwrapped(_Last);
        }
    }

    _Chunk_type _Get_chunk(const _Static_partition_key<_Diff> _Key) const {
        
        
        return {_Division_points[_Key._Chunk_number + 1], _Division_points[_Key._Chunk_number]};
    }
};

template <class _InIt1, class _InIt2>
_Common_diff_t<_InIt1, _InIt2> _Distance_any(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2) {
    
    if constexpr (_Is_random_iter_v<_InIt1>) {
        return _Last1 - _First1;
    } else if constexpr (_Is_random_iter_v<_InIt2>) {
        return _Last2 - _First2;
    } else {
        return ::std:: distance(_First1, _Last1);
    }
}

template <class _InIt1, class _InIt2>
_Common_diff_t<_InIt1, _InIt2> _Distance_min(_InIt1 _First1, const _InIt1 _Last1, _InIt2 _First2, const _InIt2 _Last2) {
    
    using _CT = _Common_diff_t<_InIt1, _InIt2>;
    _CT _Result{};
    if constexpr (_Is_random_iter_v<_InIt1> && _Is_random_iter_v<_InIt2>) {
        const _CT _Count1 = _Last1 - _First1;
        const _CT _Count2 = _Last2 - _First2;
        _Result           = (::std:: min)(_Count1, _Count2);
    } else if constexpr (_Is_random_iter_v<_InIt1>) {
        for (auto _Count1 = _Last1 - _First1; 0 < _Count1 && _First2 != _Last2; --_Count1) {
            ++_First2;
            ++_Result;
        }
    } else if constexpr (_Is_random_iter_v<_InIt2>) {
        for (auto _Count2 = _Last2 - _First2; 0 < _Count2 && _First1 != _Last1; --_Count2) {
            ++_First1;
            ++_Result;
        }
    } else {
        while (_First1 != _Last1 && _First2 != _Last2) {
            ++_First1;
            ++_First2;
            ++_Result;
        }
    }

    return _Result;
}

template <bool _Invert, class _FwdIt, class _Pr>
struct _Static_partitioned_all_of_family2 { 
    _Static_partition_team<_Iter_diff_t<_FwdIt>> _Team;
    _Static_partition_range<_FwdIt> _Basis;
    _Pr _Pred;
    _Cancellation_token _Cancel_token;

    _Static_partitioned_all_of_family2(
        _FwdIt _First, const size_t _Hw_threads, const _Iter_diff_t<_FwdIt> _Count, _Pr _Pred_)
        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis{}, _Pred(_Pred_), _Cancel_token{} {
        _Basis._Populate(_Team, _First);
    }

    _Cancellation_status _Process_chunk() {
        if (_Cancel_token._Is_canceled()) {
            return _Cancellation_status::_Canceled;
        }

        const auto _Key = _Team._Get_next_key();
        if (!_Key) {
            return _Cancellation_status::_Canceled;
        }
        

        const auto _Range = _Basis._Get_chunk(_Key);
        for (auto _First = _Range._First; _First != _Range._Last; ++_First) {
            if (_Pred(*_First) ? _Invert : !_Invert) {
                _Cancel_token._Cancel();
                return _Cancellation_status::_Canceled;
            }
        }

        return _Cancellation_status::_Running;
    }

    static void __stdcall _Threadpool_callback(
        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept  {
        _Run_available_chunked_work(*static_cast<_Static_partitioned_all_of_family2*>(_Context));
    }
};

template <bool _Invert, class _FwdIt, class _Pr>
bool _All_of_family_parallel(_FwdIt _First, const _FwdIt _Last, _Pr _Pred) {
    
    const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
    if (_Hw_threads > 1) { 
        const auto _Count = ::std:: distance(_First, _Last);
        if (_Count >= 2) { 
            try {
            _Static_partitioned_all_of_family2<_Invert, _FwdIt, _Pr> _Operation{_First, _Hw_threads, _Count, _Pred};
            _Run_chunked_parallel_work(_Hw_threads, _Operation);
            return !_Operation._Cancel_token._Is_canceled_relaxed();
            } catch (const _Parallelism_resources_exhausted&) {
            
            }
        }
    }

    for (; _First != _Last; ++_First) {
        if (_Pred(*_First) ? _Invert : !_Invert) {
            return false;
        }
    }

    return true;
}

template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> >
[[nodiscard]] bool all_of(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept  {
    
    static_assert(_Is_fwd_iter_v<_FwdIt>, "Parallel algorithms require forward iterators or stronger.");
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        return _All_of_family_parallel<false>(_UFirst, _ULast, _Pass_fn(_Pred));
    } else {
        return ::std:: all_of(_UFirst, _ULast, _Pass_fn(_Pred));
    }
}

template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> >
[[nodiscard]] bool any_of(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept  {
    
    static_assert(_Is_fwd_iter_v<_FwdIt>, "Parallel algorithms require forward iterators or stronger.");
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        return !_All_of_family_parallel<true>(_UFirst, _ULast, _Pass_fn(_Pred));
    } else {
        return ::std:: any_of(_UFirst, _ULast, _Pass_fn(_Pred));
    }
}

template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> >
[[nodiscard]] bool none_of(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept  {
    
    static_assert(_Is_fwd_iter_v<_FwdIt>, "Parallel algorithms require forward iterators or stronger.");
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        return _All_of_family_parallel<true>(_UFirst, _ULast, _Pass_fn(_Pred));
    } else {
        return ::std:: none_of(_UFirst, _ULast, _Pass_fn(_Pred));
    }
}

template <class _FwdIt, class _Fn>
void _For_each_ivdep(_FwdIt _First, const _FwdIt _Last, _Fn _Func) {
    
#pragma loop(ivdep)
    for (; _First != _Last; ++_First) {
        _Func(*_First);
    }
}

template <class _FwdIt, class _Diff, class _Fn>
struct _Static_partitioned_for_each2 { 
    _Static_partition_team<_Diff> _Team;
    _Static_partition_range<_FwdIt, _Diff> _Basis;
    _Fn _Func;

    _Static_partitioned_for_each2(const size_t _Hw_threads, const _Diff _Count, _Fn _Fx)
        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis{}, _Func(_Fx) {}

    _Cancellation_status _Process_chunk() {
        const auto _Key = _Team._Get_next_key();
        if (_Key) {
            const auto _Chunk = _Basis._Get_chunk(_Key);
            _For_each_ivdep(_Chunk._First, _Chunk._Last, _Func);
            return _Cancellation_status::_Running;
        }

        return _Cancellation_status::_Canceled;
    }

    static void __stdcall _Threadpool_callback(
        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept  {
        _Run_available_chunked_work(*static_cast<_Static_partitioned_for_each2*>(_Context));
    }
};

template <class _ExPo, class _FwdIt, class _Fn, _Enable_if_execution_policy_t<_ExPo> >
void for_each(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Fn _Func) noexcept  {
    
    static_assert(_Is_fwd_iter_v<_FwdIt>, "Parallel algorithms require forward iterators or stronger.");
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
        if (_Hw_threads > 1) { 
            auto _Count = ::std:: distance(_UFirst, _ULast);
            if (_Count >= 2) { 
                try {
                auto _Passed_fn = _Pass_fn(_Func);
                _Static_partitioned_for_each2<decltype(_UFirst), decltype(_Count), decltype(_Passed_fn)> _Operation{
                    _Hw_threads, _Count, _Passed_fn};
                _Operation._Basis._Populate(_Operation._Team, _UFirst);
                _Run_chunked_parallel_work(_Hw_threads, _Operation);
                return;
                } catch (const _Parallelism_resources_exhausted&) {
                
                }
            }
        }

        _For_each_ivdep(_UFirst, _ULast, _Pass_fn(_Func));
    } else if constexpr (remove_reference_t<_ExPo>::_Ivdep) {
        _For_each_ivdep(_UFirst, _ULast, _Pass_fn(_Func));
    } else {
        for (; _UFirst != _ULast; ++_UFirst) {
            _Func(*_UFirst);
        }
    }
}

template <class _FwdIt, class _Diff, class _Fn>
_FwdIt _For_each_n_ivdep(_FwdIt _First, _Diff _Count, _Fn _Func) {
    
#pragma loop(ivdep)
    for (; 0 < _Count; --_Count, (void) ++_First) {
        _Func(*_First);
    }

    return _First;
}

template <class _ExPo, class _FwdIt, class _Diff, class _Fn, _Enable_if_execution_policy_t<_ExPo> >
_FwdIt for_each_n(_ExPo&&, _FwdIt _First, const _Diff _Count_raw, _Fn _Func) noexcept  {
    
    static_assert(_Is_fwd_iter_v<_FwdIt>, "Parallel algorithms require forward iterators or stronger.");
    _Algorithm_int_t<_Diff> _Count = _Count_raw;
    if (0 < _Count) {
        auto _UFirst = _Get_unwrapped_n(_First, _Count);
        if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
            const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
            if (_Hw_threads > 1 && _Count >= 2) { 
                try {
                auto _Passed_fn = _Pass_fn(_Func);
                _Static_partitioned_for_each2<decltype(_UFirst), decltype(_Count), decltype(_Passed_fn)> _Operation{
                    _Hw_threads, _Count, _Passed_fn};
                _Seek_wrapped(_First, _Operation._Basis._Populate(_Operation._Team, _UFirst));
                _Run_chunked_parallel_work(_Hw_threads, _Operation);
                return _First;
                } catch (const _Parallelism_resources_exhausted&) {
                
                }
            }

            _Seek_wrapped(_First, _For_each_n_ivdep(_UFirst, _Count, _Pass_fn(_Func)));
        } else if constexpr (remove_reference_t<_ExPo>::_Ivdep) {
            _Seek_wrapped(_First, _For_each_n_ivdep(_UFirst, _Count, _Pass_fn(_Func)));
        } else {
            for (; 0 < _Count; --_Count, (void) ++_UFirst) {
                _Func(*_UFirst);
            }

            _Seek_wrapped(_First, _UFirst);
        }
    }

    return _First;
}

template <class _FwdIt>
using _Parallel_find_results = conditional_t<_Use_atomic_iterator<_FwdIt>, _Parallel_choose_min_result<_FwdIt>,
    _Parallel_choose_min_chunk<_FwdIt>>;

template <class _FwdIt, class _Find_fx>
struct _Static_partitioned_find2 {
    _Static_partition_team<_Iter_diff_t<_FwdIt>> _Team;
    _Static_partition_range<_FwdIt> _Basis;
    _Parallel_find_results<_FwdIt> _Results;
    _Find_fx _Fx;

    _Static_partitioned_find2(
        const size_t _Hw_threads, const _Iter_diff_t<_FwdIt> _Count, const _FwdIt _Last, const _Find_fx _Fx_)
        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis{}, _Results(_Last), _Fx(_Fx_) {}

    _Cancellation_status _Process_chunk() {
        if (_Results._Complete()) {
            return _Cancellation_status::_Canceled;
        }

        const auto _Key = _Team._Get_next_key();
        if (!_Key) {
            return _Cancellation_status::_Canceled;
        }
        

        const auto _Range     = _Basis._Get_chunk(_Key);
        const auto _This_find = _Fx(_Range._First, _Range._Last);
        if (_This_find == _Range._Last) {
            return _Cancellation_status::_Running;
        }

        _Results._Imbue(_Key._Chunk_number, _This_find);
        return _Cancellation_status::_Canceled;
    }

    static void __stdcall _Threadpool_callback(
        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept  {
        _Run_available_chunked_work(*static_cast<_Static_partitioned_find2*>(_Context));
    }
};

template <class _ExPo, class _FwdIt, class _Find_fx>
_FwdIt _Find_parallel_unchecked(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, const _Find_fx _Fx) {
    
    if (remove_reference_t<_ExPo>::_Parallelize) {
        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
        if (_Hw_threads > 1) {
            const auto _Count = ::std:: distance(_First, _Last);
            if (_Count >= 2) {
                try {
                _Static_partitioned_find2 _Operation{_Hw_threads, _Count, _Last, _Fx};
                _Operation._Basis._Populate(_Operation._Team, _First);
                _Run_chunked_parallel_work(_Hw_threads, _Operation);
                return _Operation._Results._Get_result();
                } catch (const _Parallelism_resources_exhausted&) {
                
                }
            }
        }
    }

    return _Fx(_First, _Last);
}

template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> >
[[nodiscard]] _FwdIt find(_ExPo&& _Exec, _FwdIt _First, const _FwdIt _Last, const _Ty& _Val) noexcept  {
    
    static_assert(_Is_fwd_iter_v<_FwdIt>, "Parallel algorithms require forward iterators or stronger.");
    using _UFwdIt = _Unwrapped_t<const _FwdIt&>;
    _Adl_verify_range(_First, _Last);
    _Seek_wrapped(_First,
        _Find_parallel_unchecked(::std:: forward<_ExPo>(_Exec), _Get_unwrapped(_First), _Get_unwrapped(_Last),
            [&](const _UFwdIt _LFirst, const _UFwdIt _LLast) { return _Find_unchecked(_LFirst, _LLast, _Val); }));
    return _First;
}

template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> >
[[nodiscard]] _FwdIt find_if(_ExPo&& _Exec, _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept  {
    
    static_assert(_Is_fwd_iter_v<_FwdIt>, "Parallel algorithms require forward iterators or stronger.");
    using _UFwdIt = _Unwrapped_t<const _FwdIt&>;
    _Adl_verify_range(_First, _Last);
    auto _Pass_pred = _Pass_fn(_Pred);
    _Seek_wrapped(_First,
        _Find_parallel_unchecked(::std:: forward<_ExPo>(_Exec), _Get_unwrapped(_First), _Get_unwrapped(_Last),
            [=](const _UFwdIt _LFirst, const _UFwdIt _LLast) { return ::std:: find_if(_LFirst, _LLast, _Pass_pred); }));
    return _First;
}

template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> >
[[nodiscard]] _FwdIt find_if_not(_ExPo&& _Exec, _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept  {
    
    static_assert(_Is_fwd_iter_v<_FwdIt>, "Parallel algorithms require forward iterators or stronger.");
    using _UFwdIt = _Unwrapped_t<const _FwdIt&>;
    _Adl_verify_range(_First, _Last);
    auto _Pass_pred = _Pass_fn(_Pred);
    _Seek_wrapped(_First, _Find_parallel_unchecked(::std:: forward<_ExPo>(_Exec), _Get_unwrapped(_First),
                              _Get_unwrapped(_Last), [=](const _UFwdIt _LFirst, const _UFwdIt _LLast) {
                                  return ::std:: find_if_not(_LFirst, _LLast, _Pass_pred);
                              }));
    return _First;
}

template <class _FwdIt1, class _FwdIt2>
_Iter_diff_t<_FwdIt1> _Get_find_end_forward_partition_size(
    _FwdIt1 _First1, const _FwdIt1 _Last1, _FwdIt2 _First2, const _FwdIt2 _Last2) {
    
    if (_First2 == _Last2) {
        return 0;
    }

    for (;;) {
        if (_First1 == _Last1) { 
            return 0;
        }

        ++_First2;
        if (_First2 == _Last2) { 
            return ::std:: distance(_First1, _Last1);
        }

        ++_First1;
    }
}

template <class _FwdIt1, class _FwdIt2, class _Pr>
struct _Static_partitioned_find_end_forward {
    _Static_partition_team<_Iter_diff_t<_FwdIt1>> _Team;
    _Static_partition_range<_FwdIt1> _Basis;
    _Iterator_range<_FwdIt2> _Range2;
    _Pr _Pred;
    conditional_t<_Use_atomic_iterator<_FwdIt1>, _Parallel_choose_max_result<_FwdIt1>,
        _Parallel_choose_max_chunk<_FwdIt1>>
        _Results;

    _Static_partitioned_find_end_forward(const size_t _Hw_threads, const _Iter_diff_t<_FwdIt1> _Count,
        const _FwdIt1 _Last1, const _FwdIt2 _First2, const _FwdIt2 _Last2, const _Pr _Pred_)
        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis{}, _Range2{_First2, _Last2},
          _Pred{_Pred_}, _Results(_Last1) {}

    _Cancellation_status _Process_chunk() {
        const auto _Key = _Team._Get_next_key();
        if (!_Key) {
            return _Cancellation_status::_Canceled;
        }

        const auto _Chunk_number = _Key._Chunk_number;
        const auto _Range        = _Basis._Get_chunk(_Key);
        _FwdIt1 _Result          = _Range._Last;
        for (auto _First1 = _Range._First; _First1 != _Range._Last; ++_First1) {
            if (_Equal_rev_pred_unchecked(_First1, _Range2._First, _Range2._Last, _Pred)) {
                _Result = _First1;
            }
        }

        if (_Result != _Range._Last) {
            _Results._Imbue(_Chunk_number, _Result);
        }

        return _Cancellation_status::_Running;
    }

    static void __stdcall _Threadpool_callback(
        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept  {
        (void) static_cast<_Static_partitioned_find_end_forward*>(_Context)->_Process_chunk();
    }
};

template <class _BidIt1, class _FwdIt2>
_BidIt1 _Get_find_end_backward_partition_start(
    const _BidIt1 _First1, _BidIt1 _Last1, _FwdIt2 _First2, const _FwdIt2 _Last2) {
    
    if constexpr (_Is_random_iter_v<_BidIt1> && _Is_random_iter_v<_FwdIt2>) {
        using _CT         = _Common_diff_t<_BidIt1, _FwdIt2>;
        const _CT _Count1 = _Last1 - _First1;
        const _CT _Count2 = _Last2 - _First2;
        _Iter_diff_t<_BidIt1> _Count{};
        if (0 < _Count2 && _Count2 <= _Count1) {
            _Count = static_cast<_Iter_diff_t<_BidIt1>>(_Count1 - _Count2 + 1);
        }
        return _First1 + _Count;
    } else {
        if (_First2 == _Last2) { 
            return _First1;
        }

        for (;;) {
            if (_First1 == _Last1) { 
                return _First1;
            }

            ++_First2;
            if (_First2 == _Last2) { 
                return _Last1;
            }

            --_Last1;
        }
    }
}

template <class _BidIt1, class _FwdIt2, class _Pr>
struct _Static_partitioned_find_end_backward2 {
    _Static_partition_team<_Iter_diff_t<_BidIt1>> _Team;
    _Static_partition_range_backward<_BidIt1> _Basis;
    conditional_t<_Use_atomic_iterator<_BidIt1>, _Parallel_choose_max_result<_BidIt1>,
        _Parallel_choose_min_chunk<_BidIt1>>
        _Results;
    _Iterator_range<_FwdIt2> _Range2;
    _Pr _Pred;

    _Static_partitioned_find_end_backward2(const size_t _Hw_threads, const _Iter_diff_t<_BidIt1> _Count,
        const _BidIt1 _Last1, const _FwdIt2 _First2, const _FwdIt2 _Last2, const _Pr _Pred_)
        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis{},
          _Results(_Last1), _Range2{_First2, _Last2}, _Pred{_Pred_} {}

    _Cancellation_status _Process_chunk() {
        if (_Results._Complete()) {
            return _Cancellation_status::_Canceled;
        }

        const auto _Key = _Team._Get_next_key();
        if (!_Key) {
            return _Cancellation_status::_Canceled;
        }
        

        const auto _Chunk_number = _Key._Chunk_number;
        const auto _Range        = _Basis._Get_chunk(_Key);
        auto _Last1              = _Range._Last;
        do {
            --_Last1;
            if (_Equal_rev_pred_unchecked(_Last1, _Range2._First, _Range2._Last, _Pred)) {
                _Results._Imbue(_Chunk_number, _Last1);
                return _Cancellation_status::_Canceled;
            }
        } while (_Last1 != _Range._First);
        return _Cancellation_status::_Running;
    }

    static void __stdcall _Threadpool_callback(
        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept  {
        _Run_available_chunked_work(*static_cast<_Static_partitioned_find_end_backward2*>(_Context));
    }
};

template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> >
[[nodiscard]] _FwdIt1 find_end(_ExPo&&, _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2, const _FwdIt2 _Last2,
    _Pr _Pred) noexcept  {
    
    _Adl_verify_range(_First1, _Last1);
    _Adl_verify_range(_First2, _Last2);
    const auto _UFirst1 = _Get_unwrapped(_First1);
    const auto _ULast1  = _Get_unwrapped(_Last1);
    const auto _UFirst2 = _Get_unwrapped(_First2);
    const auto _ULast2  = _Get_unwrapped(_Last2);
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
        if (_Hw_threads > 1) {
            if constexpr (_Is_bidi_iter_v<_FwdIt1>) {
                const auto _Partition_start =
                    _Get_find_end_backward_partition_start(_UFirst1, _ULast1, _UFirst2, _ULast2);
                if (_UFirst1 == _Partition_start) {
                    _Seek_wrapped(_First1, _ULast1);
                    return _First1;
                }

                const auto _Count = ::std:: distance(_UFirst1, _Partition_start);
                if (_Count >= 2) {
                    try {
                    _Static_partitioned_find_end_backward2 _Operation{
                        _Hw_threads, _Count, _ULast1, _UFirst2, _ULast2, _Pass_fn(_Pred)};
                    _Operation._Basis._Populate(_Operation._Team, _Partition_start);
                    _Run_chunked_parallel_work(_Hw_threads, _Operation);
                    _Seek_wrapped(_First1, _Operation._Results._Get_result());
                    return _First1;
                    } catch (const _Parallelism_resources_exhausted&) {
                    
                    }
                }
            } else {
                const auto _Count = _Get_find_end_forward_partition_size(_UFirst1, _ULast1, _UFirst2, _ULast2);
                if (_Count >= 2) {
                    try {
                    _Static_partitioned_find_end_forward _Operation{
                        _Hw_threads, _Count, _ULast1, _UFirst2, _ULast2, _Pass_fn(_Pred)};
                    _Operation._Basis._Populate(_Operation._Team, _UFirst1);
                    _Run_chunked_parallel_work(_Hw_threads, _Operation);
                    _Seek_wrapped(_First1, _Operation._Results._Get_result());
                    return _First1;
                    } catch (const _Parallelism_resources_exhausted&) {
                    
                    }
                }
            }
        }
    }

    _Seek_wrapped(_First1, ::std:: find_end(_UFirst1, _ULast1, _UFirst2, _ULast2, _Pass_fn(_Pred)));
    return _First1;
}

template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> >
[[nodiscard]] _FwdIt1 find_first_of(_ExPo&& _Exec, const _FwdIt1 _First1, _FwdIt1 _Last1, const _FwdIt2 _First2,
    const _FwdIt2 _Last2, _Pr _Pred) noexcept  {
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    using _UFwdIt1 = _Unwrapped_t<const _FwdIt1&>;
    _Adl_verify_range(_First1, _Last1);
    _Adl_verify_range(_First2, _Last2);
    const auto _UFirst2 = _Get_unwrapped(_First2);
    const auto _ULast2  = _Get_unwrapped(_Last2);
    if (_UFirst2 == _ULast2) {
        return _Last1;
    }

    auto _Pass_pred = _Pass_fn(_Pred);
    _Seek_wrapped(_Last1, _Find_parallel_unchecked(::std:: forward<_ExPo>(_Exec), _Get_unwrapped(_First1),
                              _Get_unwrapped(_Last1), [=](const _UFwdIt1 _LFirst1, const _UFwdIt1 _LLast1) {
                                  return ::std:: find_first_of(_LFirst1, _LLast1, _UFirst2, _ULast2, _Pass_pred);
                              }));
    return _Last1;
}

template <class _FwdIt, class _Pr>
struct _Static_partitioned_adjacent_find2 {
    _Static_partition_team<_Iter_diff_t<_FwdIt>> _Team;
    _Static_partition_range<_FwdIt> _Basis;
    _Parallel_find_results<_FwdIt> _Results;
    _Pr _Pred;

    _Static_partitioned_adjacent_find2(
        const size_t _Hw_threads, const _Iter_diff_t<_FwdIt> _Count, const _FwdIt _Last, const _Pr _Pred_)
        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis{}, _Results{_Last}, _Pred{_Pred_} {}

    _Cancellation_status _Process_chunk() {
        if (_Results._Complete()) {
            return _Cancellation_status::_Canceled;
        }

        const auto _Key = _Team._Get_next_key();
        if (!_Key) {
            return _Cancellation_status::_Canceled;
        }
        

        const auto _Chunk_number = _Key._Chunk_number;
        const auto _Range        = _Basis._Get_chunk(_Key);
        
        
        auto _First = _Range._First;
        for (auto _Next = _First; _First != _Range._Last; _First = _Next) {
            ++_Next;
            if (_Pred(*_First, *_Next)) { 
                _Results._Imbue(_Chunk_number, _First);
                return _Cancellation_status::_Canceled;
            }
        }

        return _Cancellation_status::_Running;
    }

    static void __stdcall _Threadpool_callback(
        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept  {
        _Run_available_chunked_work(*static_cast<_Static_partitioned_adjacent_find2*>(_Context));
    }
};

template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> >
[[nodiscard]] _FwdIt adjacent_find(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept  {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
        if (_Hw_threads > 1) {
            const auto _Count = static_cast<_Iter_diff_t<_FwdIt>>(::std:: distance(_UFirst, _ULast) - 1);
            if (_Count >= 2) {
                try {
                _Static_partitioned_adjacent_find2 _Operation{_Hw_threads, _Count, _ULast, _Pass_fn(_Pred)};
                _Operation._Basis._Populate(_Operation._Team, _UFirst);
                _Run_chunked_parallel_work(_Hw_threads, _Operation);
                _Seek_wrapped(_Last, _Operation._Results._Get_result());
                return _Last;
                } catch (const _Parallelism_resources_exhausted&) {
                
                }
            }
        }
    }

    _Seek_wrapped(_Last, ::std:: adjacent_find(_UFirst, _ULast, _Pass_fn(_Pred)));
    return _Last;
}

template <class _FwdIt, class _Pr>
struct _Static_partitioned_count_if2 {
    using _Diff = _Iter_diff_t<_FwdIt>;
    _Static_partition_team<_Diff> _Team;
    _Static_partition_range<_FwdIt> _Basis;
    _Pr _Pred;
    atomic<_Diff> _Results;

    _Static_partitioned_count_if2(const _Diff _Count, const size_t _Chunks, const _FwdIt _First, const _Pr _Pred_)
        : _Team{_Count, _Chunks}, _Basis{}, _Pred{_Pred_}, _Results{} {
        _Basis._Populate(_Team, _First);
    }

    _Diff _Process_chunks() {
        _Diff _Result{};
        while (const auto _Key = _Team._Get_next_key()) {
            const auto _Range = _Basis._Get_chunk(_Key);
            _Result += ::std:: count_if(_Range._First, _Range._Last, _Pred);
        }

        return _Result;
    }

    static void __stdcall _Threadpool_callback(
        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept  {
        const auto _This = static_cast<_Static_partitioned_count_if2*>(_Context);
        _This->_Results.fetch_add(_This->_Process_chunks(), memory_order_relaxed);
    }
};

template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> >
[[nodiscard]] _Iter_diff_t<_FwdIt> count_if(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept
 {
    
    static_assert(_Is_fwd_iter_v<_FwdIt>, "Parallel algorithms require forward iterators or stronger.");
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
        if (_Hw_threads > 1) {
            const auto _Count = ::std:: distance(_UFirst, _ULast);
            if (_Count >= 2) {
                const auto _Chunks = _Get_chunked_work_chunk_count(_Hw_threads, _Count);
                try {
                _Static_partitioned_count_if2 _Operation{_Count, _Chunks, _UFirst, _Pass_fn(_Pred)};
                _Iter_diff_t<_FwdIt> _Foreground_count;
                {
                    const _Work_ptr _Work{_Operation};
                    
                    _Work._Submit_for_chunks(_Hw_threads, _Chunks);
                    _Foreground_count = _Operation._Process_chunks();
                } 

                return _Operation._Results.load(memory_order_relaxed) + _Foreground_count;
                } catch (const _Parallelism_resources_exhausted&) {
                
                }
            }
        }
    }

    return ::std:: count_if(_UFirst, _ULast, _Pass_fn(_Pred));
}

template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> >
[[nodiscard]] _Iter_diff_t<_FwdIt> count(_ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last, const _Ty& _Val) noexcept
 {
    
    static_assert(_Is_fwd_iter_v<_FwdIt>, "Parallel algorithms require forward iterators or stronger.");
    _Adl_verify_range(_First, _Last);
    return ::std:: count_if(::std:: forward<_ExPo>(_Exec), _Get_unwrapped(_First), _Get_unwrapped(_Last),
        [&_Val](auto&& _Iter_val) { return ::std:: forward<decltype(_Iter_val)>(_Iter_val) == _Val; });
}

template <class _FwdIt1, class _FwdIt2,
    bool = _Use_atomic_iterator<_Unwrapped_t<const _FwdIt1&>>&& _Is_random_iter_v<_FwdIt2>,
    bool = _Use_atomic_iterator<_Unwrapped_t<const _FwdIt2&>>&& _Is_random_iter_v<_FwdIt1>>
struct _Static_partitioned_mismatch_results;

template <class _FwdIt1, class _FwdIt2, bool _Unused>
struct _Static_partitioned_mismatch_results<_FwdIt1, _FwdIt2, true, _Unused> {
    
    _Parallel_choose_min_result<_FwdIt1> _Storage;

    _Static_partitioned_mismatch_results(const _FwdIt1 _Last1, const _Unwrapped_t<const _FwdIt2&>&)
        : _Storage(_Last1) {}

    void _Imbue(const size_t _Chunk_number, const _FwdIt1 _First1, const _Unwrapped_t<const _FwdIt2&>&) {
        _Storage._Imbue(_Chunk_number, _First1);
    }

    pair<_FwdIt1, _FwdIt2> _Get_result(const _FwdIt1 _First1, const _FwdIt2 _First2) const {
        const _FwdIt1 _Result1 = _Storage._Get_result();
        return {_Result1, _First2 + static_cast<_Iter_diff_t<_FwdIt2>>(_Result1 - _First1)};
    }
};

template <class _FwdIt1, class _FwdIt2>
struct _Static_partitioned_mismatch_results<_FwdIt1, _FwdIt2, false, true> {
    
    _Parallel_choose_min_result<_FwdIt2> _Storage;

    _Static_partitioned_mismatch_results(const _Unwrapped_t<const _FwdIt1&>&, const _FwdIt2 _Last2)
        : _Storage(_Last2) {}

    void _Imbue(const size_t _Chunk_number, const _Unwrapped_t<const _FwdIt1&>&, const _FwdIt2 _First2) {
        _Storage._Imbue(_Chunk_number, _First2);
    }

    pair<_FwdIt1, _FwdIt2> _Get_result(const _FwdIt1 _First1, const _FwdIt2 _First2) const {
        const _FwdIt2 _Result2 = _Storage._Get_result();
        return {_First1 + static_cast<_Iter_diff_t<_FwdIt1>>(_Result2 - _First2), _Result2};
    }
};

template <class _FwdIt1, class _FwdIt2>
struct _Static_partitioned_mismatch_results<_FwdIt1, _FwdIt2, false, false> {
    
    using _UFwdIt1 = _Unwrapped_t<const _FwdIt1&>;
    using _UFwdIt2 = _Unwrapped_t<const _FwdIt2&>;
    _Parallel_choose_min_chunk<pair<_UFwdIt1, _UFwdIt2>> _Storage;

    _Static_partitioned_mismatch_results(const _UFwdIt1 _Last1, const _UFwdIt2 _Last2) : _Storage({_Last1, _Last2}) {}

    void _Imbue(const size_t _Chunk_number, const _UFwdIt1 _First1, const _UFwdIt2 _First2) {
        _Storage._Imbue(_Chunk_number, {_First1, _First2});
    }

    pair<_FwdIt1, _FwdIt2> _Get_result(_FwdIt1 _First1, _FwdIt2 _First2) const {
        const auto _Result = _Storage._Get_result();
        _Seek_wrapped(_First2, _Result.second);
        _Seek_wrapped(_First1, _Result.first);
        return {_First1, _First2};
    }
};

template <class _FwdIt1, class _FwdIt2, class _Pr>
struct _Static_partitioned_mismatch2 {
    using _Diff = _Common_diff_t<_FwdIt1, _FwdIt2>;
    _Static_partition_team<_Diff> _Team;
    _Static_partition_range<_FwdIt1, _Diff> _Basis1;
    _Static_partition_range<_FwdIt2, _Diff> _Basis2;
    _Static_partitioned_mismatch_results<_FwdIt1, _FwdIt2> _Results;
    _Pr _Pred;

    _Static_partitioned_mismatch2(
        const size_t _Hw_threads, const _Diff _Count, const _FwdIt1 _First1, const _FwdIt2 _First2, const _Pr _Pred_)
        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis1{}, _Basis2{},
          _Results(
              _Get_unwrapped(_Basis1._Populate(_Team, _First1)), _Get_unwrapped(_Basis2._Populate(_Team, _First2))),
          _Pred(_Pred_) {}

    _Cancellation_status _Process_chunk() {
        if (_Results._Storage._Complete()) {
            return _Cancellation_status::_Canceled;
        }

        const auto _Key = _Team._Get_next_key();
        if (!_Key) {
            return _Cancellation_status::_Canceled;
        }
        

        const auto _Chunk_number = _Key._Chunk_number;
        const auto _Range1       = _Basis1._Get_chunk(_Key);
        auto _First1             = _Range1._First;
        auto _First2             = _Basis2._Get_chunk(_Key)._First;
        for (;;) {
            if (_First1 == _Range1._Last) {
                return _Cancellation_status::_Running;
            }

            if (!_Pred(*_First1, *_First2)) {
                _Results._Imbue(_Chunk_number, _First1, _First2);
                return _Cancellation_status::_Canceled;
            }

            ++_First1;
            ++_First2;
        }
    }

    static void __stdcall _Threadpool_callback(
        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept  {
        _Run_available_chunked_work(*static_cast<_Static_partitioned_mismatch2*>(_Context));
    }
};

#pragma warning(push)
#pragma warning(disable : 4868) 
                                
template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> >
[[nodiscard]] pair<_FwdIt1, _FwdIt2> mismatch(
    _ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Pr _Pred) noexcept  {
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    _Adl_verify_range(_First1, _Last1);
    const auto _UFirst1 = _Get_unwrapped(_First1);
    const auto _ULast1  = _Get_unwrapped(_Last1);
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
        if (_Hw_threads > 1) {
            const auto _Count   = ::std:: distance(_UFirst1, _ULast1);
            const auto _UFirst2 = _Get_unwrapped_n(_First2, _Count);
            if (_Count >= 2) {
                try {
                _Static_partitioned_mismatch2 _Operation{_Hw_threads, _Count, _UFirst1, _UFirst2, _Pass_fn(_Pred)};
                _Run_chunked_parallel_work(_Hw_threads, _Operation);
                const auto _Result = _Operation._Results._Get_result(_UFirst1, _UFirst2);
                _Seek_wrapped(_First2, _Result.second);
                _Seek_wrapped(_First1, _Result.first);
                return {_First1, _First2};
                } catch (const _Parallelism_resources_exhausted&) {
                
                }
            }

            const auto _Result = ::std:: mismatch(_UFirst1, _ULast1, _UFirst2, _Pass_fn(_Pred));
            _Seek_wrapped(_First2, _Result.second);
            _Seek_wrapped(_First1, _Result.first);
            return {_First1, _First2};
        }
    }

    const auto _Result = ::std:: mismatch(
        _UFirst1, _ULast1, _Get_unwrapped_n(_First2, _Idl_distance<_FwdIt1>(_UFirst1, _ULast1)), _Pass_fn(_Pred));
    _Seek_wrapped(_First2, _Result.second);
    _Seek_wrapped(_First1, _Result.first);
    return {_First1, _First2};
}
#pragma warning(pop)

template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> >
[[nodiscard]] pair<_FwdIt1, _FwdIt2> mismatch(
    _ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred) noexcept  {
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    _Adl_verify_range(_First1, _Last1);
    _Adl_verify_range(_First2, _Last2);
    const auto _UFirst1 = _Get_unwrapped(_First1);
    const auto _ULast1  = _Get_unwrapped(_Last1);
    const auto _UFirst2 = _Get_unwrapped(_First2);
    const auto _ULast2  = _Get_unwrapped(_Last2);
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
        if (_Hw_threads > 1) {
            const auto _Count = static_cast<_Iter_diff_t<_FwdIt1>>(_Distance_min(_UFirst1, _ULast1, _UFirst2, _ULast2));
            if (_Count >= 2) {
                try {
                _Static_partitioned_mismatch2 _Operation{_Hw_threads, _Count, _UFirst1, _UFirst2, _Pass_fn(_Pred)};
                _Run_chunked_parallel_work(_Hw_threads, _Operation);
                const auto _Result = _Operation._Results._Get_result(_UFirst1, _UFirst2);
                _Seek_wrapped(_First2, _Result.second);
                _Seek_wrapped(_First1, _Result.first);
                return {_First1, _First2};
                } catch (const _Parallelism_resources_exhausted&) {
                
                }
            }
        }
    }

    const auto _Result = ::std:: mismatch(_UFirst1, _ULast1, _UFirst2, _ULast2, _Pass_fn(_Pred));
    _Seek_wrapped(_First2, _Result.second);
    _Seek_wrapped(_First1, _Result.first);
    return {_First1, _First2};
}

template <class _FwdIt1, class _FwdIt2, class _Pr>
struct _Static_partitioned_equal2 {
    using _Diff = _Common_diff_t<_FwdIt1, _FwdIt2>;
    _Static_partition_team<_Diff> _Team;
    _Static_partition_range<_FwdIt1, _Diff> _Basis1;
    _Static_partition_range<_FwdIt2, _Diff> _Basis2;
    _Pr _Pred;
    _Cancellation_token _Cancel_token;

    _Static_partitioned_equal2(const size_t _Hw_threads, const _Diff _Count, _Pr _Pred_, const _FwdIt1&, const _FwdIt2&)
        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis1{}, _Basis2{},
          _Pred(_Pred_), _Cancel_token{} {}

    _Cancellation_status _Process_chunk() {
        if (_Cancel_token._Is_canceled()) {
            return _Cancellation_status::_Canceled;
        }

        const auto _Key = _Team._Get_next_key();
        if (!_Key) {
            return _Cancellation_status::_Canceled;
        }
        

        const auto _Range1       = _Basis1._Get_chunk(_Key);
        const auto _Range2_first = _Basis2._Get_chunk(_Key)._First;
        if (::std:: equal(_Range1._First, _Range1._Last, _Range2_first, _Pred)) {
            return _Cancellation_status::_Running;
        }

        _Cancel_token._Cancel();
        return _Cancellation_status::_Canceled;
    }

    static void __stdcall _Threadpool_callback(
        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept  {
        _Run_available_chunked_work(*static_cast<_Static_partitioned_equal2*>(_Context));
    }
};

template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> >
[[nodiscard]] bool equal(_ExPo&&, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2, _Pr _Pred) noexcept
 {
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    _Adl_verify_range(_First1, _Last1);
    const auto _UFirst1 = _Get_unwrapped(_First1);
    const auto _ULast1  = _Get_unwrapped(_Last1);
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
        if (_Hw_threads > 1) {
            const auto _Count   = ::std:: distance(_UFirst1, _ULast1);
            const auto _UFirst2 = _Get_unwrapped_n(_First2, _Count);
            if (_Count >= 2) {
                try {
                _Static_partitioned_equal2 _Operation{_Hw_threads, _Count, _Pass_fn(_Pred), _UFirst1, _UFirst2};
                _Operation._Basis1._Populate(_Operation._Team, _UFirst1);
                _Operation._Basis2._Populate(_Operation._Team, _UFirst2);
                _Run_chunked_parallel_work(_Hw_threads, _Operation);
                return !_Operation._Cancel_token._Is_canceled_relaxed();
                } catch (const _Parallelism_resources_exhausted&) {
                
                }
            }

            return ::std:: equal(_UFirst1, _ULast1, _UFirst2, _Pass_fn(_Pred));
        }
    }

    return ::std:: equal(_UFirst1, _ULast1, _First2, _Pass_fn(_Pred));
}

template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Pr, _Enable_if_execution_policy_t<_ExPo> >
[[nodiscard]] bool equal(_ExPo&&, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2, const _FwdIt2 _Last2,
    _Pr _Pred) noexcept  {
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    _Adl_verify_range(_First1, _Last1);
    _Adl_verify_range(_First2, _Last2);
    const auto _UFirst1 = _Get_unwrapped(_First1);
    const auto _ULast1  = _Get_unwrapped(_Last1);
    const auto _UFirst2 = _Get_unwrapped(_First2);
    const auto _ULast2  = _Get_unwrapped(_Last2);
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
        if (_Hw_threads > 1) {
            const auto _Count = _Distance_any(_UFirst1, _ULast1, _UFirst2, _ULast2);
            if (_Count >= 2) {
                try {
                _Static_partitioned_equal2 _Operation{_Hw_threads, _Count, _Pass_fn(_Pred), _UFirst1, _UFirst2};
                if (!_Operation._Basis1._Populate(_Operation._Team, _UFirst1, _ULast1)) {
                    
                    return false;
                }

                if (!_Operation._Basis2._Populate(_Operation._Team, _UFirst2, _ULast2)) {
                    
                    return false;
                }

                _Run_chunked_parallel_work(_Hw_threads, _Operation);
                return !_Operation._Cancel_token._Is_canceled_relaxed();
                } catch (const _Parallelism_resources_exhausted&) {
                
                }
            }
        }
    }

    return ::std:: equal(_UFirst1, _ULast1, _UFirst2, _ULast2, _Pass_fn(_Pred));
}

template <class _FwdItHaystack, class _FwdItPat, class _Pr>
struct _Static_partitioned_search2 {
    _Static_partition_team<_Iter_diff_t<_FwdItHaystack>> _Team;
    _Static_partition_range<_FwdItHaystack> _Basis;
    _Parallel_find_results<_FwdItHaystack> _Results;
    _FwdItPat _First2;
    _FwdItPat _Last2;
    _Pr _Pred;

    _Static_partitioned_search2(const size_t _Hw_threads, const _Iter_diff_t<_FwdItHaystack> _Count,
        const _FwdItHaystack _First1, const _FwdItHaystack _Last1, const _FwdItPat _First2_, const _FwdItPat _Last2_,
        _Pr _Pred_)
        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis{}, _Results(_Last1),
          _First2(_First2_), _Last2(_Last2_), _Pred(_Pred_) {
        _Basis._Populate(_Team, _First1);
    }

    _Cancellation_status _Process_chunk() {
        if (_Results._Complete()) {
            return _Cancellation_status::_Canceled;
        }

        const auto _Key = _Team._Get_next_key();
        if (!_Key) {
            return _Cancellation_status::_Canceled;
        }
        

        const auto _Range = _Basis._Get_chunk(_Key);
        for (auto _Candidate = _Range._First; _Candidate != _Range._Last; ++_Candidate) {
            if (_Equal_rev_pred_unchecked(_Candidate, _First2, _Last2, _Pred)) {
                _Results._Imbue(_Key._Chunk_number, _Candidate);
                return _Cancellation_status::_Canceled;
            }
        }

        return _Cancellation_status::_Running;
    }

    static void __stdcall _Threadpool_callback(
        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept  {
        _Run_available_chunked_work(*static_cast<_Static_partitioned_search2*>(_Context));
    }
};

template <class _ExPo, class _FwdItHaystack, class _FwdItPat, class _Pr, _Enable_if_execution_policy_t<_ExPo> >
[[nodiscard]] _FwdItHaystack search(_ExPo&&, const _FwdItHaystack _First1, _FwdItHaystack _Last1, const _FwdItPat _First2,
    const _FwdItPat _Last2, _Pr _Pred) noexcept  {
    
    _Adl_verify_range(_First2, _Last2);
    const auto _UFirst2 = _Get_unwrapped(_First2);
    const auto _ULast2  = _Get_unwrapped(_Last2);
    if (_UFirst2 == _ULast2) {
        return _First1;
    }

    _Adl_verify_range(_First1, _Last1);
    const auto _UFirst1 = _Get_unwrapped(_First1);
    const auto _ULast1  = _Get_unwrapped(_Last1);

    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
        if (_Hw_threads > 1) {
            _Iter_diff_t<_FwdItHaystack> _Count;
            if constexpr (_Is_random_iter_v<_FwdItHaystack> && _Is_random_iter_v<_FwdItPat>) {
                const auto _HaystackDist = _ULast1 - _UFirst1;
                const auto _NeedleDist   = _ULast2 - _UFirst2;
                if (_NeedleDist > _HaystackDist) { 
                    return _Last1;
                }

                
                _Count = static_cast<_Iter_diff_t<_FwdItHaystack>>(_HaystackDist - _NeedleDist + 1);
            } else {
                auto _UFirst1c = _UFirst1;
                auto _UFirst2c = _UFirst2;
                for (;;) {
                    if (_UFirst1c == _ULast1) {
                        
                        
                        return _Last1;
                    }

                    ++_UFirst2c;
                    if (_UFirst2c == _ULast2) {
                        _Count = ::std:: distance(_UFirst1c, _ULast1);
                        break;
                    }

                    ++_UFirst1c;
                }
            }

            if (_Count == 1) {
                
                
                if (_Equal_rev_pred_unchecked(_UFirst1, _UFirst2, _ULast2, _Pass_fn(_Pred))) {
                    return _First1;
                }

                return _Last1;
            }

            try {
            _Static_partitioned_search2 _Operation{
                _Hw_threads, _Count, _UFirst1, _ULast1, _UFirst2, _ULast2, _Pass_fn(_Pred)};
            _Run_chunked_parallel_work(_Hw_threads, _Operation);
            _Seek_wrapped(_Last1, _Operation._Results._Get_result());
            return _Last1;
            } catch (const _Parallelism_resources_exhausted&) {
            
            }
        }
    }

    _Seek_wrapped(_Last1, ::std:: search(_UFirst1, _ULast1, _UFirst2, _ULast2, _Pass_fn(_Pred)));
    return _Last1;
}

template <class _FwdIt, class _Ty, class _Pr>
struct _Static_partitioned_search_n2 {
    _Static_partition_team<_Iter_diff_t<_FwdIt>> _Team;
    _Static_partition_range<_FwdIt> _Basis;
    _Parallel_find_results<_FwdIt> _Results;
    _Iter_diff_t<_FwdIt> _Target_count;
    const _Ty& _Val;
    _Pr _Pred;

    _Static_partitioned_search_n2(const size_t _Hw_threads, const _Iter_diff_t<_FwdIt> _Candidates, const _FwdIt _First,
        const _FwdIt _Last, const _Iter_diff_t<_FwdIt> _Target_count_, const _Ty& _Val_, _Pr _Pred_)
        : _Team{_Candidates, _Get_chunked_work_chunk_count(_Hw_threads, _Candidates)}, _Basis{}, _Results(_Last),
          _Target_count(_Target_count_), _Val(_Val_), _Pred(_Pred_) {
        _Basis._Populate(_Team, _First);
    }

    _Cancellation_status _Process_chunk() {
        if (_Results._Complete()) {
            return _Cancellation_status::_Canceled;
        }

        const auto _Key = _Team._Get_next_key();
        if (!_Key) {
            return _Cancellation_status::_Canceled;
        }
        

        const auto _Range = _Basis._Get_chunk(_Key);

        
        const _Iter_diff_t<_FwdIt> _Overshoot = _Target_count - 1;
        const auto _Serial_last               = ::std:: next(_Range._Last, _Overshoot);

        
        const auto _Candidate = ::std:: search_n(_Range._First, _Serial_last, _Target_count, _Val, _Pred);
        if (_Candidate == _Serial_last) {
            return _Cancellation_status::_Running;
        }

        _Results._Imbue(_Key._Chunk_number, _Candidate);
        return _Cancellation_status::_Canceled;
    }

    static void __stdcall _Threadpool_callback(
        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept  {
        _Run_available_chunked_work(*static_cast<_Static_partitioned_search_n2*>(_Context));
    }
};

template <class _ExPo, class _FwdIt, class _Diff, class _Ty, class _Pr, _Enable_if_execution_policy_t<_ExPo> >
[[nodiscard]] _FwdIt search_n(_ExPo&&, const _FwdIt _First, _FwdIt _Last, const _Diff _Count_raw, const _Ty& _Val,
    _Pr _Pred) noexcept  {
    
    const _Algorithm_int_t<_Diff> _Count = _Count_raw;
    if (_Count <= 0) {
        _Last = _First;
        return _Last;
    }

    if (static_cast<uintmax_t>(_Count) > static_cast<uintmax_t>((numeric_limits<_Iter_diff_t<_FwdIt>>::max)())) {
        
        return _Last;
    }

    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
        if (_Hw_threads > 1) {
            const auto _Haystack_count = ::std:: distance(_UFirst, _ULast);
            if (_Count > _Haystack_count) {
                return _Last;
            }

            
            const auto _Candidates = static_cast<_Iter_diff_t<_FwdIt>>(_Haystack_count - _Count + 1);
            try {
            _Static_partitioned_search_n2 _Operation{_Hw_threads, _Candidates, _UFirst, _ULast,
                static_cast<_Iter_diff_t<_FwdIt>>(_Count), _Val, _Pass_fn(_Pred)};
            _Run_chunked_parallel_work(_Hw_threads, _Operation);
            _Seek_wrapped(_Last, _Operation._Results._Get_result());
            return _Last;
            } catch (const _Parallelism_resources_exhausted&) {
            
            }
        }
    }

    _Seek_wrapped(_Last, ::std:: search_n(_UFirst, _ULast, _Count, _Val, _Pass_fn(_Pred)));
    return _Last;
}

template <class _FwdIt1, class _FwdIt2, class _Fn>
struct _Static_partitioned_unary_transform2 {
    using _Diff = _Common_diff_t<_FwdIt1, _FwdIt2>;
    _Static_partition_team<_Diff> _Team;
    _Static_partition_range<_FwdIt1, _Diff> _Source_basis;
    _Static_partition_range<_FwdIt2, _Diff> _Dest_basis;
    _Fn _Func;

    _Static_partitioned_unary_transform2(
        const size_t _Hw_threads, const _Diff _Count, const _FwdIt1 _First, _Fn _Fx, const _FwdIt2&)
        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Source_basis{}, _Dest_basis{},
          _Func(_Fx) {
        _Source_basis._Populate(_Team, _First);
    }

    _Cancellation_status _Process_chunk() {
        const auto _Key = _Team._Get_next_key();
        if (_Key) {
            const auto _Source = _Source_basis._Get_chunk(_Key);
            ::std:: transform(_Source._First, _Source._Last, _Dest_basis._Get_chunk(_Key)._First, _Func);
            return _Cancellation_status::_Running;
        }

        return _Cancellation_status::_Canceled;
    }

    static void __stdcall _Threadpool_callback(
        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept  {
        _Run_available_chunked_work(*static_cast<_Static_partitioned_unary_transform2*>(_Context));
    }
};

template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Fn, _Enable_if_execution_policy_t<_ExPo> >
_FwdIt2 transform(_ExPo&&, const _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _Fn _Func) noexcept
 {
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
        if (_Hw_threads > 1) { 
            const auto _Count = ::std:: distance(_UFirst, _ULast);
            const auto _UDest = _Get_unwrapped_n(_Dest, _Count);
            if (_Count >= 2) { 
                try {
                _Static_partitioned_unary_transform2 _Operation{_Hw_threads, _Count, _UFirst, _Pass_fn(_Func), _UDest};
                _Seek_wrapped(_Dest, _Operation._Dest_basis._Populate(_Operation._Team, _UDest));
                _Run_chunked_parallel_work(_Hw_threads, _Operation);
                return _Dest;
                } catch (const _Parallelism_resources_exhausted&) {
                
                }
            }

            _Seek_wrapped(_Dest, ::std:: transform(_UFirst, _ULast, _UDest, _Pass_fn(_Func)));
            return _Dest;
        } else {
            _Seek_wrapped(
                _Dest, ::std:: transform(_UFirst, _ULast, _Get_unwrapped_n(_Dest, _Idl_distance<_FwdIt1>(_UFirst, _ULast)),
                           _Pass_fn(_Func)));
            return _Dest;
        }
    } else {
        _Seek_wrapped(_Dest, ::std:: transform(_UFirst, _ULast,
                                 _Get_unwrapped_n(_Dest, _Idl_distance<_FwdIt1>(_UFirst, _ULast)), _Pass_fn(_Func)));
        return _Dest;
    }
}

template <class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Fn>
struct _Static_partitioned_binary_transform2 {
    using _Diff = _Common_diff_t<_FwdIt1, _FwdIt2, _FwdIt3>;
    _Static_partition_team<_Diff> _Team;
    _Static_partition_range<_FwdIt1, _Diff> _Source1_basis;
    _Static_partition_range<_FwdIt2, _Diff> _Source2_basis;
    _Static_partition_range<_FwdIt3, _Diff> _Dest_basis;
    _Fn _Func;

    _Static_partitioned_binary_transform2(
        const size_t _Hw_threads, const _Diff _Count, _FwdIt1 _First1, _FwdIt2 _First2, _Fn _Fx, const _FwdIt3&)
        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Source1_basis{}, _Source2_basis{},
          _Dest_basis{}, _Func(_Fx) {
        _Source1_basis._Populate(_Team, _First1);
        _Source2_basis._Populate(_Team, _First2);
    }

    _Cancellation_status _Process_chunk() {
        const auto _Key = _Team._Get_next_key();
        if (_Key) {
            const auto _Source1 = _Source1_basis._Get_chunk(_Key);
            ::std:: transform(_Source1._First, _Source1._Last, _Source2_basis._Get_chunk(_Key)._First,
                _Dest_basis._Get_chunk(_Key)._First, _Func);
            return _Cancellation_status::_Running;
        }

        return _Cancellation_status::_Canceled;
    }

    static void __stdcall _Threadpool_callback(
        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept  {
        _Run_available_chunked_work(*static_cast<_Static_partitioned_binary_transform2*>(_Context));
    }
};

#pragma warning(push)
#pragma warning(disable : 4868) 
                                
template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Fn,
    _Enable_if_execution_policy_t<_ExPo> >
_FwdIt3 transform(_ExPo&&, const _FwdIt1 _First1, const _FwdIt1 _Last1, const _FwdIt2 _First2, _FwdIt3 _Dest,
    _Fn _Func) noexcept  {
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt3>, "Parallel algorithms require forward iterators or stronger.");
    _Adl_verify_range(_First1, _Last1);
    const auto _UFirst1 = _Get_unwrapped(_First1);
    const auto _ULast1  = _Get_unwrapped(_Last1);
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
        if (_Hw_threads > 1) { 
            const auto _Count   = ::std:: distance(_UFirst1, _ULast1);
            const auto _UFirst2 = _Get_unwrapped_n(_First2, _Count);
            const auto _UDest   = _Get_unwrapped_n(_Dest, _Count);
            if (_Count >= 2) { 
                try {
                _Static_partitioned_binary_transform2 _Operation{
                    _Hw_threads, _Count, _UFirst1, _UFirst2, _Pass_fn(_Func), _UDest};
                _Seek_wrapped(_Dest, _Operation._Dest_basis._Populate(_Operation._Team, _UDest));
                _Run_chunked_parallel_work(_Hw_threads, _Operation);
                return _Dest;
                } catch (const _Parallelism_resources_exhausted&) {
                
                }
            }

            _Seek_wrapped(_Dest, ::std:: transform(_UFirst1, _ULast1, _UFirst2, _UDest, _Pass_fn(_Func)));
            return _Dest;
        } else {
            const auto _Count = _Idl_distance<_FwdIt1>(_UFirst1, _ULast1);
            _Seek_wrapped(_Dest, ::std:: transform(_UFirst1, _ULast1, _Get_unwrapped_n(_First2, _Count),
                                     _Get_unwrapped_n(_Dest, _Count), _Pass_fn(_Func)));
            return _Dest;
        }
    } else {
        const auto _Count = _Idl_distance<_FwdIt1>(_UFirst1, _ULast1);
        _Seek_wrapped(_Dest, ::std:: transform(_UFirst1, _ULast1, _Get_unwrapped_n(_First2, _Count),
                                 _Get_unwrapped_n(_Dest, _Count), _Pass_fn(_Func)));
        return _Dest;
    }
}
#pragma warning(pop)

template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> >
void replace(_ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last, const _Ty& _Oldval, const _Ty& _Newval) noexcept
 {
    
    static_assert(_Is_fwd_iter_v<_FwdIt>, "Parallel algorithms require forward iterators or stronger.");
    ::std:: for_each(::std:: forward<_ExPo>(_Exec), _First, _Last, [&](auto&& _Value) {
        if (::std:: forward<decltype(_Value)>(_Value) == _Oldval) {
            ::std:: forward<decltype(_Value)>(_Value) = _Newval;
        }
    });
}

template <class _ExPo, class _FwdIt, class _Pr, class _Ty, _Enable_if_execution_policy_t<_ExPo> >
void replace_if(_ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last, _Pr _Pred, const _Ty& _Val) noexcept
 {
    
    static_assert(_Is_fwd_iter_v<_FwdIt>, "Parallel algorithms require forward iterators or stronger.");
    ::std:: for_each(
        ::std:: forward<_ExPo>(_Exec), _First, _Last, [&_Val, _Lambda_pred = _Pass_fn(_Pred)](auto&& _Value) mutable {
            if (_Lambda_pred(::std:: forward<decltype(_Value)>(_Value))) {
                ::std:: forward<decltype(_Value)>(_Value) = _Val;
            }
        });
}

template <class _FwdIt, class _Pr>
_FwdIt _Remove_move_if_unchecked(_FwdIt _First, const _FwdIt _Last, _FwdIt _Dest, _Pr _Pred) {
    
    for (; _First != _Last; ++_First) {
        if (!_Pred(*_First)) {
            *_Dest = ::std:: move(*_First);
            ++_Dest;
        }
    }

    return _Dest;
}

template <class _FwdIt, class _Pr>
struct _Static_partitioned_remove_if2 {
    enum class _Chunk_state : unsigned char {
        _Serial, 
        _Merging, 
                  
                  
        _Moving, 
                 
        _Done 

        
    };

#pragma warning(push)
#pragma warning(disable : 4324) 
    struct alignas(hardware_destructive_interference_size) alignas(_FwdIt) _Chunk_local_data {
        atomic<_Chunk_state> _State;
        _FwdIt _New_end;
    };
#pragma warning(pop)

    _Static_partition_team<_Iter_diff_t<_FwdIt>> _Team;
    _Static_partition_range<_FwdIt> _Basis;
    _Pr _Pred;
    _Parallel_vector<_Chunk_local_data> _Chunk_locals;
    _FwdIt _Results;

    _Static_partitioned_remove_if2(
        const size_t _Hw_threads, const _Iter_diff_t<_FwdIt> _Count, const _FwdIt _First, const _Pr _Pred_)
        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis{}, _Pred{_Pred_},
          _Chunk_locals(_Team._Chunks), _Results{_First} {
        _Basis._Populate(_Team, _First);
    }

    _Cancellation_status _Process_chunk() {
        const auto _Key = _Team._Get_next_key();
        if (!_Key) {
            return _Cancellation_status::_Canceled;
        }

        
        auto _Merge_index = _Key._Chunk_number; 
        {
            auto& _Chunk_data = _Chunk_locals[_Merge_index];
            const auto _Range = _Basis._Get_chunk(_Key);
            if (_Merge_index == 0 || _Chunk_locals[_Merge_index - 1]._State.load() == _Chunk_state::_Done) {
                
                if (_Merge_index == 0 || _Results == _Range._First) {
                    _Results = ::std:: remove_if(_Range._First, _Range._Last, _Pred);
                } else {
                    _Results = _Remove_move_if_unchecked(_Range._First, _Range._Last, _Results, _Pred);
                }

                _Chunk_data._State.store(_Chunk_state::_Done);
                ++_Merge_index; 
            } else { 
                _Chunk_data._New_end = ::std:: remove_if(_Range._First, _Range._Last, _Pred);
                _Chunk_data._State.store(_Chunk_state::_Merging);
                if (_Chunk_locals[_Merge_index - 1]._State.load() != _Chunk_state::_Done) {
                    
                    return _Cancellation_status::_Running;
                }
            }
        }

        
        for (; _Merge_index != _Team._Chunks; ++_Merge_index) {
            auto& _Merge_chunk_data = _Chunk_locals[_Merge_index];
            auto _Expected          = _Chunk_state::_Merging;
            if (!_Merge_chunk_data._State.compare_exchange_strong(_Expected, _Chunk_state::_Moving)) {
                
                return _Cancellation_status::_Running;
            }

            const auto _Merge_first   = _Basis._Get_first(_Merge_index, _Team._Get_chunk_offset(_Merge_index));
            const auto _Merge_new_end = ::std:: exchange(_Merge_chunk_data._New_end, {});
            if (_Results == _Merge_first) { 
                _Results = _Merge_new_end;
            } else {
                _Results = _Move_unchecked(_Merge_first, _Merge_new_end, _Results);
            }

            _Merge_chunk_data._State.store(_Chunk_state::_Done);
        }

        return _Cancellation_status::_Canceled;
    }

    static void __stdcall _Threadpool_callback(
        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept  {
        _Run_available_chunked_work(*static_cast<_Static_partitioned_remove_if2*>(_Context));
    }
};

template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> >
[[nodiscard]] _FwdIt remove_if(_ExPo&&, _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept  {
    
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
        if (_Hw_threads > 1) {
            const auto _Count = ::std:: distance(_UFirst, _ULast);
            if (_Count >= 2) {
                try {
                _Static_partitioned_remove_if2 _Operation{_Hw_threads, _Count, _UFirst, _Pass_fn(_Pred)};
                _Run_chunked_parallel_work(_Hw_threads, _Operation);
                _Seek_wrapped(_First, _Operation._Results);
                return _First;
                } catch (const _Parallelism_resources_exhausted&) {
                
                }
            }
        }
    }

    _Seek_wrapped(_First, ::std:: remove_if(_UFirst, _ULast, _Pass_fn(_Pred)));
    return _First;
}

template <class _ExPo, class _FwdIt, class _Ty, _Enable_if_execution_policy_t<_ExPo> >
[[nodiscard]] _FwdIt remove(_ExPo&& _Exec, const _FwdIt _First, const _FwdIt _Last, const _Ty& _Val) noexcept
 {
    
    return ::std:: remove_if(::std:: forward<_ExPo>(_Exec), _First, _Last,
        [&_Val](auto&& _Lhs) { return ::std:: forward<decltype(_Lhs)>(_Lhs) == _Val; });
}

template <class _Diff>
struct _Sort_work_item_impl { 
    using difference_type = _Diff;

    _Diff _Offset;
    _Diff _Size;
    _Diff _Ideal;
};

template <class _RanIt>
using _Sort_work_item = _Sort_work_item_impl<_Iter_diff_t<_RanIt>>;

template <class _RanIt, class _Pr>
bool _Process_sort_work_item(const _RanIt _Basis, _Pr _Pred, _Sort_work_item<_RanIt>& _Wi,
    _Sort_work_item<_RanIt>& _Right_fork_wi, _Iter_diff_t<_RanIt>& _Work_complete) noexcept  {
    
    
    const auto _Size  = _Wi._Size;
    const auto _First = _Basis + _Wi._Offset;
    const auto _Last  = _First + _Size;
    const auto _Ideal = _Wi._Ideal;
    if (_Size <= _Isort_max<_RanIt>) {
        _Insertion_sort_unchecked(_First, _Last, _Pred);
        _Work_complete += _Size;
        return false;
    }

    if (0 < _Ideal) { 
        const auto _Mid = _Partition_by_median_guess_unchecked(_First, _Last, _Pred);
        const auto _New_ideal =
            static_cast<_Iter_diff_t<_RanIt>>(_Ideal / 2 + _Ideal / 4); 
        _Wi._Size      = _Mid.first - _First;
        _Wi._Ideal     = _New_ideal;
        _Right_fork_wi = {_Mid.second - _Basis, _Last - _Mid.second, _New_ideal};
        _Work_complete += _Mid.second - _Mid.first;
        return true;
    }

    
    _Make_heap_unchecked(_First, _Last, _Pred);
    _Sort_heap_unchecked(_First, _Last, _Pred);
    _Work_complete += _Size;
    return false;
}

template <class _RanIt, class _Pr>
void _Process_sort_queue(const _RanIt _Basis, _Pr _Pred, _Work_stealing_membership<_Sort_work_item<_RanIt>>& _My_ticket,
    _Sort_work_item<_RanIt>& _Wi) noexcept  {
    _Sort_work_item<_RanIt> _Right_fork_wi;
    do { 
        while (_Process_sort_work_item(_Basis, _Pred, _Wi, _Right_fork_wi, _My_ticket._Work_complete)) {
            try {
            _My_ticket._Push_bottom(_Right_fork_wi);
            } catch (const _Parallelism_resources_exhausted&) {
            
            const auto _First = _Basis + _Right_fork_wi._Offset;
            _Sort_unchecked(_First, _First + _Right_fork_wi._Size, _Right_fork_wi._Ideal, _Pred);
            _My_ticket._Work_complete += _Right_fork_wi._Size;
            }
        }
    } while (_My_ticket._Try_pop_bottom(_Wi));
}

template <class _RanIt, class _Pr>
struct _Sort_operation { 
    _RanIt _Basis;
    _Pr _Pred;
    _Work_stealing_team<_Sort_work_item<_RanIt>> _Team;

    _Sort_operation(_RanIt _First, _Pr _Pred_arg, size_t _Threads, _Iter_diff_t<_RanIt> _Count)
        : _Basis(_First), _Pred(_Pred_arg), _Team(_Threads, _Count) {}

    static void __stdcall _Threadpool_callback(
        __std_PTP_CALLBACK_INSTANCE, void* const _Context, const __std_PTP_WORK _Work) noexcept  {
        auto* const _This = static_cast<_Sort_operation*>(_Context);
        const auto _Basis = _This->_Basis;
        const auto _Pred  = _This->_Pred;
        auto& _Team       = _This->_Team;
        auto _My_ticket   = _Team._Join_team();
        _Sort_work_item<_RanIt> _Wi;
        for (;;) {
            switch (_My_ticket._Steal(_Wi)) {
            case _Steal_result::_Success:
                _Process_sort_queue(_Basis, _Pred, _My_ticket, _Wi);
                break;
            case _Steal_result::_Abort:
                _My_ticket._Leave();
                __std_submit_threadpool_work(_Work);
                return;
            case _Steal_result::_Done:
                return;
            }
        }
    }
};

template <class _ExPo, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> >
void sort(_ExPo&&, const _RanIt _First, const _RanIt _Last, _Pr _Pred) noexcept  {
    
    _Adl_verify_range(_First, _Last);
    const auto _UFirst                = _Get_unwrapped(_First);
    const auto _ULast                 = _Get_unwrapped(_Last);
    const _Iter_diff_t<_RanIt> _Ideal = _ULast - _UFirst;
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        size_t _Threads;
        if (_Ideal > _ISORT_MAX && (_Threads = __std_parallel_algorithms_hw_threads()) > 1) {
            
            try {
            _Sort_operation _Operation(_UFirst, _Pass_fn(_Pred), _Threads, _Ideal); 
            const _Work_ptr _Work{_Operation}; 
            auto& _Team     = _Operation._Team;
            auto _My_ticket = _Team._Join_team();
            _Work._Submit(_Threads - 1);
            _Sort_work_item<_RanIt> _Wi{0, _Ideal, _Ideal};
            _Steal_result _Sr;
            do {
                _Process_sort_queue(_UFirst, _Pass_fn(_Pred), _My_ticket, _Wi);

                do {
                    _Sr = _My_ticket._Steal(_Wi);
                } while (_Sr == _Steal_result::_Abort);
            } while (_Sr != _Steal_result::_Done);
            return;
            } catch (const _Parallelism_resources_exhausted&) {
            
            }
        }
    }

    _Sort_unchecked(_UFirst, _ULast, _Ideal, _Pass_fn(_Pred));
}

template <class _Ty>
struct _Static_partitioned_temporary_buffer2 {
    _Optimistic_temporary_buffer<_Ty>& _Temp_buf;
    ptrdiff_t _Chunk_size;
    ptrdiff_t _Unchunked_items;

    template <class _Diff>
    explicit _Static_partitioned_temporary_buffer2(
        _Optimistic_temporary_buffer<_Ty>& _Temp_buf_raw, _Static_partition_team<_Diff>& _Team)
        : _Temp_buf(_Temp_buf_raw), _Chunk_size(static_cast<ptrdiff_t>(_Temp_buf._Capacity / _Team._Chunks)),
          _Unchunked_items(static_cast<ptrdiff_t>(_Temp_buf._Capacity % _Team._Chunks)) {}

    pair<_Ty*, ptrdiff_t> _Get_temp_buffer_for_chunk(const size_t _Chunk_number) {
        
        return _Get_temp_buffer_for_chunk_range(_Chunk_number, _Chunk_number + 1);
    }

    pair<_Ty*, ptrdiff_t> _Get_temp_buffer_for_chunk_range(const size_t _Base, const size_t _End) {
        
        const auto _Offset = _Get_offset(_Base);
        return {_Temp_buf._Data + _Offset, _Offset - _Get_offset(_End)};
    }

    _Ty* _Get_first(const size_t _Chunk_number) {
        
        return _Temp_buf._Data + _Get_offset(_Chunk_number);
    }

    ptrdiff_t _Get_offset(const size_t _Chunk_number) {
        
        auto _Diff_chunk = static_cast<ptrdiff_t>(_Chunk_number);
        return _Diff_chunk * _Chunk_size + (::std:: min)(_Diff_chunk, _Unchunked_items);
    }

    void _Destroy_all() { 
        _Destroy_range(_Temp_buf._Data, _Temp_buf._Data + _Temp_buf._Capacity);
    }
};

inline size_t _Get_stable_sort_tree_height(const size_t _Count, const size_t _Hw_threads) {
    
    
    const auto _Count_max_chunks       = _Count / _ISORT_MAX;
    const size_t _Log_count_max_chunks = _Floor_of_log_2(_Count_max_chunks);

    
    const auto _Count_max_tree_height = _Log_count_max_chunks & ~static_cast<size_t>(1);

    const auto _Ideal_chunks           = _Hw_threads * _Oversubscription_multiplier;
    const size_t _Log_ideal_chunks     = _Floor_of_log_2(_Ideal_chunks);


    const size_t _Max_tree_height = 30;
#line 2798 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\execution"
    const size_t _Clamped_ideal_chunks = (::std:: min)(_Max_tree_height, _Log_ideal_chunks);

    
    const auto _Ideal_tree_height = _Clamped_ideal_chunks + (_Clamped_ideal_chunks & 0x1U);

    return (::std:: min)(_Count_max_tree_height, _Ideal_tree_height);
}

struct _Bottom_up_merge_tree {
    
    
    size_t _Height;
    
    _Parallel_vector<atomic<bool>> _Buckets;

    explicit _Bottom_up_merge_tree(const size_t _Height_)
        : _Height(_Height_), _Buckets((static_cast<size_t>(1) << _Height_) - 1) {}
};

struct _Bottom_up_tree_visitor {
    size_t _Cell;
    size_t _Base;
    size_t _Shift;

    _Bottom_up_tree_visitor(const size_t _Tree_height, const size_t _Initial_chunk)
        : _Cell((_Initial_chunk >> 1) + (static_cast<size_t>(1) << (_Tree_height - 1))),
          _Base(_Initial_chunk & ~static_cast<size_t>(1)), _Shift(1) {}

    bool _Try_give_up_merge_to_peer(_Bottom_up_merge_tree& _Merge_tree) const {
        
        
        return !_Merge_tree._Buckets[_Cell - 1].exchange(true);
    }

    bool _Go_to_parent() {
        
        _Shift <<= 1;
        _Base -= _Shift * (_Cell & static_cast<size_t>(1));
        _Cell >>= 1;
        return _Cell != 0;
    }
};

template <class _BidIt, class _Pr>
struct _Static_partitioned_stable_sort3 {
    using _Diff = _Iter_diff_t<_BidIt>;
    _Static_partition_team<_Diff> _Team;
    _Static_partition_range<_BidIt> _Basis;
    _Bottom_up_merge_tree _Merge_tree;
    _Static_partitioned_temporary_buffer2<_Iter_value_t<_BidIt>> _Temp_buf;
    _Pr _Pred;

    _Static_partitioned_stable_sort3(_Optimistic_temporary_buffer<_Iter_value_t<_BidIt>>& _Temp_buf_raw,
        const _Diff _Count, const size_t _Merge_tree_height_, const _BidIt _First, _Pr _Pred_)
        : _Team(_Count, static_cast<size_t>(1) << _Merge_tree_height_), _Basis{}, _Merge_tree(_Merge_tree_height_),
          _Temp_buf(_Temp_buf_raw, _Team), _Pred{_Pred_} {
        _Basis._Populate(_Team, _First);
    }

    _Cancellation_status _Process_chunk() {
        const auto _Key = _Team._Get_next_key();
        if (!_Key) {
            return _Cancellation_status::_Canceled;
        }

        {
            const auto _Serial_chunk = _Basis._Get_chunk(_Key);
            const auto _Temp_chunk   = _Temp_buf._Get_temp_buffer_for_chunk(_Key._Chunk_number);
            _Stable_sort_unchecked(
                _Serial_chunk._First, _Serial_chunk._Last, _Key._Size, _Temp_chunk.first, _Temp_chunk.second, _Pred);
        }

        _Bottom_up_tree_visitor _Visitor{_Merge_tree._Height, _Key._Chunk_number};
        if (_Visitor._Try_give_up_merge_to_peer(_Merge_tree)) { 
            return _Cancellation_status::_Running;
        }

        if (_Temp_buf._Temp_buf._Capacity >= _Team._Count) { 
            { 
                const size_t _Base = _Visitor._Base;
                _Uninitialized_merge_move(_Basis._Get_first(_Base, _Team._Get_chunk_offset(_Base)),
                    _Basis._Get_first(_Base + 1, _Team._Get_chunk_offset(_Base + 1)),
                    _Basis._Get_first(_Base + 2, _Team._Get_chunk_offset(_Base + 2)), _Temp_buf._Get_first(_Base),
                    _Pred);
            }

            for (;;) { 
                (void) _Visitor._Go_to_parent(); 
                if (_Visitor._Try_give_up_merge_to_peer(_Merge_tree)) { 
                    return _Cancellation_status::_Running;
                }

                { 
                    const size_t _Base = _Visitor._Base;
                    const size_t _Mid  = _Base + _Visitor._Shift;
                    const size_t _End  = _Mid + _Visitor._Shift;
                    _Merge_move(_Temp_buf._Get_first(_Base), _Temp_buf._Get_first(_Mid), _Temp_buf._Get_first(_End),
                        _Basis._Get_first(_Base, _Team._Get_chunk_offset(_Base)), _Pred);
                }

                if (!_Visitor._Go_to_parent()) {
                    
                    _Temp_buf._Destroy_all();
                    return _Cancellation_status::_Canceled;
                }

                if (_Visitor._Try_give_up_merge_to_peer(_Merge_tree)) { 
                    return _Cancellation_status::_Running;
                }

                { 
                    const size_t _Base = _Visitor._Base;
                    const size_t _Mid  = _Base + _Visitor._Shift;
                    const size_t _End  = _Mid + _Visitor._Shift;
                    _Merge_move(_Basis._Get_first(_Base, _Team._Get_chunk_offset(_Base)),
                        _Basis._Get_first(_Mid, _Team._Get_chunk_offset(_Mid)),
                        _Basis._Get_first(_End, _Team._Get_chunk_offset(_End)), _Temp_buf._Get_first(_Base), _Pred);
                }
            }
        } else { 
            for (;;) {
                const size_t _Base      = _Visitor._Base;
                const size_t _Mid       = _Base + _Visitor._Shift;
                const size_t _End       = _Mid + _Visitor._Shift;
                const auto _Base_offset = _Team._Get_chunk_offset(_Base);
                const auto _Mid_offset  = _Team._Get_chunk_offset(_Mid);
                const auto _End_offset  = _Team._Get_chunk_offset(_End);
                const auto _Temp_range  = _Temp_buf._Get_temp_buffer_for_chunk_range(_Base, _End);
                _Buffered_inplace_merge_unchecked(_Basis._Get_first(_Base, _Base_offset),
                    _Basis._Get_first(_Mid, _Mid_offset), _Basis._Get_first(_End, _End_offset),
                    _Mid_offset - _Base_offset, _End_offset - _Mid_offset, _Temp_range.first, _Temp_range.second,
                    _Pred);

                if (!_Visitor._Go_to_parent()) { 
                    return _Cancellation_status::_Canceled;
                }

                if (_Visitor._Try_give_up_merge_to_peer(_Merge_tree)) { 
                    return _Cancellation_status::_Running;
                }
            }
        }
    }

    static void __stdcall _Threadpool_callback(
        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept  {
        _Run_available_chunked_work(*static_cast<_Static_partitioned_stable_sort3*>(_Context));
    }
};

template <class _ExPo, class _BidIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> >
void stable_sort(_ExPo&&, const _BidIt _First, const _BidIt _Last, _Pr _Pred) noexcept  {
    
    _Adl_verify_range(_First, _Last);
    const auto _UFirst = _Get_unwrapped(_First);
    const auto _ULast  = _Get_unwrapped(_Last);
    const auto _Count  = ::std:: distance(_UFirst, _ULast);
    if (_Count <= _ISORT_MAX) {
        _Insertion_sort_unchecked(_UFirst, _ULast, _Pass_fn(_Pred));
        return;
    }

    size_t _Hw_threads;
    bool _Attempt_parallelism;
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        _Hw_threads          = __std_parallel_algorithms_hw_threads();
        _Attempt_parallelism = _Hw_threads > 1;
    } else {
        _Attempt_parallelism = false;
    }

    _Optimistic_temporary_buffer<_Iter_value_t<_BidIt>> _Temp_buf{_Attempt_parallelism ? _Count : _Count - _Count / 2};
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        if (_Attempt_parallelism) {
            
            const auto _Tree_height = _Get_stable_sort_tree_height(static_cast<size_t>(_Count), _Hw_threads);
            if (_Tree_height != 0) {
                try {
                _Static_partitioned_stable_sort3 _Operation{_Temp_buf, _Count, _Tree_height, _UFirst, _Pass_fn(_Pred)};
                _Run_chunked_parallel_work(_Hw_threads, _Operation);
                return;
                } catch (const _Parallelism_resources_exhausted&) {
                
                }
            }
        }
    }

    _Stable_sort_unchecked(_UFirst, _ULast, _Count, _Temp_buf._Data, _Temp_buf._Capacity, _Pass_fn(_Pred));
}

template <class _FwdIt, class _Pr>
struct _Static_partitioned_is_sorted_until {
    _Static_partition_team<_Iter_diff_t<_FwdIt>> _Team;
    
    _Static_partition_range<_FwdIt> _Basis; 
    _Pr _Pred;
    _Parallel_find_results<_FwdIt> _Results;

    _Static_partitioned_is_sorted_until(
        _FwdIt _First, _FwdIt _Last, const size_t _Hw_threads, const _Iter_diff_t<_FwdIt> _Count, _Pr _Pred_)
        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis{}, _Pred(_Pred_), _Results(_Last) {
        _Basis._Populate(_Team, _First);
    }

    _Cancellation_status _Process_chunk() {
        if (_Results._Complete()) {
            return _Cancellation_status::_Canceled;
        }

        const auto _Key = _Team._Get_next_key();
        if (!_Key) {
            return _Cancellation_status::_Canceled;
        }
        

        auto _Range = _Basis._Get_chunk(_Key);
        auto _Next  = _Range._First;
        do {
            ++_Next;
            if (static_cast<bool>(_Pred(*_Next, *_Range._First))) {
                _Results._Imbue(_Key._Chunk_number, _Next);
                return _Cancellation_status::_Canceled;
            }

            _Range._First = _Next;
        } while (_Range._First != _Range._Last);

        return _Cancellation_status::_Running;
    }

    static void __stdcall _Threadpool_callback(
        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept  {
        _Run_available_chunked_work(*static_cast<_Static_partitioned_is_sorted_until*>(_Context));
    }
};

template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> >
[[nodiscard]] _FwdIt is_sorted_until(_ExPo&&, _FwdIt _First, _FwdIt _Last, _Pr _Pred) noexcept  {
    
    static_assert(_Is_fwd_iter_v<_FwdIt>, "Parallel algorithms require forward iterators or stronger.");
    _Adl_verify_range(_First, _Last);
    const auto _UFirst = _Get_unwrapped(_First);
    const auto _ULast  = _Get_unwrapped(_Last);
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
        if (_Hw_threads > 1) { 
            auto _Count = ::std:: distance(_UFirst, _ULast);
            if (_Count >= 3) { 
                try {
                --_Count; 
                _Static_partitioned_is_sorted_until _Operation{_UFirst, _ULast, _Hw_threads, _Count, _Pass_fn(_Pred)};
                _Run_chunked_parallel_work(_Hw_threads, _Operation);
                _Seek_wrapped(_First, _Operation._Results._Get_result());
                return _First;
                } catch (const _Parallelism_resources_exhausted&) {
                
                }
            }
        }
    }

    _Seek_wrapped(_First, ::std:: is_sorted_until(_UFirst, _ULast, _Pass_fn(_Pred)));
    return _First;
}

inline constexpr unsigned char _Contains_counterexample = 0;
inline constexpr unsigned char _Contains_true           = 1;
inline constexpr unsigned char _Contains_false          = 2;

template <class _FwdIt, class _Pr>
unsigned char _Chunk_is_partitioned_status(_FwdIt _First, _FwdIt _Last, _Pr _Pred) {
    
    
    unsigned char _Result = 0;
    if (_Pred(*_First)) { 
        _Result = _Contains_true;
        for (;;) { 
            ++_First;
            if (_First == _Last) { 
                return _Contains_true;
            }

            if (!_Pred(*_First)) { 
                break;
            }
        }
    }

    _Result |= _Contains_false;
    while (++_First != _Last) { 
        if (_Pred(*_First)) { 
            return _Contains_counterexample;
        }
    }

    return _Result;
}

template <class _FwdIt, class _Pr>
struct _Static_partitioned_is_partitioned {
    _Static_partition_team<_Iter_diff_t<_FwdIt>> _Team;
    _Static_partition_range<_FwdIt> _Basis;
    atomic<size_t> _Rightmost_true; 
    atomic<size_t> _Leftmost_false; 
    _Pr _Pred;

    _Static_partitioned_is_partitioned(
        const size_t _Hw_threads, const _Iter_diff_t<_FwdIt> _Count, const _FwdIt _First, _Pr _Pred_)
        : _Team(_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)), _Basis{}, _Rightmost_true(0),
          _Leftmost_false(0xffffffffui32 - 1), _Pred(_Pred_) {
        _Basis._Populate(_Team, _First);
    }

    _Cancellation_status _Process_chunk() {
        
        
        if (_Rightmost_true.load(memory_order_relaxed) > _Leftmost_false.load(memory_order_relaxed)) {
            
            return _Cancellation_status::_Canceled;
        }

        const auto _Key = _Team._Get_next_key();
        if (!_Key) {
            return _Cancellation_status::_Canceled;
        }
        

        auto _Target_chunk_number = _Key._Chunk_number >> 1;
        if (!(_Key._Chunk_number & static_cast<size_t>(1))) {
            _Target_chunk_number = _Team._Chunks - _Target_chunk_number - 1;
        }

        const auto _Target_chunk_key  = _Team._Get_chunk_key(_Target_chunk_number);
        const auto _Chunk             = _Basis._Get_chunk(_Target_chunk_key);
        const auto _This_chunk_status = _Chunk_is_partitioned_status(_Chunk._First, _Chunk._Last, _Pred);

        if (_This_chunk_status == _Contains_counterexample) {
            
            _Rightmost_true.store(0xffffffffui32);
            return _Cancellation_status::_Canceled;
        }

        
        auto _Old_true = _Rightmost_true.load();
        if (_This_chunk_status & _Contains_true) {
            while (_Target_chunk_number > _Old_true) {
                if (_Rightmost_true.compare_exchange_weak(_Old_true, _Target_chunk_number)) {
                    _Old_true = _Target_chunk_number;
                    break;
                }
            }
        }

        
        auto _Old_false = _Leftmost_false.load();
        if (_Old_true > _Old_false) {
            return _Cancellation_status::_Canceled;
        }

        if (_This_chunk_status & _Contains_false) {
            while (_Target_chunk_number < _Old_false) {
                if (_Leftmost_false.compare_exchange_weak(_Old_false, _Target_chunk_number)) {
                    _Old_false = _Target_chunk_number;
                    break;
                }
            }
        }

        
        if (_Old_true > _Old_false) {
            return _Cancellation_status::_Canceled;
        }

        return _Cancellation_status::_Running;
    }

    static void __stdcall _Threadpool_callback(
        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept  {
        _Run_available_chunked_work(*static_cast<_Static_partitioned_is_partitioned*>(_Context));
    }
};

template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> >
[[nodiscard]] bool is_partitioned(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept  {
    
    static_assert(_Is_fwd_iter_v<_FwdIt>, "Parallel algorithms require forward iterators or stronger.");
    _Adl_verify_range(_First, _Last);
    const auto _UFirst = _Get_unwrapped(_First);
    const auto _ULast  = _Get_unwrapped(_Last);
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
        if (_Hw_threads > 1) { 
            const auto _Count = ::std:: distance(_UFirst, _ULast);
            if (_Count >= 2) { 
                try {
                _Static_partitioned_is_partitioned _Operation{_Hw_threads, _Count, _UFirst, _Pass_fn(_Pred)};
                _Run_chunked_parallel_work(_Hw_threads, _Operation);
                return _Operation._Rightmost_true.load(memory_order_relaxed)
                    <= _Operation._Leftmost_false.load(memory_order_relaxed);
                } catch (const _Parallelism_resources_exhausted&) {
                
                }
            }
        }
    }

    return ::std:: is_partitioned(_UFirst, _ULast, _Pass_fn(_Pred));
}

template <class _RanIt, class _Pr>
struct _Static_partitioned_is_heap_until {
    using _Diff = _Iter_diff_t<_RanIt>;
    _Static_partition_team<_Diff> _Team;
    _RanIt _Range_first;
    _Pr _Pred;
    _Parallel_find_results<_RanIt> _Results;

    _Static_partitioned_is_heap_until(
        _RanIt _First, _RanIt _Last, const size_t _Hw_threads, const _Diff _Count, _Pr _Pred_)
        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Range_first(_First), _Pred(_Pred_),
          _Results(_Last) {}

    _Cancellation_status _Process_chunk() {
        if (_Results._Complete()) {
            return _Cancellation_status::_Canceled;
        }

        const auto _Key = _Team._Get_next_key();
        if (!_Key) {
            return _Cancellation_status::_Canceled;
        }
        

        const auto _Chunk_range_size = _Key._Size;
        const auto _Chunk_offset     = _Key._Start_at;
        const auto _Last             = _Chunk_offset + _Chunk_range_size;

        const auto _Initial = (::std:: max)(_Chunk_offset, _Diff{1});
        for (_Diff _Off = _Initial; _Off < _Last; ++_Off) {
            if (static_cast<bool>(_Pred(*(_Range_first + ((_Off - 1) >> 1)), *(_Range_first + _Off)))) {
                _Results._Imbue(_Key._Chunk_number, _Range_first + _Off);
                return _Cancellation_status::_Canceled;
            }
        }

        return _Cancellation_status::_Running;
    }

    static void __stdcall _Threadpool_callback(
        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept  {
        _Run_available_chunked_work(*static_cast<_Static_partitioned_is_heap_until*>(_Context));
    }
};

template <class _ExPo, class _RanIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> >
[[nodiscard]] _RanIt is_heap_until(_ExPo&&, _RanIt _First, _RanIt _Last, _Pr _Pred) noexcept  {
    
    static_assert(_Is_fwd_iter_v<_RanIt>, "Parallel algorithms require forward iterators or stronger.");
    _Adl_verify_range(_First, _Last);
    const auto _UFirst = _Get_unwrapped(_First);
    const auto _ULast  = _Get_unwrapped(_Last);
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
        if (_Hw_threads > 1) { 
            const auto _Count = _ULast - _UFirst;
            if (_Count >= 3) { 
                try {
                _Static_partitioned_is_heap_until _Operation{_UFirst, _ULast, _Hw_threads, _Count, _Pass_fn(_Pred)};
                _Run_chunked_parallel_work(_Hw_threads, _Operation);
                _Seek_wrapped(_First, _Operation._Results._Get_result());
                return _First;
                } catch (const _Parallelism_resources_exhausted&) {
                
                }
            }
        }
    }

    _Seek_wrapped(_First, ::std:: is_heap_until(_UFirst, _ULast, _Pass_fn(_Pred)));
    return _First;
}

template <class _FwdIt, class _Pr>
pair<_FwdIt, _Iter_diff_t<_FwdIt>> _Partition_with_count_unchecked(_FwdIt _First, _FwdIt _Last, _Pr _Pred) {
    
    if constexpr (_Is_random_iter_v<_FwdIt>) {
        auto _Mid = ::std:: partition(_First, _Last, _Pred);
        return {_Mid, _Mid - _First};
    } else if constexpr (_Is_bidi_iter_v<_FwdIt>) {
        _Iter_diff_t<_FwdIt> _Trues{};
        for (;;) { 
            for (;;) { 
                if (_First == _Last) {
                    return {_First, _Trues};
                }

                if (!_Pred(*_First)) {
                    break;
                }

                ++_First;
                ++_Trues;
            }

            do { 
                --_Last;
                if (_First == _Last) {
                    return {_First, _Trues};
                }
            } while (!_Pred(*_Last));

            ::std:: iter_swap(_First, _Last); 
            ++_First;
            ++_Trues;
        }
    } else {
        _Iter_diff_t<_FwdIt> _Trues{};
        for (;;) { 
            if (_First == _Last) {
                return {_First, _Trues};
            }

            if (!_Pred(*_First)) {
                break;
            }

            ++_First;
            ++_Trues;
        }

        for (_FwdIt _Next = _First; ++_Next != _Last;) {
            if (_Pred(*_Next)) {
                ::std:: iter_swap(_First, _Next); 
                ++_First;
                ++_Trues;
            }
        }

        return {_First, _Trues};
    }
}

template <class _FwdIt, class _Pr>
pair<_FwdIt, _Iter_diff_t<_FwdIt>> _Partition_swap_backward(
    _FwdIt _First, _FwdIt _Last, _FwdIt _Beginning_of_falses, _Pr _Pred) {
    
    
    _Iter_diff_t<_FwdIt> _Trues{};
    if constexpr (_Is_bidi_iter_v<_FwdIt>) {
        while (_First != _Last) {
            --_Last;
            if (_Pred(*_Last)) {
                ::std:: iter_swap(_Beginning_of_falses, _Last);
                ++_Beginning_of_falses;
                ++_Trues;
                if (_Beginning_of_falses == _First) {
                    auto _Remain = _Partition_with_count_unchecked(_First, _Last, _Pred);
                    return {_Remain.first, static_cast<_Iter_diff_t<_FwdIt>>(_Remain.second + _Trues)};
                }
            }
        }
    } else {
        for (; _First != _Last; ++_First) {
            if (_Pred(*_First)) {
                ::std:: iter_swap(_First, _Beginning_of_falses);
                ++_Beginning_of_falses;
                ++_Trues;
            }
        }
    }

    return {_Beginning_of_falses, _Trues};
}

template <class _FwdIt>
_FwdIt _Partition_merge(const _FwdIt _False_first, const _FwdIt _True_first, const _FwdIt _True_last,
    const _Iter_diff_t<_FwdIt> _Count1, const _Iter_diff_t<_FwdIt> _Count2) {
    
    
    if (_Count1 < _Count2) { 
        const _Iter_diff_t<_FwdIt> _Offset = _Count2 - _Count1;
        auto _Result                       = _True_first;
        if constexpr (_Is_random_iter_v<_FwdIt>) {
            _Result += _Offset;
        } else if constexpr (_Is_bidi_iter_v<_FwdIt>) {
            if (_Count1 < _Offset) {
                _Result = _True_last;
                ::std:: advance(_Result, -_Count1);
            } else {
                ::std:: advance(_Result, _Offset);
            }
        } else {
            ::std:: advance(_Result, _Offset);
        }

        _Swap_ranges_unchecked(_False_first, _True_first, _Result);
        return _Result;
    }

    
    return _Swap_ranges_unchecked(_True_first, _True_last, _False_first);
}

template <class _FwdIt, class _Pr>
struct _Static_partitioned_partition2 {
    using _Diff = _Iter_diff_t<_FwdIt>;

    enum class _Chunk_state : unsigned char {
        _Serial, 
        _Merging, 
                  
                  
        _Swapping, 
                   
                   
        _Done 
    };

#pragma warning(push)
#pragma warning(disable : 4324) 
    struct alignas(hardware_destructive_interference_size) alignas(_FwdIt) _Chunk_local_data {
        atomic<_Chunk_state> _State;
        _FwdIt _Beginning_of_falses;
        _Diff _Chunk_trues;
    };
#pragma warning(pop)

    _Static_partition_team<_Diff> _Team;
    _Static_partition_range<_FwdIt> _Basis;
    _Pr _Pred;
    _Parallel_vector<_Chunk_local_data> _Chunk_locals;
    _FwdIt _Results;
    _Diff _Results_falses;

    _Static_partitioned_partition2(const size_t _Hw_threads, const _Diff _Count, const _FwdIt _First, const _Pr _Pred_)
        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis{}, _Pred{_Pred_},
          _Chunk_locals(_Team._Chunks), _Results{_First}, _Results_falses{} {
        _Basis._Populate(_Team, _First);
    }

    _Cancellation_status _Process_chunk() {
        const auto _Key = _Team._Get_next_key();
        if (!_Key) {
            return _Cancellation_status::_Canceled;
        }

        
        auto _Merge_index = _Key._Chunk_number; 
        {
            auto& _Chunk_data = _Chunk_locals[_Merge_index];
            const auto _Range = _Basis._Get_chunk(_Key);
            if (_Merge_index == 0 || _Chunk_locals[_Merge_index - 1]._State.load() == _Chunk_state::_Done) {
                
                const auto _Chunk_results = _Merge_index == 0 || _Results == _Range._First
                                              ? _Partition_with_count_unchecked(_Range._First, _Range._Last, _Pred)
                                              : _Partition_swap_backward(_Range._First, _Range._Last, _Results, _Pred);
                _Results                  = _Chunk_results.first;
                _Chunk_data._Chunk_trues  = _Chunk_results.second;
                _Results_falses += _Key._Size - _Chunk_results.second;
                _Chunk_data._State.store(_Chunk_state::_Done);
                ++_Merge_index; 
            } else {
                
                auto _Chunk_results              = _Partition_with_count_unchecked(_Range._First, _Range._Last, _Pred);
                _Chunk_data._Beginning_of_falses = _Chunk_results.first;
                _Chunk_data._Chunk_trues         = _Chunk_results.second;
                _Chunk_data._State.store(_Chunk_state::_Merging);
                if (_Chunk_locals[_Merge_index - 1]._State.load() != _Chunk_state::_Done) {
                    
                    return _Cancellation_status::_Running;
                }
            }
        }

        
        for (; _Merge_index != _Team._Chunks; ++_Merge_index) {
            auto& _Merge_chunk_data = _Chunk_locals[_Merge_index];
            auto _Expected          = _Chunk_state::_Merging;
            if (!_Merge_chunk_data._State.compare_exchange_strong(_Expected, _Chunk_state::_Swapping)) {
                
                return _Cancellation_status::_Running;
            }

            const auto _Merge_key   = _Team._Get_chunk_key(_Merge_index);
            const auto _Chunk_trues = _Merge_chunk_data._Chunk_trues;

            _Results = _Partition_merge(_Results, _Basis._Get_first(_Merge_index, _Merge_key._Start_at),
                ::std:: exchange(_Merge_chunk_data._Beginning_of_falses, {}), _Results_falses, _Chunk_trues);
            _Results_falses += _Merge_key._Size - _Chunk_trues;
            _Merge_chunk_data._State.store(_Chunk_state::_Done);
        }

        return _Cancellation_status::_Canceled;
    }

    static void __stdcall _Threadpool_callback(
        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept  {
        _Run_available_chunked_work(*static_cast<_Static_partitioned_partition2*>(_Context));
    }
};

template <class _ExPo, class _FwdIt, class _Pr, _Enable_if_execution_policy_t<_ExPo> >
_FwdIt partition(_ExPo&&, _FwdIt _First, const _FwdIt _Last, _Pr _Pred) noexcept  {
    
    _Adl_verify_range(_First, _Last);
    const auto _UFirst = _Get_unwrapped(_First);
    const auto _ULast  = _Get_unwrapped(_Last);
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
        if (_Hw_threads > 1) {
            const auto _Count = ::std:: distance(_UFirst, _ULast);
            if (_Count >= 2) {
                try {
                _Static_partitioned_partition2 _Operation{_Hw_threads, _Count, _UFirst, _Pass_fn(_Pred)};
                _Run_chunked_parallel_work(_Hw_threads, _Operation);
                _Seek_wrapped(_First, _Operation._Results);
                return _First;
                } catch (const _Parallelism_resources_exhausted&) {
                
                }
            }
        }
    }

    _Seek_wrapped(_First, ::std:: partition(_UFirst, _ULast, _Pass_fn(_Pred)));
    return _First;
}

inline constexpr unsigned char _Local_available = 1;
inline constexpr unsigned char _Sum_available   = 2;

template <class _Ty>
struct _Scan_decoupled_lookback {
    
    
    using value_type = _Ty;
    atomic<unsigned char> _State;
    _Storage_for<_Ty> _Local; 
    _Storage_for<_Ty> _Sum; 

    unsigned char _Get_available_state() const {
        for (;;) {
            const unsigned char _Local_state = _State.load();
            if (_Local_state != 0) {
                return _Local_state;
            }

            __std_execution_wait_on_uchar(reinterpret_cast<const unsigned char*>(&_State), _Local_state);
        }
    }

    void _Store_available_state(const unsigned char _New_state) {
        _State.store(_New_state);
        __std_execution_wake_by_address_all(&_State);
    }

    template <class _FwdIt, class _BinOp>
    void _Apply_exclusive_predecessor(_Ty& _Preceding, _FwdIt _First, const _FwdIt _Last, _BinOp _Reduce_op) {
        
        _Construct_in_place(_Sum._Ref(), _Reduce_op(_Preceding, _Local._Ref()));
        _State.store(_Local_available | _Sum_available);
        *_First = _Preceding;

#pragma loop(ivdep)
        while (++_First != _Last) {
            *_First = _Reduce_op(_Preceding, ::std:: move(*_First));
        }
    }

    template <class _FwdIt, class _BinOp>
    void _Apply_inclusive_predecessor(_Ty& _Preceding, _FwdIt _First, const _FwdIt _Last, _BinOp _Reduce_op) {
        
        _Construct_in_place(_Sum._Ref(), _Reduce_op(_Preceding, _Local._Ref()));
        _State.store(_Local_available | _Sum_available);

#pragma loop(ivdep)
        for (; _First != _Last; ++_First) {
            *_First = _Reduce_op(_Preceding, ::std:: move(*_First));
        }
    }

    ~_Scan_decoupled_lookback() {
        const auto _State_bits = _State.load(memory_order_relaxed);
        if (_State_bits & _Sum_available) {
            _Destroy_in_place(_Sum._Ref());
        }

        if (_State_bits & _Local_available) {
            _Destroy_in_place(_Local._Ref());
        }
    }
};

template <class _BidIt, class _BinOp>
typename _Iter_value_t<_BidIt>::value_type _Get_lookback_sum(const _BidIt _Current, _BinOp _Reduce_op) {
    
    
    static_assert(_Is_specialization_v<_Iter_value_t<_BidIt>, _Scan_decoupled_lookback>, "Bad _Get_lookback_sum");
    auto _Prev = _Current;
    --_Prev;
    auto _Prev_state = _Prev->_Get_available_state();
    typename _Iter_value_t<_BidIt>::value_type _Result(
        _Reduce_op(_Prev_state & _Sum_available ? _Prev->_Sum._Ref() : _Prev->_Local._Ref(), _Current->_Local._Ref()));
    while (!(_Prev_state & _Sum_available)) {
        --_Prev;
        _Prev_state = _Prev->_Get_available_state();
        _Result =
            _Reduce_op(_Prev_state & _Sum_available ? _Prev->_Sum._Ref() : _Prev->_Local._Ref(), ::std:: move(_Result));
    }

    return _Result;
}

template <class _Ty>
struct _Casty_plus {
    
    
    [[nodiscard]] constexpr _Ty operator()(_Ty _Val1, _Ty _Val2) const noexcept  {
        return static_cast<_Ty>(_Val1 + _Val2);
    }
};

template <class _Diff>
void _Surrender_elements_to_next_chunk(const size_t _Chunk_number,
    const typename _Parallel_vector<_Scan_decoupled_lookback<_Diff>>::iterator _Chunk_lookback_data) {
    
    
    if (_Chunk_number == 0) {
        
        
        _Chunk_lookback_data->_Store_available_state(_Sum_available);
        return;
    }

    
    _Chunk_lookback_data->_Store_available_state(_Local_available);

    const auto _Prev_chunk_lookback_data = _Prev_iter(_Chunk_lookback_data);
    _Diff _Prev_chunk_sum;
    if (_Prev_chunk_lookback_data->_Get_available_state() & _Sum_available) {
        _Prev_chunk_sum = _Prev_chunk_lookback_data->_Sum._Ref();
    } else {
        
        
        _Prev_chunk_sum = _Get_lookback_sum(_Prev_chunk_lookback_data, _Casty_plus<_Diff>{});
    }

    _Chunk_lookback_data->_Sum._Ref() = _Prev_chunk_sum;
    _Chunk_lookback_data->_Store_available_state(_Sum_available);
}

template <class _RanIt1, class _RanIt2, class _RanIt3>
void _Place_elements_from_indices(
    const _RanIt1 _First, _RanIt2 _Dest, _RanIt3 _Indices_first, const ptrdiff_t _Num_results) {
    
    const auto _Last_index = _Indices_first + _Num_results;
    for (; _Indices_first != _Last_index; ++_Indices_first) {
        const auto _Curr_index = *_Indices_first;
        *_Dest                 = *(_First + static_cast<_Iter_diff_t<_RanIt1>>(_Curr_index));
        ++_Dest;
    }
}

template <class _RanIt1, class _RanIt2, class _RanIt3, class _Pr, class _SetOper>
struct _Static_partitioned_set_subtraction {
    using _Diff = _Common_diff_t<_RanIt1, _RanIt2, _RanIt3>;
    _Static_partition_team<_Diff> _Team;
    _Static_partition_range<_RanIt1, _Diff> _Basis;
    _Parallel_vector<_Diff> _Index_indicator; 
    _Iterator_range<_RanIt2> _Range2;
    _RanIt3 _Dest;
    _Parallel_vector<_Scan_decoupled_lookback<_Diff>> _Lookback; 
                                                                 
                                                                 
    _Pr _Pred;
    _SetOper _Set_oper_per_chunk;

    _Static_partitioned_set_subtraction(const size_t _Hw_threads, const _Diff _Count, _RanIt1 _First1, _RanIt2 _First2,
        const _RanIt2 _Last2, _RanIt3 _Dest_, _Pr _Pred_, _SetOper _Set_oper)
        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis{},
          _Index_indicator(static_cast<size_t>(_Count)), _Range2{_First2, _Last2}, _Dest(_Dest_),
          _Lookback(_Team._Chunks), _Pred(_Pred_), _Set_oper_per_chunk(_Set_oper) {
        _Basis._Populate(_Team, _First1);
    }

    _Cancellation_status _Process_chunk() {
        const auto _Key = _Team._Get_next_key();
        if (!_Key) {
            return _Cancellation_status::_Canceled;
        }

        const auto _Chunk_number        = _Key._Chunk_number;
        const auto _Chunk_lookback_data = _Lookback.begin() + static_cast<ptrdiff_t>(_Chunk_number);

        
        auto [_Range1_chunk_first, _Range1_chunk_last] = _Basis._Get_chunk(_Key);
        const bool _Last_chunk                         = _Chunk_number == _Team._Chunks - 1;

        
        if (!_Last_chunk) {
            
            
            _Range1_chunk_last = ::std:: lower_bound(_Range1_chunk_first, _Range1_chunk_last, *_Range1_chunk_last, _Pred);

            if (_Range1_chunk_last <= _Range1_chunk_first) {
                
                
                _Surrender_elements_to_next_chunk<_Diff>(_Chunk_number, _Chunk_lookback_data);
                return _Cancellation_status::_Running;
            }
        }

        
        _Range1_chunk_first = ::std:: lower_bound(_Basis._Start_at, _Range1_chunk_first, *_Range1_chunk_first, _Pred);

        
        auto _Range2_chunk_first = ::std:: lower_bound(_Range2._First, _Range2._Last, *_Range1_chunk_first, _Pred);
        auto _Range2_chunk_last =
            ::std:: upper_bound(_Range2_chunk_first, _Range2._Last, *_Prev_iter(_Range1_chunk_last), _Pred);

        
        if (_Chunk_number == 0) {
            
            
            const auto _Num_results = _Set_oper_per_chunk._Update_dest(
                _Range1_chunk_first, _Range1_chunk_last, _Range2_chunk_first, _Range2_chunk_last, _Dest, _Pred);

            _Chunk_lookback_data->_Sum._Ref() = _Num_results;
            _Chunk_lookback_data->_Store_available_state(_Sum_available);
            return _Cancellation_status::_Running;
        }

        const auto _Prev_chunk_lookback_data = _Prev_iter(_Chunk_lookback_data);
        if (_Prev_chunk_lookback_data->_State.load() & _Sum_available) {
            
            const auto _Prev_chunk_sum = _Prev_chunk_lookback_data->_Sum._Ref();
            auto _Chunk_specific_dest  = _Dest + static_cast<_Iter_diff_t<_RanIt3>>(_Prev_chunk_sum);
            const auto _Num_results    = _Set_oper_per_chunk._Update_dest(_Range1_chunk_first, _Range1_chunk_last,
                   _Range2_chunk_first, _Range2_chunk_last, _Chunk_specific_dest, _Pred);

            _Chunk_lookback_data->_Sum._Ref() = static_cast<_Diff>(_Num_results + _Prev_chunk_sum);
            _Chunk_lookback_data->_Store_available_state(_Sum_available);
            return _Cancellation_status::_Running;
        }

        
        auto _Index_chunk_first =
            _Index_indicator.begin() + static_cast<ptrdiff_t>(_Range1_chunk_first - _Basis._Start_at);

        
        const auto _Num_results             = _Set_oper_per_chunk._Mark_indices(_Range1_chunk_first, _Range1_chunk_last,
                        _Range2_chunk_first, _Range2_chunk_last, _Index_chunk_first, _Pred);
        _Chunk_lookback_data->_Local._Ref() = _Num_results;
        _Chunk_lookback_data->_Store_available_state(_Local_available);

        
        _Diff _Prev_chunk_sum;
        if (_Prev_chunk_lookback_data->_Get_available_state() & _Sum_available) {
            
            _Prev_chunk_sum = _Prev_chunk_lookback_data->_Sum._Ref();
        } else {
            _Prev_chunk_sum = _Get_lookback_sum(_Prev_chunk_lookback_data, _Casty_plus<_Diff>{});
        }

        _Chunk_lookback_data->_Sum._Ref() = static_cast<_Diff>(_Num_results + _Prev_chunk_sum);
        _Chunk_lookback_data->_Store_available_state(_Sum_available);

        
        auto _Chunk_specific_dest = _Dest + static_cast<_Iter_diff_t<_RanIt3>>(_Prev_chunk_sum);
        _Place_elements_from_indices(
            _Range1_chunk_first, _Chunk_specific_dest, _Index_chunk_first, static_cast<ptrdiff_t>(_Num_results));
        return _Cancellation_status::_Running;
    }

    static void __stdcall _Threadpool_callback(
        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept  {
        _Run_available_chunked_work(*static_cast<_Static_partitioned_set_subtraction*>(_Context));
    }
};

struct _Set_intersection_per_chunk {
    template <class _RanIt1, class _RanIt2, class _RanIt3, class _Pr>
    _Common_diff_t<_RanIt1, _RanIt2, _RanIt3> _Update_dest(
        _RanIt1 _First1, const _RanIt1 _Last1, _RanIt2 _First2, const _RanIt2 _Last2, _RanIt3 _Dest, _Pr _Pred) {
        
        
        return ::std:: set_intersection(_First1, _Last1, _First2, _Last2, _Dest, _Pred) - _Dest;
    }

    template <class _RanIt1, class _RanIt2, class _BidIt, class _Pr>
    _Iter_value_t<_BidIt> _Mark_indices(_RanIt1 _First1, const _RanIt1 _Last1, _RanIt2 _First2, const _RanIt2 _Last2,
        _BidIt _Index_chunk_first, _Pr _Pred) {
        
        
        static_assert(is_integral_v<_Iter_value_t<_BidIt>>);
        static_assert(
            is_same_v<_Iter_value_t<_BidIt>, common_type_t<_Iter_value_t<_BidIt>, _Common_diff_t<_RanIt1, _RanIt2>>>);
        ;
        ;
        const auto _Index_chunk_first_save       = _Index_chunk_first;
        _Iter_diff_t<_RanIt1> _Curr_range1_index = 0;
        _Iter_diff_t<_RanIt2> _Curr_range2_index = 0;
        const auto _Range1_dist                  = _Last1 - _First1;
        const auto _Range2_dist                  = _Last2 - _First2;
        while (_Curr_range1_index < _Range1_dist && _Curr_range1_index < _Range2_dist) {
            if (static_cast<bool>(_Pred(*(_First1 + _Curr_range1_index), *(_First2 + _Curr_range2_index)))) {
                ++_Curr_range1_index;
            } else {
                if (!_Pred(*(_First2 + _Curr_range2_index), *(_First1 + _Curr_range1_index))) {
                    *_Index_chunk_first = static_cast<_Iter_value_t<_BidIt>>(_Curr_range1_index);
                    ++_Index_chunk_first;
                    ++_Curr_range1_index;
                }

                ++_Curr_range2_index;
            }
        }

        return static_cast<_Iter_value_t<_BidIt>>(_Index_chunk_first - _Index_chunk_first_save);
    }
};

template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr,
    _Enable_if_execution_policy_t<_ExPo> >
_FwdIt3 set_intersection(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _FwdIt3 _Dest,
    _Pr _Pred) noexcept  {
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt3>, "Parallel algorithms require forward iterators or stronger.");
    _Adl_verify_range(_First1, _Last1);
    _Adl_verify_range(_First2, _Last2);
    auto _UFirst1      = _Get_unwrapped(_First1);
    const auto _ULast1 = _Get_unwrapped(_Last1);
    auto _UFirst2      = _Get_unwrapped(_First2);
    const auto _ULast2 = _Get_unwrapped(_Last2);
    auto _UDest        = _Get_unwrapped_unverified(_Dest);
    using _Diff        = _Common_diff_t<_FwdIt1, _FwdIt2, _FwdIt3>;
    if constexpr (remove_reference_t<_ExPo>::_Parallelize
                  && _Is_random_iter_v<_FwdIt1> && _Is_random_iter_v<_FwdIt2> && _Is_random_iter_v<_FwdIt3>) {
        
        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
        if (_Hw_threads > 1) { 
            const _Diff _Count1 = _ULast1 - _UFirst1;
            const _Diff _Count2 = _ULast2 - _UFirst2;
            if (_Count1 >= 2 && _Count2 >= 2) { 
                try {
                _Static_partitioned_set_subtraction _Operation(_Hw_threads, _Count1, _UFirst1, _UFirst2, _ULast2,
                    _UDest, _Pass_fn(_Pred), _Set_intersection_per_chunk());
                _Run_chunked_parallel_work(_Hw_threads, _Operation);
                _UDest += static_cast<_Iter_diff_t<_FwdIt3>>(_Operation._Lookback.back()._Sum._Ref());
                _Seek_wrapped(_Dest, _UDest);
                return _Dest;
                } catch (const _Parallelism_resources_exhausted&) {
                
                }
            }
        }
    }

    _Seek_wrapped(_Dest, ::std:: set_intersection(_UFirst1, _ULast1, _UFirst2, _ULast2, _UDest, _Pass_fn(_Pred)));
    return _Dest;
}

struct _Set_difference_per_chunk {
    template <class _RanIt1, class _RanIt2, class _RanIt3, class _Pr>
    _Common_diff_t<_RanIt1, _RanIt2, _RanIt3> _Update_dest(
        _RanIt1 _First1, const _RanIt1 _Last1, _RanIt2 _First2, _RanIt2 _Last2, _RanIt3 _Dest, _Pr _Pred) {
        
        
        return ::std:: set_difference(_First1, _Last1, _First2, _Last2, _Dest, _Pred) - _Dest;
    }

    template <class _RanIt1, class _RanIt2, class _BidIt, class _Pr>
    _Iter_value_t<_BidIt> _Mark_indices(_RanIt1 _First1, const _RanIt1 _Last1, _RanIt2 _First2, const _RanIt2 _Last2,
        _BidIt _Index_chunk_first, _Pr _Pred) {
        
        
        static_assert(is_integral_v<_Iter_value_t<_BidIt>>);
        static_assert(
            is_same_v<_Iter_value_t<_BidIt>, common_type_t<_Iter_value_t<_BidIt>, _Common_diff_t<_RanIt1, _RanIt2>>>);
        ;
        ;
        const auto _Index_chunk_first_save       = _Index_chunk_first;
        _Iter_diff_t<_RanIt1> _Curr_range1_index = 0;
        _Iter_diff_t<_RanIt2> _Curr_range2_index = 0;
        const auto _Range1_dist                  = _Last1 - _First1;
        const auto _Range2_dist                  = _Last2 - _First2;
        while (_Curr_range1_index < _Range1_dist && _Curr_range2_index < _Range2_dist) {
            if (static_cast<bool>(_Pred(*(_First1 + _Curr_range1_index), *(_First2 + _Curr_range2_index)))) {
                *_Index_chunk_first = static_cast<_Iter_value_t<_BidIt>>(_Curr_range1_index);
                ++_Index_chunk_first;
                ++_Curr_range1_index;
            } else {
                if (!_Pred(*(_First2 + _Curr_range2_index), *(_First1 + _Curr_range1_index))) {
                    ++_Curr_range1_index;
                }

                ++_Curr_range2_index;
            }
        }

        
        for (; _Curr_range1_index < _Range1_dist; ++_Curr_range1_index) {
            *_Index_chunk_first = static_cast<_Iter_value_t<_BidIt>>(_Curr_range1_index);
            ++_Index_chunk_first;
        }

        return static_cast<_Iter_value_t<_BidIt>>(_Index_chunk_first - _Index_chunk_first_save);
    }
};

template <class _ExPo, class _FwdIt1, class _FwdIt2, class _FwdIt3, class _Pr,
    _Enable_if_execution_policy_t<_ExPo> >
_FwdIt3 set_difference(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _FwdIt3 _Dest,
    _Pr _Pred) noexcept  {
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt3>, "Parallel algorithms require forward iterators or stronger.");
    _Adl_verify_range(_First1, _Last1);
    _Adl_verify_range(_First2, _Last2);
    auto _UFirst1      = _Get_unwrapped(_First1);
    const auto _ULast1 = _Get_unwrapped(_Last1);
    auto _UFirst2      = _Get_unwrapped(_First2);
    const auto _ULast2 = _Get_unwrapped(_Last2);
    auto _UDest        = _Get_unwrapped_unverified(_Dest);
    using _Diff        = _Common_diff_t<_FwdIt1, _FwdIt2, _FwdIt3>;
    if constexpr (remove_reference_t<_ExPo>::_Parallelize
                  && _Is_random_iter_v<_FwdIt1> && _Is_random_iter_v<_FwdIt2> && _Is_random_iter_v<_FwdIt3>) {
        
        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
        if (_Hw_threads > 1) { 
            const _Diff _Count = _ULast1 - _UFirst1;
            if (_Count >= 2) { 
                try {
                _Static_partitioned_set_subtraction _Operation(_Hw_threads, _Count, _UFirst1, _UFirst2, _ULast2, _UDest,
                    _Pass_fn(_Pred), _Set_difference_per_chunk());
                _Run_chunked_parallel_work(_Hw_threads, _Operation);
                _UDest += static_cast<_Iter_diff_t<_FwdIt3>>(_Operation._Lookback.back()._Sum._Ref());
                _Seek_wrapped(_Dest, _UDest);
                return _Dest;
                } catch (const _Parallelism_resources_exhausted&) {
                
                }
            }
        }
    }

    _Seek_wrapped(_Dest, ::std:: set_difference(_UFirst1, _ULast1, _UFirst2, _ULast2, _UDest, _Pass_fn(_Pred)));
    return _Dest;
}

template <class _InIt, class _Ty, class _BinOp>
_Ty _Reduce_move_unchecked(_InIt _First, const _InIt _Last, _Ty _Val, _BinOp _Reduce_op) {
    
    if constexpr (_Plus_on_arithmetic_ranges_reduction_v<_Unwrapped_t<const _InIt&>, _Ty, _BinOp>) {
        return _Reduce_plus_arithmetic_ranges(_First, _Last, _Val);
    } else {
        for (; _First != _Last; ++_First) {
            _Val = _Reduce_op(::std:: move(_Val), ::std:: move(*_First)); 
        }

        return _Val;
    }
}

template <class _Ty, class _FwdIt, class _BinOp>
_Ty _Reduce_at_least_two(const _FwdIt _First, const _FwdIt _Last, _BinOp _Reduce_op) {
    
    
    if constexpr (_Plus_on_arithmetic_ranges_reduction_v<_FwdIt, _Ty, _BinOp>) {
        return _Reduce_plus_arithmetic_ranges(_First, _Last, _Ty{0});
    } else {
        auto _Next = _First;
        _Ty _Val   = _Reduce_op(*_First, *++_Next);
        while (++_Next != _Last) {
            _Val = _Reduce_op(::std:: move(_Val), *_Next); 
        }

        return _Val;
    }
}

template <class _FwdIt, class _Ty, class _BinOp>
struct _Static_partitioned_reduce2 {
    
    _Static_partition_team<_Iter_diff_t<_FwdIt>> _Team;
    _Static_partition_range<_FwdIt> _Basis;
    _BinOp _Reduce_op;
    _Generalized_sum_drop<_Ty> _Results;

    _Static_partitioned_reduce2(
        const _Iter_diff_t<_FwdIt> _Count, const size_t _Chunks, const _FwdIt _First, _BinOp _Reduce_op_)
        : _Team{_Count, _Chunks}, _Basis{}, _Reduce_op(_Reduce_op_), _Results{_Team._Chunks} {
        _Basis._Populate(_Team, _First);
    }

    static void __stdcall _Threadpool_callback(
        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept  {
        const auto _This = static_cast<_Static_partitioned_reduce2*>(_Context);
        auto _Key        = _This->_Team._Get_next_key();
        if (_Key) {
            auto _Chunk        = _This->_Basis._Get_chunk(_Key);
            auto _Local_result = _Reduce_at_least_two<_Ty>(_Chunk._First, _Chunk._Last, _This->_Reduce_op);
            while ((_Key = _This->_Team._Get_next_key())) {
                _Chunk        = _This->_Basis._Get_chunk(_Key);
                _Local_result = ::std:: reduce(_Chunk._First, _Chunk._Last, ::std:: move(_Local_result), _This->_Reduce_op);
            }

            _This->_Results._Add_result(::std:: move(_Local_result));
        }
    }
};

template <class _ExPo, class _FwdIt, class _Ty, class _BinOp, _Enable_if_execution_policy_t<_ExPo> >
[[nodiscard]] _Ty reduce(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, _Ty _Val, _BinOp _Reduce_op) noexcept
 {
    
    static_assert(_Is_fwd_iter_v<_FwdIt>, "Parallel algorithms require forward iterators or stronger.");
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
        if (_Hw_threads > 1) { 
            const auto _Count  = ::std:: distance(_UFirst, _ULast);
            const auto _Chunks = _Get_least2_chunked_work_chunk_count(_Hw_threads, _Count);
            if (_Chunks > 1) {
                try {
                auto _Passed_fn = _Pass_fn(_Reduce_op);
                _Static_partitioned_reduce2<decltype(_UFirst), _Ty, decltype(_Passed_fn)> _Operation{
                    _Count, _Chunks, _UFirst, _Passed_fn};
                {
                    
                    
                    const _Work_ptr _Work{_Operation};
                    
                    _Work._Submit_for_chunks(_Hw_threads, _Chunks);
                    while (const auto _Stolen_key = _Operation._Team._Get_next_key()) {
                        auto _Chunk = _Operation._Basis._Get_chunk(_Stolen_key);
                        _Val        = ::std:: reduce(_Chunk._First, _Chunk._Last, ::std:: move(_Val), _Pass_fn(_Reduce_op));
                    }
                } 

                auto& _Results = _Operation._Results;
                return _Reduce_move_unchecked(_Results.begin(), _Results.end(), ::std:: move(_Val), _Pass_fn(_Reduce_op));
                } catch (const _Parallelism_resources_exhausted&) {
                
                }
            }
        }
    }

    return ::std:: reduce(_UFirst, _ULast, ::std:: move(_Val), _Pass_fn(_Reduce_op));
}

template <class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp1, class _BinOp2>
struct _Static_partitioned_transform_reduce_binary2 { 
    using _Diff = _Common_diff_t<_FwdIt1, _FwdIt2>;
    _Static_partition_team<_Diff> _Team;
    _Static_partition_range<_FwdIt1, _Diff> _Basis1;
    _Static_partition_range<_FwdIt2, _Diff> _Basis2;
    _BinOp1 _Reduce_op;
    _BinOp2 _Transform_op;
    _Generalized_sum_drop<_Ty> _Results;

    _Static_partitioned_transform_reduce_binary2(const _Diff _Count, const size_t _Chunks, const _FwdIt1 _First1,
        const _FwdIt2 _First2, _BinOp1 _Reduce_op_, _BinOp2 _Transform_op_)
        : _Team{_Count, _Chunks}, _Basis1{}, _Basis2{}, _Reduce_op(_Reduce_op_),
          _Transform_op(_Transform_op_), _Results{_Chunks} {
        _Basis1._Populate(_Team, _First1);
        _Basis2._Populate(_Team, _First2);
    }

    static void __stdcall _Threadpool_callback(
        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept  {
        const auto _This = static_cast<_Static_partitioned_transform_reduce_binary2*>(_Context);
        auto _Key        = _This->_Team._Get_next_key();
        if (_Key) {
            auto _Reduce_op    = _This->_Reduce_op;
            auto _Transform_op = _This->_Transform_op;
            auto _Chunk1       = _This->_Basis1._Get_chunk(_Key);
            auto _First2 =
                _This->_Basis2._Get_first(_Key._Chunk_number, _This->_Team._Get_chunk_offset(_Key._Chunk_number));
            auto _Next1 = _Chunk1._First;
            auto _Next2 = _First2;
            
            _Ty _Val = _Reduce_op(_Transform_op(*_Chunk1._First, *_First2), _Transform_op(*++_Next1, *++_Next2));
            while (++_Next1 != _Chunk1._Last) {
                
                _Val = _Reduce_op(::std:: move(_Val), _Transform_op(*_Next1, *++_Next2));
            }

            while ((_Key = _This->_Team._Get_next_key())) {
                _Chunk1 = _This->_Basis1._Get_chunk(_Key);
                _First2 =
                    _This->_Basis2._Get_first(_Key._Chunk_number, _This->_Team._Get_chunk_offset(_Key._Chunk_number));
                _Next1 = _Chunk1._First;
                _Next2 = _First2;
                for (; _Next1 != _Chunk1._Last; ++_Next1, (void) ++_Next2) {
                    
                    _Val = _Reduce_op(::std:: move(_Val), _Transform_op(*_Next1, *_Next2));
                }
            }

            _This->_Results._Add_result(::std:: move(_Val));
        }
    }
};

#pragma warning(push)
#pragma warning(disable : 4868) 
                                
template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp1, class _BinOp2,
    _Enable_if_execution_policy_t<_ExPo> >
[[nodiscard]] _Ty transform_reduce(_ExPo&&, _FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _Ty _Val, _BinOp1 _Reduce_op,
    _BinOp2 _Transform_op) noexcept  {
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    _Adl_verify_range(_First1, _Last1);
    auto _UFirst1      = _Get_unwrapped(_First1);
    const auto _ULast1 = _Get_unwrapped(_Last1);
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
        if (_Hw_threads > 1) { 
            const auto _Count  = ::std:: distance(_UFirst1, _ULast1);
            auto _UFirst2      = _Get_unwrapped_n(_First2, _Count);
            const auto _Chunks = _Get_least2_chunked_work_chunk_count(_Hw_threads, _Count);
            if (_Chunks > 1) {
                try {
                auto _Passed_reduce    = _Pass_fn(_Reduce_op);
                auto _Passed_transform = _Pass_fn(_Transform_op);
                _Static_partitioned_transform_reduce_binary2<decltype(_UFirst1), decltype(_UFirst2), _Ty,
                    decltype(_Passed_reduce), decltype(_Passed_transform)>
                    _Operation{_Count, _Chunks, _UFirst1, _UFirst2, _Passed_reduce, _Passed_transform};
                { 
                    const _Work_ptr _Work{_Operation};
                    
                    _Work._Submit_for_chunks(_Hw_threads, _Chunks);
                    while (const auto _Stolen_key = _Operation._Team._Get_next_key()) {
                        const auto _Chunk_number = _Stolen_key._Chunk_number;
                        const auto _Chunk1       = _Operation._Basis1._Get_chunk(_Stolen_key);
                        _Val                     = ::std:: transform_reduce(_Chunk1._First, _Chunk1._Last,
                                                _Operation._Basis2._Get_first(
                                                    _Chunk_number, _Operation._Team._Get_chunk_offset(_Chunk_number)),
                                                ::std:: move(_Val), _Pass_fn(_Reduce_op), _Pass_fn(_Transform_op));
                    }
                } 

                auto& _Results = _Operation._Results; 
                return _Reduce_move_unchecked(_Results.begin(), _Results.end(), ::std:: move(_Val), _Pass_fn(_Reduce_op));
                } catch (const _Parallelism_resources_exhausted&) {
                
                }
            }

            return ::std:: transform_reduce(
                _UFirst1, _ULast1, _UFirst2, ::std:: move(_Val), _Pass_fn(_Reduce_op), _Pass_fn(_Transform_op));
        }
    }

    return ::std:: transform_reduce(_UFirst1, _ULast1,
        _Get_unwrapped_n(_First2, _Idl_distance<_FwdIt1>(_UFirst1, _ULast1)), ::std:: move(_Val), _Pass_fn(_Reduce_op),
        _Pass_fn(_Transform_op));
}
#pragma warning(pop)

template <class _FwdIt, class _Ty, class _BinOp, class _UnaryOp>
struct _Static_partitioned_transform_reduce2 { 
    _Static_partition_team<_Iter_diff_t<_FwdIt>> _Team;
    _Static_partition_range<_FwdIt> _Basis;
    _BinOp _Reduce_op;
    _UnaryOp _Transform_op;
    _Generalized_sum_drop<_Ty> _Results;

    _Static_partitioned_transform_reduce2(const _Iter_diff_t<_FwdIt> _Count, const size_t _Chunks, _FwdIt _First,
        _BinOp _Reduce_op_, _UnaryOp _Transform_op_)
        : _Team{_Count, _Chunks}, _Basis{}, _Reduce_op(_Reduce_op_), _Transform_op(_Transform_op_), _Results{_Chunks} {
        _Basis._Populate(_Team, _First);
    }

    static void __stdcall _Threadpool_callback(
        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept  {
        const auto _This = static_cast<_Static_partitioned_transform_reduce2*>(_Context);
        auto _Key        = _This->_Team._Get_next_key();
        if (_Key) {
            auto& _Reduce_op    = _This->_Reduce_op;
            auto& _Transform_op = _This->_Transform_op;
            auto _Chunk         = _This->_Basis._Get_chunk(_Key);
            auto _Next          = _Chunk._First;
            _Ty _Val{_Reduce_op(_Transform_op(*_Chunk._First), _Transform_op(*++_Next))};
            while (++_Next != _Chunk._Last) {
                _Val = _Reduce_op(::std:: move(_Val), _Transform_op(*_Next));
            }

            while ((_Key = _This->_Team._Get_next_key())) {
                _Chunk = _This->_Basis._Get_chunk(_Key);
                _Next  = _Chunk._First;
                for (; _Next != _Chunk._Last; ++_Next) {
                    _Val = _Reduce_op(::std:: move(_Val), _Transform_op(*_Next));
                }
            }

            _This->_Results._Add_result(::std:: move(_Val));
        }
    }
};

template <class _ExPo, class _FwdIt, class _Ty, class _BinOp, class _UnaryOp,
    _Enable_if_execution_policy_t<_ExPo> >
[[nodiscard]] _Ty transform_reduce(_ExPo&&, const _FwdIt _First, const _FwdIt _Last, _Ty _Val, _BinOp _Reduce_op,
    _UnaryOp _Transform_op) noexcept  {
    
    static_assert(_Is_fwd_iter_v<_FwdIt>, "Parallel algorithms require forward iterators or stronger.");
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
        if (_Hw_threads > 1) { 
            const auto _Count  = ::std:: distance(_UFirst, _ULast);
            const auto _Chunks = _Get_least2_chunked_work_chunk_count(_Hw_threads, _Count);
            if (_Chunks > 1) {
                try {
                auto _Passed_reduce    = _Pass_fn(_Reduce_op);
                auto _Passed_transform = _Pass_fn(_Transform_op);
                _Static_partitioned_transform_reduce2<decltype(_UFirst), _Ty, decltype(_Passed_reduce),
                    decltype(_Passed_transform)>
                    _Operation{_Count, _Chunks, _UFirst, _Passed_reduce, _Passed_transform};
                { 
                    const _Work_ptr _Work{_Operation};
                    
                    _Work._Submit_for_chunks(_Hw_threads, _Chunks);
                    while (auto _Stolen_key = _Operation._Team._Get_next_key()) {
                        
                        auto _Chunk = _Operation._Basis._Get_chunk(_Stolen_key);
                        _Val = ::std:: transform_reduce(_Chunk._First, _Chunk._Last, ::std:: move(_Val), _Pass_fn(_Reduce_op),
                            _Pass_fn(_Transform_op));
                    }
                } 

                auto& _Results = _Operation._Results; 
                return _Reduce_move_unchecked(_Results.begin(), _Results.end(), ::std:: move(_Val), _Pass_fn(_Reduce_op));
                } catch (const _Parallelism_resources_exhausted&) {
                
                }
            }
        }
    }

    return ::std:: transform_reduce(_UFirst, _ULast, ::std:: move(_Val), _Pass_fn(_Reduce_op), _Pass_fn(_Transform_op));
}

struct _No_init_tag {
    explicit _No_init_tag() = default;
}; 

template <class _FwdIt1, class _FwdIt2, class _BinOp, class _Ty>
_FwdIt2 _Exclusive_scan_per_chunk(_FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op, _Ty& _Val) {
    
    
    _Construct_in_place(_Val, *_First);
    for (;;) {
        ++_First;
        ++_Dest;
        if (_First == _Last) {
            return _Dest;
        }

        _Ty _Tmp(_Reduce_op(_Val, *_First)); 
        *_Dest = _Val;
        _Val   = ::std:: move(_Tmp);
    }
}

template <class _FwdIt1, class _FwdIt2, class _BinOp, class _Ty>
void _Exclusive_scan_per_chunk_complete(
    _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op, _Ty& _Val, _Ty& _Init) {
    
    
    _Construct_in_place(_Val, _Reduce_op(_Init, *_First));
    *_Dest = _Init;
    while (++_First != _Last) {
        ++_Dest;
        _Ty _Tmp(_Reduce_op(_Val, *_First)); 
        *_Dest = ::std:: move(_Val);
        _Val   = ::std:: move(_Tmp);
    }
}

template <class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp>
struct _Static_partitioned_exclusive_scan2 {
    using _Diff = _Common_diff_t<_FwdIt1, _FwdIt2>;
    _Static_partition_team<_Diff> _Team;
    _Static_partition_range<_FwdIt1, _Diff> _Basis1;
    _Static_partition_range<_FwdIt2, _Diff> _Basis2;
    _Parallel_vector<_Scan_decoupled_lookback<_Ty>> _Lookback;
    _Ty& _Initial;
    _BinOp _Reduce_op;

    _Static_partitioned_exclusive_scan2(const size_t _Hw_threads, const _Diff _Count, const _FwdIt1 _First,
        _Ty& _Initial_, _BinOp _Reduce_op_, const _FwdIt2&)
        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis1{}, _Basis2{},
          _Lookback(_Team._Chunks), _Initial(_Initial_), _Reduce_op(_Reduce_op_) {
        _Basis1._Populate(_Team, _First);
    }

    _Cancellation_status _Process_chunk() {
        const auto _Key = _Team._Get_next_key();
        if (!_Key) {
            return _Cancellation_status::_Canceled;
        }

        const auto _Chunk_number = _Key._Chunk_number;
        const auto _In_range     = _Basis1._Get_chunk(_Key);
        const auto _Dest         = _Basis2._Get_first(_Chunk_number, _Team._Get_chunk_offset(_Chunk_number));
        
        const auto _Chunk = _Lookback.begin() + static_cast<ptrdiff_t>(_Chunk_number);
        if (_Chunk_number == 0) { 
            _Exclusive_scan_per_chunk_complete(
                _In_range._First, _In_range._Last, _Dest, _Reduce_op, _Chunk->_Sum._Ref(), _Initial);
            _Chunk->_Store_available_state(_Sum_available);
            return _Cancellation_status::_Running;
        }

        const auto _Prev_chunk = _Prev_iter(_Chunk);
        if (_Prev_chunk->_State.load() & _Sum_available) {
            
            _Exclusive_scan_per_chunk_complete(
                _In_range._First, _In_range._Last, _Dest, _Reduce_op, _Chunk->_Sum._Ref(), _Prev_chunk->_Sum._Ref());
            _Chunk->_Store_available_state(_Sum_available);
            return _Cancellation_status::_Running;
        }

        
        const auto _Last =
            _Exclusive_scan_per_chunk(_In_range._First, _In_range._Last, _Dest, _Reduce_op, _Chunk->_Local._Ref());
        _Chunk->_Store_available_state(_Local_available);

        
        if (_Prev_chunk->_Get_available_state() & _Sum_available) { 
            _Chunk->_Apply_exclusive_predecessor(_Prev_chunk->_Sum._Ref(), _Dest, _Last, _Reduce_op);
        } else {
            auto _Tmp = _Get_lookback_sum(_Prev_chunk, _Reduce_op);
            _Chunk->_Apply_exclusive_predecessor(_Tmp, _Dest, _Last, _Reduce_op);
        }

        return _Cancellation_status::_Running;
    }

    static void __stdcall _Threadpool_callback(
        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept  {
        _Run_available_chunked_work(*static_cast<_Static_partitioned_exclusive_scan2*>(_Context));
    }
};

template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp,
    _Enable_if_execution_policy_t<_ExPo> >
_FwdIt2 exclusive_scan(_ExPo&&, const _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _Ty _Val,
    _BinOp _Reduce_op) noexcept  {
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    _Adl_verify_range(_First, _Last);
    const auto _UFirst = _Get_unwrapped(_First);
    const auto _ULast  = _Get_unwrapped(_Last);
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
        if (_Hw_threads > 1) { 
            const auto _Count = ::std:: distance(_UFirst, _ULast);
            const auto _UDest = _Get_unwrapped_n(_Dest, _Count);
            if (_Count >= 2) { 
                try {
                _Static_partitioned_exclusive_scan2 _Operation{
                    _Hw_threads, _Count, _UFirst, _Val, _Pass_fn(_Reduce_op), _UDest};
                _Seek_wrapped(_Dest, _Operation._Basis2._Populate(_Operation._Team, _UDest));
                
                
                _Run_chunked_parallel_work(_Hw_threads, _Operation);
                return _Dest;
                } catch (const _Parallelism_resources_exhausted&) {
                
                }
            }

            _Seek_wrapped(_Dest, ::std:: exclusive_scan(_UFirst, _ULast, _UDest, ::std:: move(_Val), _Pass_fn(_Reduce_op)));
            return _Dest;
        }
    }

    _Seek_wrapped(
        _Dest, ::std:: exclusive_scan(_UFirst, _ULast, _Get_unwrapped_n(_Dest, _Idl_distance<_FwdIt1>(_UFirst, _ULast)),
                   ::std:: move(_Val), _Pass_fn(_Reduce_op)));
    return _Dest;
}

template <class _FwdIt1, class _FwdIt2, class _BinOp, class _Ty>
_FwdIt2 _Inclusive_scan_per_chunk(
    _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op, _Ty& _Val, _No_init_tag) {
    
    
    _Construct_in_place(_Val, *_First);
    for (;;) {
        *_Dest = _Val;
        ++_Dest;
        ++_First;
        if (_First == _Last) {
            return _Dest;
        }

        _Val = _Reduce_op(::std:: move(_Val), *_First);
    }
}

template <class _FwdIt1, class _FwdIt2, class _BinOp, class _Ty, class _Ty_fwd,
    enable_if_t<!is_same_v<_No_init_tag, remove_const_t<remove_reference_t<_Ty_fwd>>>, int> = 0>
_FwdIt2 _Inclusive_scan_per_chunk(
    _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op, _Ty& _Val, _Ty_fwd&& _Predecessor) {
    
    
    _Construct_in_place(_Val, _Reduce_op(::std:: forward<_Ty_fwd>(_Predecessor), *_First));
    for (;;) {
        *_Dest = _Val;
        ++_Dest;
        ++_First;
        if (_First == _Last) {
            return _Dest;
        }

        _Val = _Reduce_op(::std:: move(_Val), *_First);
    }
}

template <class _Ty, class _Init_ty, class _FwdIt1, class _FwdIt2, class _BinOp>
struct _Static_partitioned_inclusive_scan2 {
    using _Diff = _Common_diff_t<_FwdIt1, _FwdIt2>;
    _Static_partition_team<_Diff> _Team;
    _Static_partition_range<_FwdIt1, _Diff> _Basis1;
    _Static_partition_range<_FwdIt2, _Diff> _Basis2;
    _Parallel_vector<_Scan_decoupled_lookback<_Ty>> _Lookback;
    _BinOp _Reduce_op;
    _Init_ty& _Initial;

    _Static_partitioned_inclusive_scan2(
        const size_t _Hw_threads, const _Diff _Count, _BinOp _Reduce_op_, _Init_ty& _Initial_)
        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis1{}, _Basis2{},
          _Lookback(_Team._Chunks), _Reduce_op(_Reduce_op_), _Initial(_Initial_) {}

    _Cancellation_status _Process_chunk() {
        const auto _Key = _Team._Get_next_key();
        if (!_Key) {
            return _Cancellation_status::_Canceled;
        }

        const auto _Chunk_number = _Key._Chunk_number;
        const auto _In_range     = _Basis1._Get_chunk(_Key);
        const auto _Dest         = _Basis2._Get_first(_Chunk_number, _Team._Get_chunk_offset(_Chunk_number));
        
        const auto _Chunk = _Lookback.begin() + static_cast<ptrdiff_t>(_Chunk_number);
        if (_Chunk_number == 0) { 
            _Inclusive_scan_per_chunk(
                _In_range._First, _In_range._Last, _Dest, _Reduce_op, _Chunk->_Sum._Ref(), ::std:: move(_Initial));
            _Chunk->_Store_available_state(_Sum_available);
            return _Cancellation_status::_Running;
        }

        const auto _Prev_chunk = _Prev_iter(_Chunk);
        if (_Prev_chunk->_State.load() & _Sum_available) {
            
            _Inclusive_scan_per_chunk(
                _In_range._First, _In_range._Last, _Dest, _Reduce_op, _Chunk->_Sum._Ref(), _Prev_chunk->_Sum._Ref());
            _Chunk->_Store_available_state(_Sum_available);
            return _Cancellation_status::_Running;
        }

        
        const auto _Last = _Inclusive_scan_per_chunk(
            _In_range._First, _In_range._Last, _Dest, _Reduce_op, _Chunk->_Local._Ref(), _No_init_tag{});
        _Chunk->_Store_available_state(_Local_available);

        
        if (_Prev_chunk->_Get_available_state() & _Sum_available) { 
            _Chunk->_Apply_inclusive_predecessor(_Prev_chunk->_Sum._Ref(), _Dest, _Last, _Reduce_op);
        } else {
            auto _Tmp = _Get_lookback_sum(_Prev_chunk, _Reduce_op);
            _Chunk->_Apply_inclusive_predecessor(_Tmp, _Dest, _Last, _Reduce_op);
        }

        return _Cancellation_status::_Running;
    }

    static void __stdcall _Threadpool_callback(
        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept  {
        _Run_available_chunked_work(*static_cast<_Static_partitioned_inclusive_scan2*>(_Context));
    }
};

template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp, class _Ty,
    _Enable_if_execution_policy_t<_ExPo> >
_FwdIt2 inclusive_scan(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op, _Ty _Val) noexcept
 {
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    _Adl_verify_range(_First, _Last);
    const auto _UFirst = _Get_unwrapped(_First);
    const auto _ULast  = _Get_unwrapped(_Last);
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
        if (_Hw_threads > 1) { 
            const auto _Count = ::std:: distance(_First, _Last);
            auto _UDest       = _Get_unwrapped_n(_Dest, _Count);
            if (_Count >= 2) { 
                try {
                auto _Passed_op = _Pass_fn(_Reduce_op);
                _Static_partitioned_inclusive_scan2<_Ty, _Ty, _Unwrapped_t<const _FwdIt1&>, decltype(_UDest),
                    decltype(_Passed_op)>
                    _Operation{_Hw_threads, _Count, _Passed_op, _Val};
                _Operation._Basis1._Populate(_Operation._Team, _UFirst);
                _Seek_wrapped(_Dest, _Operation._Basis2._Populate(_Operation._Team, _UDest));
                
                
                _Run_chunked_parallel_work(_Hw_threads, _Operation);
                return _Dest;
                } catch (const _Parallelism_resources_exhausted&) {
                
                }
            }

            _Seek_wrapped(_Dest, ::std:: inclusive_scan(_UFirst, _ULast, _UDest, _Pass_fn(_Reduce_op), ::std:: move(_Val)));
            return _Dest;
        }
    }

    _Seek_wrapped(
        _Dest, ::std:: inclusive_scan(_UFirst, _ULast, _Get_unwrapped_n(_Dest, _Idl_distance<_FwdIt1>(_UFirst, _ULast)),
                   _Pass_fn(_Reduce_op), ::std:: move(_Val)));
    return _Dest;
}

template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp, _Enable_if_execution_policy_t<_ExPo> >
_FwdIt2 inclusive_scan(_ExPo&&, _FwdIt1 _First, _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op) noexcept
 {
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    _Adl_verify_range(_First, _Last);
    const auto _UFirst = _Get_unwrapped(_First);
    const auto _ULast  = _Get_unwrapped(_Last);
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
        if (_Hw_threads > 1) { 
            const auto _Count = ::std:: distance(_UFirst, _ULast);
            auto _UDest       = _Get_unwrapped_n(_Dest, _Count);
            if (_Count >= 2) { 
                try {
                _No_init_tag _Tag;
                auto _Passed_op = _Pass_fn(_Reduce_op);
                _Static_partitioned_inclusive_scan2<_Iter_value_t<_FwdIt1>, _No_init_tag, _Unwrapped_t<const _FwdIt1&>,
                    decltype(_UDest), decltype(_Passed_op)>
                    _Operation{_Hw_threads, _Count, _Passed_op, _Tag};
                _Operation._Basis1._Populate(_Operation._Team, _UFirst);
                _Seek_wrapped(_Dest, _Operation._Basis2._Populate(_Operation._Team, _UDest));
                _Run_chunked_parallel_work(_Hw_threads, _Operation);
                return _Dest;
                } catch (const _Parallelism_resources_exhausted&) {
                
                }
            }

            _Seek_wrapped(_Dest, ::std:: inclusive_scan(_UFirst, _ULast, _UDest, _Pass_fn(_Reduce_op)));
            return _Dest;
        }
    }

    _Seek_wrapped(_Dest, ::std:: inclusive_scan(_UFirst, _ULast,
                             _Get_unwrapped_n(_Dest, _Idl_distance<_FwdIt1>(_UFirst, _ULast)), _Pass_fn(_Reduce_op)));
    return _Dest;
}

template <class _FwdIt1, class _FwdIt2, class _BinOp, class _UnaryOp, class _Ty>
_FwdIt2 _Transform_exclusive_scan_per_chunk(
    _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op, _UnaryOp _Transform_op, _Ty& _Val) {
    
    
    _Construct_in_place(_Val, _Transform_op(*_First));
    for (;;) {
        ++_First;
        ++_Dest;
        if (_First == _Last) {
            return _Dest;
        }

        _Ty _Tmp(_Reduce_op(_Val, _Transform_op(*_First))); 
        *_Dest = _Val;
        _Val   = ::std:: move(_Tmp);
    }
}

template <class _FwdIt1, class _FwdIt2, class _BinOp, class _UnaryOp, class _Ty>
void _Transform_exclusive_scan_per_chunk_complete(_FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op,
    _UnaryOp _Transform_op, _Ty& _Val, _Ty& _Init) {
    
    
    _Construct_in_place(_Val, _Reduce_op(_Init, _Transform_op(*_First)));
    *_Dest = _Init;
    while (++_First != _Last) {
        ++_Dest;
        _Ty _Tmp(_Reduce_op(_Val, _Transform_op(*_First))); 
        *_Dest = ::std:: move(_Val);
        _Val   = ::std:: move(_Tmp);
    }
}

template <class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp, class _UnaryOp>
struct _Static_partitioned_transform_exclusive_scan2 {
    using _Diff = _Common_diff_t<_FwdIt1, _FwdIt2>;
    _Static_partition_team<_Diff> _Team;
    _Static_partition_range<_FwdIt1, _Diff> _Basis1;
    _Static_partition_range<_FwdIt2, _Diff> _Basis2;
    _Parallel_vector<_Scan_decoupled_lookback<_Ty>> _Lookback;
    _Ty& _Initial;
    _BinOp _Reduce_op;
    _UnaryOp _Transform_op;

    _Static_partitioned_transform_exclusive_scan2(const size_t _Hw_threads, const _Diff _Count, const _FwdIt1 _First,
        _Ty& _Initial_, _BinOp _Reduce_op_, _UnaryOp _Transform_op_, const _FwdIt2&)
        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis1{}, _Basis2{},
          _Lookback(_Team._Chunks), _Initial(_Initial_), _Reduce_op(_Reduce_op_), _Transform_op(_Transform_op_) {
        _Basis1._Populate(_Team, _First);
    }

    _Cancellation_status _Process_chunk() {
        const auto _Key = _Team._Get_next_key();
        if (!_Key) {
            return _Cancellation_status::_Canceled;
        }

        const auto _Chunk_number = _Key._Chunk_number;
        const auto _In_range     = _Basis1._Get_chunk(_Key);
        const auto _Dest         = _Basis2._Get_first(_Chunk_number, _Team._Get_chunk_offset(_Chunk_number));
        
        const auto _Chunk = _Lookback.begin() + static_cast<ptrdiff_t>(_Chunk_number);
        if (_Chunk_number == 0) { 
            _Transform_exclusive_scan_per_chunk_complete(
                _In_range._First, _In_range._Last, _Dest, _Reduce_op, _Transform_op, _Chunk->_Sum._Ref(), _Initial);
            _Chunk->_Store_available_state(_Sum_available);
            return _Cancellation_status::_Running;
        }

        const auto _Prev_chunk = _Prev_iter(_Chunk);
        if (_Prev_chunk->_State.load() & _Sum_available) {
            
            _Transform_exclusive_scan_per_chunk_complete(_In_range._First, _In_range._Last, _Dest, _Reduce_op,
                _Transform_op, _Chunk->_Sum._Ref(), _Prev_chunk->_Sum._Ref());
            _Chunk->_Store_available_state(_Sum_available);
            return _Cancellation_status::_Running;
        }

        
        const auto _Last = _Transform_exclusive_scan_per_chunk(
            _In_range._First, _In_range._Last, _Dest, _Reduce_op, _Transform_op, _Chunk->_Local._Ref());
        _Chunk->_Store_available_state(_Local_available);

        
        if (_Prev_chunk->_Get_available_state() & _Sum_available) { 
            _Chunk->_Apply_exclusive_predecessor(_Prev_chunk->_Sum._Ref(), _Dest, _Last, _Reduce_op);
        } else {
            auto _Tmp = _Get_lookback_sum(_Prev_chunk, _Reduce_op);
            _Chunk->_Apply_exclusive_predecessor(_Tmp, _Dest, _Last, _Reduce_op);
        }

        return _Cancellation_status::_Running;
    }

    static void __stdcall _Threadpool_callback(
        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept  {
        _Run_available_chunked_work(*static_cast<_Static_partitioned_transform_exclusive_scan2*>(_Context));
    }
};

template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp, class _UnaryOp,
    _Enable_if_execution_policy_t<_ExPo> >
_FwdIt2 transform_exclusive_scan(_ExPo&&, const _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _Ty _Val,
    _BinOp _Reduce_op, _UnaryOp _Transform_op) noexcept  {
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    _Adl_verify_range(_First, _Last);
    const auto _UFirst = _Get_unwrapped(_First);
    const auto _ULast  = _Get_unwrapped(_Last);
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
        if (_Hw_threads > 1) { 
            const auto _Count = ::std:: distance(_UFirst, _ULast);
            const auto _UDest = _Get_unwrapped_n(_Dest, _Count);
            if (_Count >= 2) { 
                try {
                _Static_partitioned_transform_exclusive_scan2 _Operation{
                    _Hw_threads, _Count, _UFirst, _Val, _Pass_fn(_Reduce_op), _Pass_fn(_Transform_op), _UDest};
                _Seek_wrapped(_Dest, _Operation._Basis2._Populate(_Operation._Team, _UDest));
                
                
                _Run_chunked_parallel_work(_Hw_threads, _Operation);
                return _Dest;
                } catch (const _Parallelism_resources_exhausted&) {
                
                }
            }

            _Seek_wrapped(_Dest, ::std:: transform_exclusive_scan(_UFirst, _ULast, _UDest, ::std:: move(_Val),
                                     _Pass_fn(_Reduce_op), _Pass_fn(_Transform_op)));
            return _Dest;
        }
    }

    _Seek_wrapped(_Dest,
        ::std:: transform_exclusive_scan(_UFirst, _ULast, _Get_unwrapped_n(_Dest, _Idl_distance<_FwdIt1>(_UFirst, _ULast)),
            ::std:: move(_Val), _Pass_fn(_Reduce_op), _Pass_fn(_Transform_op)));
    return _Dest;
}

template <class _FwdIt1, class _FwdIt2, class _BinOp, class _UnaryOp, class _Ty>
_FwdIt2 _Transform_inclusive_scan_per_chunk(_FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op,
    _UnaryOp _Transform_op, _Ty& _Val, _No_init_tag) {
    
    
    _Construct_in_place(_Val, _Transform_op(*_First));
    for (;;) {
        *_Dest = _Val;
        ++_Dest;
        ++_First;
        if (_First == _Last) {
            return _Dest;
        }

        _Val = _Reduce_op(::std:: move(_Val), _Transform_op(*_First));
    }
}

template <class _FwdIt1, class _FwdIt2, class _BinOp, class _UnaryOp, class _Ty, class _Ty_fwd,
    enable_if_t<!is_same_v<_No_init_tag, remove_const_t<remove_reference_t<_Ty_fwd>>>, int> = 0>
_FwdIt2 _Transform_inclusive_scan_per_chunk(_FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op,
    _UnaryOp _Transform_op, _Ty& _Val, _Ty_fwd&& _Predecessor) {
    
    
    _Construct_in_place(_Val, _Reduce_op(::std:: forward<_Ty_fwd>(_Predecessor), _Transform_op(*_First)));
    for (;;) {
        *_Dest = _Val;
        ++_Dest;
        ++_First;
        if (_First == _Last) {
            return _Dest;
        }

        _Val = _Reduce_op(::std:: move(_Val), _Transform_op(*_First));
    }
}

template <class _Ty, class _Init_ty, class _FwdIt1, class _FwdIt2, class _BinOp, class _UnaryOp>
struct _Static_partitioned_transform_inclusive_scan2 {
    using _Diff = _Common_diff_t<_FwdIt1, _FwdIt2>;
    _Static_partition_team<_Diff> _Team;
    _Static_partition_range<_FwdIt1, _Diff> _Basis1;
    _Static_partition_range<_FwdIt2, _Diff> _Basis2;
    _Parallel_vector<_Scan_decoupled_lookback<_Ty>> _Lookback;
    _BinOp _Reduce_op;
    _UnaryOp _Transform_op;
    _Init_ty& _Initial;

    _Static_partitioned_transform_inclusive_scan2(
        const size_t _Hw_threads, const _Diff _Count, _BinOp _Reduce_op_, _UnaryOp _Transform_op_, _Init_ty& _Initial_)
        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis1{}, _Basis2{},
          _Lookback(_Team._Chunks), _Reduce_op(_Reduce_op_), _Transform_op(_Transform_op_), _Initial(_Initial_) {}

    _Cancellation_status _Process_chunk() {
        const auto _Key = _Team._Get_next_key();
        if (!_Key) {
            return _Cancellation_status::_Canceled;
        }

        const auto _Chunk_number = _Key._Chunk_number;
        const auto _In_range     = _Basis1._Get_chunk(_Key);
        const auto _Dest         = _Basis2._Get_first(_Chunk_number, _Team._Get_chunk_offset(_Chunk_number));
        
        const auto _Chunk = _Lookback.begin() + static_cast<ptrdiff_t>(_Chunk_number);
        if (_Chunk_number == 0) { 
            _Transform_inclusive_scan_per_chunk(_In_range._First, _In_range._Last, _Dest, _Reduce_op, _Transform_op,
                _Chunk->_Sum._Ref(), ::std:: move(_Initial));
            _Chunk->_Store_available_state(_Sum_available);
            return _Cancellation_status::_Running;
        }

        const auto _Prev_chunk = _Prev_iter(_Chunk);
        if (_Prev_chunk->_State.load() & _Sum_available) {
            
            _Transform_inclusive_scan_per_chunk(_In_range._First, _In_range._Last, _Dest, _Reduce_op, _Transform_op,
                _Chunk->_Sum._Ref(), _Prev_chunk->_Sum._Ref());
            _Chunk->_Store_available_state(_Sum_available);
            return _Cancellation_status::_Running;
        }

        
        const auto _Last = _Transform_inclusive_scan_per_chunk(
            _In_range._First, _In_range._Last, _Dest, _Reduce_op, _Transform_op, _Chunk->_Local._Ref(), _No_init_tag{});
        _Chunk->_Store_available_state(_Local_available);

        
        if (_Prev_chunk->_Get_available_state() & _Sum_available) { 
            _Chunk->_Apply_inclusive_predecessor(_Prev_chunk->_Sum._Ref(), _Dest, _Last, _Reduce_op);
        } else {
            auto _Tmp = _Get_lookback_sum(_Prev_chunk, _Reduce_op);
            _Chunk->_Apply_inclusive_predecessor(_Tmp, _Dest, _Last, _Reduce_op);
        }

        return _Cancellation_status::_Running;
    }

    static void __stdcall _Threadpool_callback(
        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept  {
        _Run_available_chunked_work(*static_cast<_Static_partitioned_transform_inclusive_scan2*>(_Context));
    }
};

template <class _ExPo, class _FwdIt1, class _FwdIt2, class _Ty, class _BinOp, class _UnaryOp,
    _Enable_if_execution_policy_t<_ExPo> >
_FwdIt2 transform_inclusive_scan(_ExPo&&, const _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op,
    _UnaryOp _Transform_op, _Ty _Val) noexcept  {
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    _Adl_verify_range(_First, _Last);
    const auto _UFirst = _Get_unwrapped(_First);
    const auto _ULast  = _Get_unwrapped(_Last);
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
        if (_Hw_threads > 1) { 
            const auto _Count = ::std:: distance(_UFirst, _ULast);
            auto _UDest       = _Get_unwrapped_n(_Dest, _Count);
            if (_Count >= 2) { 
                try {
                auto _Passed_reduce    = _Pass_fn(_Reduce_op);
                auto _Passed_transform = _Pass_fn(_Transform_op);
                _Static_partitioned_transform_inclusive_scan2<_Ty, _Ty, _Unwrapped_t<const _FwdIt1&>, decltype(_UDest),
                    decltype(_Passed_reduce), decltype(_Passed_transform)>
                    _Operation{_Hw_threads, _Count, _Passed_reduce, _Passed_transform, _Val};
                _Operation._Basis1._Populate(_Operation._Team, _UFirst);
                _Seek_wrapped(_Dest, _Operation._Basis2._Populate(_Operation._Team, _UDest));
                
                
                _Run_chunked_parallel_work(_Hw_threads, _Operation);
                return _Dest;
                } catch (const _Parallelism_resources_exhausted&) {
                
                }
            }

            _Seek_wrapped(_Dest, ::std:: transform_inclusive_scan(_UFirst, _ULast, _UDest, _Pass_fn(_Reduce_op),
                                     _Pass_fn(_Transform_op), ::std:: move(_Val)));
            return _Dest;
        }
    }

    _Seek_wrapped(_Dest,
        ::std:: transform_inclusive_scan(_UFirst, _ULast, _Get_unwrapped_n(_Dest, _Idl_distance<_FwdIt1>(_UFirst, _ULast)),
            _Pass_fn(_Reduce_op), _Pass_fn(_Transform_op), ::std:: move(_Val)));
    return _Dest;
}

template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp, class _UnaryOp,
    _Enable_if_execution_policy_t<_ExPo> >
_FwdIt2 transform_inclusive_scan(_ExPo&&, const _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Reduce_op,
    _UnaryOp _Transform_op) noexcept  {
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    _Adl_verify_range(_First, _Last);
    const auto _UFirst = _Get_unwrapped(_First);
    const auto _ULast  = _Get_unwrapped(_Last);
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
        if (_Hw_threads > 1) { 
            const auto _Count = ::std:: distance(_UFirst, _ULast);
            auto _UDest       = _Get_unwrapped_n(_Dest, _Count);
            if (_Count >= 2) { 
                try {
                _No_init_tag _Tag;
                auto _Passed_reduce    = _Pass_fn(_Reduce_op);
                auto _Passed_transform = _Pass_fn(_Transform_op);
                using _Intermediate_t  = decay_t<decltype(_Transform_op(*_UFirst))>;
                _Static_partitioned_transform_inclusive_scan2<_Intermediate_t, _No_init_tag,
                    _Unwrapped_t<const _FwdIt1&>, decltype(_UDest), decltype(_Passed_reduce),
                    decltype(_Passed_transform)>
                    _Operation{_Hw_threads, _Count, _Passed_reduce, _Passed_transform, _Tag};
                _Operation._Basis1._Populate(_Operation._Team, _UFirst);
                _Seek_wrapped(_Dest, _Operation._Basis2._Populate(_Operation._Team, _UDest));
                _Run_chunked_parallel_work(_Hw_threads, _Operation);
                return _Dest;
                } catch (const _Parallelism_resources_exhausted&) {
                
                }
            }

            _Seek_wrapped(_Dest,
                ::std:: transform_inclusive_scan(_UFirst, _ULast, _UDest, _Pass_fn(_Reduce_op), _Pass_fn(_Transform_op)));
            return _Dest;
        }
    }

    _Seek_wrapped(_Dest,
        ::std:: transform_inclusive_scan(_UFirst, _ULast, _Get_unwrapped_n(_Dest, _Idl_distance<_FwdIt1>(_UFirst, _ULast)),
            _Pass_fn(_Reduce_op), _Pass_fn(_Transform_op)));
    return _Dest;
}

template <class _FwdIt1, class _FwdIt2, class _BinOp>
struct _Static_partitioned_adjacent_difference2 {
    using _Diff = _Common_diff_t<_FwdIt1, _FwdIt2>;
    _Static_partition_team<_Diff> _Team;
    
    _Static_partition_range<_FwdIt1, _Diff> _Basis1; 
    _Static_partition_range<_FwdIt2, _Diff> _Basis2; 
    _BinOp _Diff_op;

    _Static_partitioned_adjacent_difference2(
        const size_t _Hw_threads, const _Diff _Count, const _FwdIt1 _First, _BinOp _Diff_op_, const _FwdIt2&)
        : _Team{_Count, _Get_chunked_work_chunk_count(_Hw_threads, _Count)}, _Basis1{}, _Basis2{}, _Diff_op(_Diff_op_) {
        _Basis1._Populate(_Team, _First);
    }

    _Cancellation_status _Process_chunk() {
        const auto _Key = _Team._Get_next_key();
        if (!_Key) {
            return _Cancellation_status::_Canceled;
        }

        const auto _Chunk_number = _Key._Chunk_number;
        auto _In_range           = _Basis1._Get_chunk(_Key);
        auto _Dest               = _Basis2._Get_first(_Chunk_number, _Team._Get_chunk_offset(_Chunk_number));
        auto _Next               = _In_range._First;
        do {
            ++_Next; 
            *_Dest = _Diff_op(*_Next, *_In_range._First);
            ++_Dest;
            _In_range._First = _Next;
        } while (_In_range._First != _In_range._Last);

        return _Cancellation_status::_Running;
    }

    static void __stdcall _Threadpool_callback(
        __std_PTP_CALLBACK_INSTANCE, void* const _Context, __std_PTP_WORK) noexcept  {
        _Run_available_chunked_work(*static_cast<_Static_partitioned_adjacent_difference2*>(_Context));
    }
};

template <class _FwdIt1, class _FwdIt2, class _BinOp>
_FwdIt2 _Adjacent_difference_seq(_FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Diff_op) {
    
    if (_First != _Last) {
        *_Dest = *_First;
        ++_Dest;
        for (auto _Next = _First; ++_Next != _Last; _First = _Next) {
            *_Dest = _Diff_op(*_Next, *_First);
            ++_Dest;
        }
    }

    return _Dest;
}

template <class _ExPo, class _FwdIt1, class _FwdIt2, class _BinOp, _Enable_if_execution_policy_t<_ExPo> >
_FwdIt2 adjacent_difference(_ExPo&&, const _FwdIt1 _First, const _FwdIt1 _Last, _FwdIt2 _Dest, _BinOp _Diff_op) noexcept
 {
    
    static_assert(_Is_fwd_iter_v<_FwdIt1>, "Parallel algorithms require forward iterators or stronger.");
    static_assert(_Is_fwd_iter_v<_FwdIt2>, "Parallel algorithms require forward iterators or stronger.");
    _Adl_verify_range(_First, _Last);
    auto _UFirst      = _Get_unwrapped(_First);
    const auto _ULast = _Get_unwrapped(_Last);
    if constexpr (remove_reference_t<_ExPo>::_Parallelize) {
        const size_t _Hw_threads = __std_parallel_algorithms_hw_threads();
        if (_Hw_threads > 1) { 
            auto _Count       = ::std:: distance(_UFirst, _ULast);
            const auto _UDest = _Get_unwrapped_n(_Dest, _Count);
            if (_Count >= 2) { 
                try {
                --_Count; 
                _Static_partitioned_adjacent_difference2 _Operation{
                    _Hw_threads, _Count, _UFirst, _Pass_fn(_Diff_op), _UDest};
                auto _Result = _Operation._Basis2._Populate(_Operation._Team, _Next_iter(_UDest));
                const _Work_ptr _Work_op{_Operation};
                
                _Work_op._Submit_for_chunks(_Hw_threads, _Operation._Team._Chunks);
                
                *_UDest = *_UFirst;
                _Run_available_chunked_work(_Operation);
                _Seek_wrapped(_Dest, _Result);
                return _Dest;
                } catch (const _Parallelism_resources_exhausted&) {
                
                }
            }

            _Seek_wrapped(_Dest, _Adjacent_difference_seq(_UFirst, _ULast, _UDest, _Pass_fn(_Diff_op)));
            return _Dest;
        }
    }

    
    _Seek_wrapped(_Dest, _Adjacent_difference_seq(_UFirst, _ULast,
                             _Get_unwrapped_n(_Dest, _Idl_distance<_FwdIt1>(_UFirst, _ULast)), _Pass_fn(_Diff_op)));
    return _Dest;
}
}


#pragma warning(pop)
#pragma pack(pop)
#line 5060 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\execution"
#line 5061 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\execution"
#line 5062 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\execution"
#line 72 "all-std.cxx"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cfenv"


#pragma once


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\fenv.h"


#pragma once


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


 int __cdecl fegetround(void);
 int __cdecl fesetround(  int _Round);


    typedef unsigned long fexcept_t;

    typedef struct fenv_t
    {
        unsigned long _Fe_ctl, _Fe_stat;
    } fenv_t;


     int __cdecl fegetenv(  fenv_t* _Env);
     int __cdecl fesetenv(  fenv_t const* _Env);
     int __cdecl feclearexcept(  int _Flags);
       int __cdecl feholdexcept(  fenv_t* _Env);
     int __cdecl fetestexcept(  int _Flags);
     int __cdecl fegetexceptflag(  fexcept_t* _Except,   int _TestFlags);
     int __cdecl fesetexceptflag(  fexcept_t const* _Except,   int _SetFlags);

    
            __declspec(selectany) extern const fenv_t _Fenv1 = { 0x3f3f103f, 0 };
        

#line 74 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\fenv.h"
    #line 75 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\fenv.h"

    
        #line 96 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\fenv.h"
        __pragma(optimize("", off))
        __inline int __cdecl feraiseexcept(  int _Except)
        {
            static struct
            {
                int    _Except_Val;
                double _Num;
                double _Denom;
            } const _Table[] =
            {  
                {0x00000010,   0.0,    0.0    },
                {0x00000008, 1.0,    0.0    },
                {0x00000004,  1e+300, 1e-300 },
                {0x00000002, 1e-300, 1e+300 },
                {0x00000001,   2.0,    3.0    }
            };

            double _Ans = 0.0;
            size_t _Index;

            if ((_Except &= (0x00000008 | 0x00000001 | 0x00000010 | 0x00000004 | 0x00000002)) == 0)
            {
                return 0;
            }

            
            for (_Index = 0; _Index < sizeof(_Table) / sizeof(_Table[0]); ++_Index)
            {
                if ((_Except & _Table[_Index]._Except_Val) != 0)
                {
                    _Ans = _Table[_Index]._Num / _Table[_Index]._Denom;

                    
#line 134 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\fenv.h"
                }
            }

            return 0;
        }
        __pragma(optimize("", on))

        __inline int __cdecl feupdateenv(  const fenv_t *_Penv)
        {
            int _Except = fetestexcept((0x00000008 | 0x00000001 | 0x00000010 | 0x00000004 | 0x00000002));

            if (fesetenv(_Penv) != 0 || feraiseexcept(_Except) != 0)
            {
                return 1;
            }

            return 0;
        }
    #line 153 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\fenv.h"

#line 155 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\fenv.h"

} __pragma(pack(pop))

#pragma warning(pop) 
#line 160 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\fenv.h"
#line 13 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cfenv"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
using :: fegetround;
using :: fesetround;


using :: feclearexcept;
using :: fegetenv;
using :: fegetexceptflag;
using :: feholdexcept;
using :: fenv_t;
using :: fesetenv;
using :: fesetexceptflag;
using :: fetestexcept;
using :: fexcept_t;
#line 36 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cfenv"


using :: feraiseexcept;
using :: feupdateenv;
#line 41 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cfenv"
}


#pragma warning(pop)
#pragma pack(pop)

#line 49 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cfenv"
#line 50 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\cfenv"
#line 74 "all-std.cxx"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\complex"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ymath.h"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


extern "C" {


void __cdecl _Feraise(int);

union _Dconst { 
    unsigned short _Word[8]; 
    float _Float;
    double _Double;
    long double _Long_double;
};

 double __cdecl _Cosh(double, double);
 short __cdecl _Dtest(double*);
 double __cdecl _Sinh(double, double);

 short __cdecl _Exp(double*, double, short);
extern  _Dconst _Denorm;
extern  _Dconst _Hugeval;
extern  _Dconst _Inf;
extern  _Dconst _Nan;
extern  _Dconst _Snan;

 float __cdecl _FCosh(float, float);
 short __cdecl _FDtest(float*);
 float __cdecl _FSinh(float, float);

 short __cdecl _FExp(float*, float, short);
extern  _Dconst _FDenorm;
extern  _Dconst _FInf;
extern  _Dconst _FNan;
extern  _Dconst _FSnan;

 long double __cdecl _LCosh(long double, long double);
 short __cdecl _LDtest(long double*);
 long double __cdecl _LSinh(long double, long double);

 short __cdecl _LExp(long double*, long double, short);
extern  _Dconst _LDenorm;
extern  _Dconst _LInf;
extern  _Dconst _LNan;
extern  _Dconst _LSnan;

}


#pragma warning(pop)
#pragma pack(pop)
#line 73 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ymath.h"
#line 74 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ymath.h"
#line 18 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\complex"


#line 24 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\complex"


extern "C" int __isa_available;
extern "C" __m128d __cdecl _mm_fmsub_sd(__m128d, __m128d, __m128d);


#line 33 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\complex"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


struct _C_double_complex {
    double _Val[2];
};

struct _C_float_complex {
    float _Val[2];
};

struct _C_ldouble_complex {
    long double _Val[2];
};
#line 56 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\complex"


namespace std {


#pragma float_control(precise, on, push)
namespace _Float_multi_prec {
    
    template <class _Ty, int _Prec>
    struct _Fmp_t;

    template <class _Ty>
    struct _Fmp_t<_Ty, 2> {
        static_assert(is_floating_point_v<_Ty>, "_Ty must be floating-point");
        _Ty _Val0; 
        _Ty _Val1; 
    };

    
    template <class _Ty>
    [[nodiscard]] constexpr _Fmp_t<_Ty, 2> _Add_x2(const _Ty _Xval, const _Ty _Yval) noexcept {
        const _Ty _Sum0 = _Xval + _Yval;
        const _Ty _Ymod = _Sum0 - _Xval;
        const _Ty _Xmod = _Sum0 - _Ymod;
        const _Ty _Yerr = _Yval - _Ymod;
        const _Ty _Xerr = _Xval - _Xmod;
        return {_Sum0, _Xerr + _Yerr};
    }

    
    template <class _Ty>
    [[nodiscard]] constexpr _Fmp_t<_Ty, 2> _Add_small_x2(const _Ty _Xval, const _Ty _Yval) noexcept {
        const _Ty _Sum0 = _Xval + _Yval;
        const _Ty _Ymod = _Sum0 - _Xval;
        const _Ty _Yerr = _Yval - _Ymod;
        return {_Sum0, _Yerr};
    }

    
    template <class _Ty>
    [[nodiscard]] constexpr _Fmp_t<_Ty, 2> _Add_small_x2(const _Ty _Xval, const _Fmp_t<_Ty, 2>& _Yval) noexcept {
        const _Fmp_t<_Ty, 2> _Sum0 = _Add_small_x2(_Xval, _Yval._Val0);
        return _Add_small_x2(_Sum0._Val0, _Sum0._Val1 + _Yval._Val1);
    }

    
    template <class _Ty>
    [[nodiscard]] constexpr _Ty _Add_x1(const _Fmp_t<_Ty, 2>& _Xval, const _Fmp_t<_Ty, 2>& _Yval) noexcept {
        const _Fmp_t<_Ty, 2> _Sum00 = _Add_x2(_Xval._Val0, _Yval._Val0);
        return _Sum00._Val0 + (_Sum00._Val1 + (_Xval._Val1 + _Yval._Val1));
    }

    
    [[nodiscard]] constexpr double _High_half(const double _Val) noexcept {
        const auto _Bits           = _Bit_cast<unsigned long long>(_Val);
        const auto _High_half_bits = (_Bits + 0x3ff'ffffULL) & 0xffff'ffff'f800'0000ULL;
        return _Bit_cast<double>(_High_half_bits);
    }

    
    [[nodiscard]] constexpr double _Sqr_error_fallback(const double _Xval, const double _Prod0) noexcept {
        const double _Xhigh = _High_half(_Xval);
        const double _Xlow  = _Xval - _Xhigh;
        return ((_Xhigh * _Xhigh - _Prod0) + 2.0 * _Xhigh * _Xlow) + _Xlow * _Xlow;
    }


    [[nodiscard]] inline double _Sqr_error_x86_x64_fma(const double _Xval, const double _Prod0) noexcept {
        const __m128d _Mx      = _mm_set_sd(_Xval);
        const __m128d _Mprod0  = _mm_set_sd(_Prod0);
        const __m128d _Mresult = _mm_fmsub_sd(_Mx, _Mx, _Mprod0);
        double _Result;
        _mm_store_sd(&_Result, _Mresult);
        return _Result;
    }
#line 162 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\complex"


    [[nodiscard]] inline _Fmp_t<double, 2> _Sqr_x2(const double _Xval) noexcept {
        const double _Prod0 = _Xval * _Xval;


        const bool _Definitely_have_fma = __isa_available >= __ISA_AVAILABLE_AVX2;
        if (_Definitely_have_fma) {
            return {_Prod0, _Sqr_error_x86_x64_fma(_Xval, _Prod0)};
        } else {
            return {_Prod0, _Sqr_error_fallback(_Xval, _Prod0)};
        }
#line 191 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\complex"


#line 199 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\complex"
    }
} 
#pragma float_control(pop)


namespace _Math_algorithms {
    
    
    template <class _Ty>
    struct _Hypot_leg_huge_helper {
        static constexpr _Ty value{6.703903964971298e+153};
    };
    template <>
    struct _Hypot_leg_huge_helper<float> {
        static constexpr float value{9.2233715e+18f};
    };
    template <class _Ty>
    inline constexpr _Ty _Hypot_leg_huge = _Hypot_leg_huge_helper<_Ty>::value;

    template <class _Ty>
    struct _Hypot_leg_tiny_helper {
        static constexpr _Ty value{1.4156865331029228e-146};
    };
    template <>
    struct _Hypot_leg_tiny_helper<float> {
        static constexpr float value{4.440892e-16f};
    };
    template <class _Ty>
    inline constexpr _Ty _Hypot_leg_tiny = _Hypot_leg_tiny_helper<_Ty>::value;

    template <class _Ty>
    [[nodiscard]] _Ty _Norm_minus_one(const _Ty _Xval, const _Ty _Yval) noexcept {
        
        
        const ::std::_Float_multi_prec:: _Fmp_t<_Ty, 2> _Xsqr    = ::std::_Float_multi_prec:: _Sqr_x2(_Xval);
        const ::std::_Float_multi_prec:: _Fmp_t<_Ty, 2> _Ysqr    = ::std::_Float_multi_prec:: _Sqr_x2(_Yval);
        const ::std::_Float_multi_prec:: _Fmp_t<_Ty, 2> _Xsqr_m1 = ::std::_Float_multi_prec:: _Add_small_x2(_Ty{-1.0}, _Xsqr);
        return _Add_x1(_Xsqr_m1, _Ysqr);
    }

    [[nodiscard]] inline float _Norm_minus_one(const float _Xval, const float _Yval) noexcept {
        const auto _Dx = static_cast<double>(_Xval);
        const auto _Dy = static_cast<double>(_Yval);
        return static_cast<float>((_Dx * _Dx - 1.0) + _Dy * _Dy);
    }

    
    template <class _Ty>
    [[nodiscard]] _Ty _Logp1(const _Ty _Xval) { 
        static_assert(is_floating_point_v<_Ty>, "_Ty must be floating-point");

        if (_Is_nan(_Xval)) { 
            return _Xval + _Xval; 
        }

        if (_Xval <= _Ty{-0.5} || _Ty{2.0} <= _Xval) { 
            if (_Xval == (numeric_limits<_Ty>::max)()) { 
                return ::std:: log(_Xval);
            }

            return ::std:: log(_Ty{1.0} + _Xval);
        }

        const _Ty _Xabs = _Float_abs(_Xval);
        if (_Xabs < numeric_limits<_Ty>::epsilon()) { 
            if (_Xval == _Ty{0.0}) {
                return _Xval;
            }

            
            return _Xval - _Ty{0.5} * _Xval * _Xval;
        }

        
        const ::std::_Float_multi_prec:: _Fmp_t<_Ty, 2> _Xp1 = ::std::_Float_multi_prec:: _Add_small_x2(_Ty{1.0}, _Xval);
        return ::std:: log(_Xp1._Val0) + _Xp1._Val1 / _Xp1._Val0;
    }

    template <class _Ty>
    [[nodiscard]] _Ty _Log_hypot(const _Ty _Xval, const _Ty _Yval) noexcept { 
        static_assert(is_floating_point_v<_Ty>, "_Ty must be floating-point");

        if (!_Is_finite(_Xval) || !_Is_finite(_Yval)) { 
            
            if (_Is_signaling_nan(_Xval) || _Is_signaling_nan(_Yval)) {
                return _Xval + _Yval;
            }

            
            if (_Is_inf(_Xval)) {
                return _Float_abs(_Xval);
            }

            if (_Is_inf(_Yval)) {
                return _Float_abs(_Yval);
            }

            
            return _Xval + _Yval;
        }

        _Ty _Av = _Float_abs(_Xval);
        _Ty _Bv = _Float_abs(_Yval);

        if (_Av < _Bv) { 
            ::std:: swap(_Av, _Bv);
        }

        if (_Bv == 0) {
            return ::std:: log(_Av);
        }

        if (_Hypot_leg_tiny<_Ty> < _Av && _Av < _Hypot_leg_huge<_Ty>) { 
            constexpr _Ty _Norm_small = _Ty{0.5};
            constexpr _Ty _Norm_big   = _Ty{3.0};

            const _Ty _Bv_sqr = _Bv * _Bv;

            if (_Av == _Ty{1.0}) { 
                                   
                return _Logp1(_Bv_sqr) * _Ty{0.5};
            }

            const _Ty _Norm = _Av * _Av + _Bv_sqr;

            if (_Norm_small < _Norm && _Norm < _Norm_big) { 
                return _Logp1(_Norm_minus_one(_Av, _Bv)) * _Ty{0.5};
            } else {
                return ::std:: log(_Norm) * _Ty{0.5};
            }
        } else { 
            constexpr _Ty _Cm = _Ty{22713.0L / 32768.0L};
            constexpr _Ty _Cl = _Ty{1.4286068203094172321214581765680755e-6L};

            const int _Exponent      = ::std:: ilogb(_Av);
            const _Ty _Av_scaled     = ::std:: scalbn(_Av, -_Exponent);
            const _Ty _Bv_scaled     = ::std:: scalbn(_Bv, -_Exponent);
            const _Ty _Bv_scaled_sqr = _Bv_scaled * _Bv_scaled;
            const _Ty _Norm_scaled   = _Av_scaled * _Av_scaled + _Bv_scaled_sqr;
            const _Ty _Real_shifted  = ::std:: log(_Norm_scaled) * _Ty{0.5};
            const auto _Fexponent    = static_cast<_Ty>(_Exponent);
            return (_Real_shifted + _Fexponent * _Cl) + _Fexponent * _Cm;
        }
    }
} 


using _Dcomplex_value = :: _C_double_complex;
using _Fcomplex_value = :: _C_float_complex;
using _Lcomplex_value = :: _C_ldouble_complex;

template <class _Ty>
class complex;
template <>
class complex<float>;
template <>
class complex<double>;
template <>
class complex<long double>;

template <class _Ty>
class _Ctraits {
public:
    static constexpr _Ty _Flt_eps() { 
        return numeric_limits<_Ty>::epsilon();
    }

    static constexpr _Ty _Flt_max() {
        return (numeric_limits<_Ty>::max)();
    }

    static constexpr _Ty _Flt_norm_min() {
        return (numeric_limits<_Ty>::min)() > 0 ? (numeric_limits<_Ty>::min)() : 0;
    }

    static _Ty _Abs(_Ty _Left) {
        return static_cast<_Ty>(_Signbit(_Left) ? -_Left : _Left);
    }

    static _Ty _Cosh(_Ty _Left, _Ty _Right) { 
        return static_cast<_Ty>(:: _Cosh(static_cast<double>(_Left), static_cast<double>(_Right)));
    }

    static _Ty _Copysign(_Ty _Magnitude, _Ty _Sign) {
        return static_cast<_Ty>(_Signbit(_Sign) ? -_Abs(_Magnitude) : _Abs(_Magnitude));
    }

    static short _Exp(_Ty* _Pleft, _Ty _Right, short _Exponent) { 
        double _Tmp = static_cast<double>(*_Pleft);
        short _Ans  = :: _Exp(&_Tmp, static_cast<double>(_Right), _Exponent);
        *_Pleft     = static_cast<_Ty>(_Tmp);
        return _Ans;
    }

    static constexpr _Ty _Infv() { 
        return numeric_limits<_Ty>::infinity();
    }

    static bool _Isinf(_Ty _Left) { 
        const auto _Tmp  = static_cast<double>(_Left);
        const auto _Uint = _Bit_cast<uint64_t>(_Tmp);
        return (_Uint & 0x7fffffffffffffffU) == 0x7ff0000000000000U;
    }

    static constexpr bool _Isnan(_Ty _Left) {
        const auto _Tmp  = static_cast<double>(_Left);
        const auto _Uint = _Bit_cast<uint64_t>(_Tmp);
        return (_Uint & 0x7fffffffffffffffU) > 0x7ff0000000000000U;
    }

    static constexpr _Ty _Nanv() { 
        return numeric_limits<_Ty>::quiet_NaN();
    }

    static bool _Signbit(_Ty _Left) {
        return (::std:: signbit)(static_cast<double>(_Left));
    }

    static _Ty _Sinh(_Ty _Left, _Ty _Right) { 
        return static_cast<_Ty>(:: _Sinh(static_cast<double>(_Left), static_cast<double>(_Right)));
    }

    static _Ty asinh(_Ty _Left) {
        if (_Left == 0 || _Isnan(_Left) || _Isinf(_Left)) {
            return _Left;
        }

        constexpr _Ty _Ln2 = 0.69314718055994530941723212145817658L;

        const _Ty _Old_left = _Left;
        _Ty _Ans;

        _Left = _Abs(_Left);

        if (_Left < 2 / _Flt_eps()) {
            _Ans = log1p(_Left + _Left * _Left / (1 + sqrt(_Left * _Left + 1)));
        } else {
            _Ans = log(_Left) + _Ln2;
        }

        return _Copysign(_Ans, _Old_left);
    }

    static _Ty atan2(_Ty _Yval, _Ty _Xval) { 
        return static_cast<_Ty>(:: atan2(static_cast<double>(_Yval), static_cast<double>(_Xval)));
    }

    static _Ty cos(_Ty _Left) {
        return static_cast<_Ty>(:: cos(static_cast<double>(_Left)));
    }

    static _Ty exp(_Ty _Left) {
        return static_cast<_Ty>(:: exp(static_cast<double>(_Left)));
    }

    static _Ty ldexp(_Ty _Left, int _Exponent) { 
        return static_cast<_Ty>(:: ldexp(static_cast<double>(_Left), _Exponent));
    }

    static _Ty log(_Ty _Left) {
        return static_cast<_Ty>(:: log(static_cast<double>(_Left)));
    }

    static _Ty log1p(_Ty _Left) { 
        if (_Left < -1) {
            return _Nanv();
        } else if (_Left == 0) {
            return _Left;
        } else { 
            _Ty _Leftp1 = 1 + _Left;
            return log(_Leftp1) - ((_Leftp1 - 1) - _Left) / _Leftp1;
        }
    }

    static _Ty pow(_Ty _Left, _Ty _Right) {
        return static_cast<_Ty>(:: pow(static_cast<double>(_Left), static_cast<double>(_Right)));
    }

    static _Ty sin(_Ty _Left) {
        return static_cast<_Ty>(:: sin(static_cast<double>(_Left)));
    }

    static _Ty sqrt(_Ty _Left) {
        return static_cast<_Ty>(:: sqrt(static_cast<double>(_Left)));
    }

    static _Ty tan(_Ty _Left) {
        return static_cast<_Ty>(:: tan(static_cast<double>(_Left)));
    }

    static _Ty hypot(_Ty _Left, _Ty _Right) {
        return static_cast<_Ty>(:: hypot(static_cast<double>(_Left), static_cast<double>(_Right)));
    }
};

template <>
class _Ctraits<long double> {
public:
    using _Ty = long double;

    static constexpr _Ty _Flt_eps() { 
        return numeric_limits<long double>::epsilon();
    }

    static constexpr _Ty _Flt_max() {
        return (numeric_limits<long double>::max)();
    }

    static constexpr _Ty _Flt_norm_min() {
        return (numeric_limits<long double>::min)();
    }

    static _Ty _Abs(_Ty _Left) {
        
        return :: fabsl(_Left);
    }

    static _Ty _Cosh(_Ty _Left, _Ty _Right) { 
        return :: _LCosh(_Left, _Right);
    }

    static _Ty _Copysign(_Ty _Magnitude, _Ty _Sign) {
        
        return :: copysignl(_Magnitude, _Sign);
    }

    static short _Exp(_Ty* _Pleft, _Ty _Right, short _Exponent) { 
        return :: _LExp(_Pleft, _Right, _Exponent);
    }

    static constexpr _Ty _Infv() { 
        return numeric_limits<long double>::infinity();
    }

    static bool _Isinf(_Ty _Left) { 


#line 544 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\complex"
        const auto _Uint = _Bit_cast<uint64_t>(_Left);
        return (_Uint & 0x7fffffffffffffffU) == 0x7ff0000000000000U;
#line 547 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\complex"
    }

    static constexpr bool _Isnan(_Ty _Left) {


#line 553 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\complex"
        const auto _Uint = _Bit_cast<uint64_t>(_Left);
        return (_Uint & 0x7fffffffffffffffU) > 0x7ff0000000000000U;
#line 556 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\complex"
    }

    static constexpr _Ty _Nanv() { 
        return numeric_limits<long double>::quiet_NaN();
    }

    static bool _Signbit(_Ty _Left) {
        
        return (::std:: signbit)(_Left);
    }

    static _Ty _Sinh(_Ty _Left, _Ty _Right) { 
        return :: _LSinh(_Left, _Right);
    }

    static _Ty asinh(_Ty _Left) {
        if (_Left == 0 || _Isnan(_Left) || _Isinf(_Left)) {
            return _Left;
        }

        constexpr _Ty _Ln2 = 0.69314718055994530941723212145817658L;

        const _Ty _Old_left = _Left;
        _Ty _Ans;

        _Left = _Abs(_Left);

        if (_Left < 2 / _Flt_eps()) {
            _Ans = log1p(_Left + _Left * _Left / (1 + sqrt(_Left * _Left + 1)));
        } else {
            _Ans = log(_Left) + _Ln2;
        }

        return _Copysign(_Ans, _Old_left);
    }

    static _Ty atan2(_Ty _Yval, _Ty _Xval) { 
        return :: atan2l(_Yval, _Xval);
    }

    static _Ty cos(_Ty _Left) {
        return :: cosl(_Left);
    }

    static _Ty exp(_Ty _Left) {
        return :: expl(_Left);
    }

    static _Ty ldexp(_Ty _Left, int _Exponent) { 
        return :: ldexpl(_Left, _Exponent);
    }

    static _Ty log(_Ty _Left) {
        return :: logl(_Left);
    }

    static _Ty log1p(_Ty _Left) { 
        if (_Left < -1) {
            return _Nanv();
        } else if (_Left == 0) {
            return _Left;
        } else { 
            _Ty _Leftp1 = 1 + _Left;
            return log(_Leftp1) - ((_Leftp1 - 1) - _Left) / _Leftp1;
        }
    }

    static _Ty pow(_Ty _Left, _Ty _Right) {
        return :: powl(_Left, _Right);
    }

    static _Ty sin(_Ty _Left) {
        return :: sinl(_Left);
    }

    static _Ty sqrt(_Ty _Left) {
        return :: sqrtl(_Left);
    }

    static _Ty tan(_Ty _Left) {
        return :: tanl(_Left);
    }

    static _Ty hypot(_Ty _Left, _Ty _Right) {
        return :: hypotl(_Left, _Right);
    }
};

template <>
class _Ctraits<double> {
public:
    using _Ty = double;

    static constexpr _Ty _Flt_eps() { 
        return numeric_limits<double>::epsilon();
    }

    static constexpr _Ty _Flt_max() {
        return (numeric_limits<double>::max)();
    }

    static constexpr _Ty _Flt_norm_min() {
        return (numeric_limits<double>::min)();
    }

    static _Ty _Abs(_Ty _Left) {
        
        return :: fabs(_Left);
    }

    static _Ty _Cosh(_Ty _Left, _Ty _Right) { 
        return :: _Cosh(_Left, _Right);
    }

    static _Ty _Copysign(_Ty _Magnitude, _Ty _Sign) {
        
        return :: copysign(_Magnitude, _Sign);
    }

    static short _Exp(_Ty* _Pleft, _Ty _Right, short _Exponent) { 
        return :: _Exp(_Pleft, _Right, _Exponent);
    }

    static constexpr _Ty _Infv() { 
        return numeric_limits<double>::infinity();
    }

    static bool _Isinf(_Ty _Left) { 
        const auto _Uint = _Bit_cast<uint64_t>(_Left);
        return (_Uint & 0x7fffffffffffffffU) == 0x7ff0000000000000U;
    }

    static constexpr bool _Isnan(_Ty _Left) {
        const auto _Uint = _Bit_cast<uint64_t>(_Left);
        return (_Uint & 0x7fffffffffffffffU) > 0x7ff0000000000000U;
    }

    static constexpr _Ty _Nanv() { 
        return numeric_limits<double>::quiet_NaN();
    }

    static bool _Signbit(_Ty _Left) {
        
        return (::std:: signbit)(_Left);
    }

    static _Ty _Sinh(_Ty _Left, _Ty _Right) { 
        return :: _Sinh(_Left, _Right);
    }

    static _Ty asinh(_Ty _Left) {
        if (_Isnan(_Left) || _Isinf(_Left) || _Left == 0) {
            return _Left;
        } else { 
            const _Ty _Old_left = _Left;
            _Ty _Ans;

            _Left = _Abs(_Left);

            if (_Left < 2 / _Flt_eps()) {
                _Ans = log1p(_Left + _Left * _Left / (1 + sqrt(_Left * _Left + 1)));
            } else {
                _Ans = log(_Left) 
                     + static_cast<_Ty>(0.69314718055994530941723212145817658L);
            }

            return _Copysign(_Ans, _Old_left);
        }
    }

    static _Ty atan2(_Ty _Yval, _Ty _Xval) { 
        return :: atan2(_Yval, _Xval);
    }

    static _Ty cos(_Ty _Left) {
        return :: cos(_Left);
    }

    static _Ty exp(_Ty _Left) {
        return :: exp(_Left);
    }

    static _Ty ldexp(_Ty _Left, int _Exponent) { 
        return :: ldexp(_Left, _Exponent);
    }

    static _Ty log(_Ty _Left) {
        return :: log(_Left);
    }

    static _Ty log1p(_Ty _Left) { 
        if (_Isnan(_Left) || _Left == 0 || (_Isinf(_Left) && 0 < _Left)) {
            return _Left;
        } else if (_Left < -1) {
            return _Nanv();
        } else if (_Left == -1) {
            return -_Infv();
        } else if (_Left == 0) {
            return _Left;
        } else { 
            _Ty _Leftp1 = 1 + _Left;
            return log(_Leftp1) - ((_Leftp1 - 1) - _Left) / _Leftp1;
        }
    }

    static _Ty pow(_Ty _Left, _Ty _Right) {
        return :: pow(_Left, _Right);
    }

    static _Ty sin(_Ty _Left) {
        return :: sin(_Left);
    }

    static _Ty sqrt(_Ty _Left) {
        return :: sqrt(_Left);
    }

    static _Ty tan(_Ty _Left) {
        return :: tan(_Left);
    }

    static _Ty hypot(_Ty _Left, _Ty _Right) {
        return :: hypot(_Left, _Right);
    }
};

template <>
class _Ctraits<float> {
public:
    using _Ty = float;

    static constexpr _Ty _Flt_eps() { 
        return numeric_limits<float>::epsilon();
    }

    static constexpr _Ty _Flt_max() {
        return (numeric_limits<float>::max)();
    }

    static constexpr _Ty _Flt_norm_min() {
        return (numeric_limits<float>::min)();
    }

    static _Ty _Abs(_Ty _Left) {
        
        return :: fabsf(_Left);
    }

    static _Ty _Cosh(_Ty _Left, _Ty _Right) { 
        return :: _FCosh(_Left, _Right);
    }

    static _Ty _Copysign(_Ty _Magnitude, _Ty _Sign) {
        
        return :: copysignf(_Magnitude, _Sign);
    }

    static short _Exp(_Ty* _Pleft, _Ty _Right, short _Exponent) { 
        return :: _FExp(_Pleft, _Right, _Exponent);
    }

    static constexpr _Ty _Infv() { 
        return numeric_limits<float>::infinity();
    }

    static bool _Isinf(_Ty _Left) { 
        const auto _Uint = _Bit_cast<uint32_t>(_Left);
        return (_Uint & 0x7fffffffU) == 0x7f800000U;
    }

    static constexpr bool _Isnan(_Ty _Left) {
        const auto _Uint = _Bit_cast<uint32_t>(_Left);
        return (_Uint & 0x7fffffffU) > 0x7f800000U;
    }

    static constexpr _Ty _Nanv() { 
        return numeric_limits<float>::quiet_NaN();
    }

    static bool _Signbit(_Ty _Left) {
        
        return (::std:: signbit)(_Left);
    }

    static _Ty _Sinh(_Ty _Left, _Ty _Right) { 
        return :: _FSinh(_Left, _Right);
    }

    static _Ty asinh(_Ty _Left) {
        if (_Left == 0 || _Isnan(_Left) || _Isinf(_Left)) {
            return _Left;
        }

        constexpr _Ty _Ln2 = 0.69314718055994530941723212145817658F;

        const _Ty _Old_left = _Left;
        _Ty _Ans;

        _Left = _Abs(_Left);

        if (_Left < 2 / _Flt_eps()) {
            _Ans = log1p(_Left + _Left * _Left / (1 + sqrt(_Left * _Left + 1)));
        } else {
            _Ans = log(_Left) + _Ln2;
        }

        return _Copysign(_Ans, _Old_left);
    }

    static _Ty atan2(_Ty _Yval, _Ty _Xval) { 
        return :: atan2f(_Yval, _Xval);
    }

    static _Ty cos(_Ty _Left) {
        return :: cosf(_Left);
    }

    static _Ty exp(_Ty _Left) {
        return :: expf(_Left);
    }

    static _Ty ldexp(_Ty _Left, int _Exponent) { 
        return :: ldexpf(_Left, _Exponent);
    }

    static _Ty log(_Ty _Left) {
        return :: logf(_Left);
    }

    static _Ty log1p(_Ty _Left) { 
        if (_Left < -1) {
            return _Nanv();
        } else if (_Left == 0) {
            return _Left;
        } else { 
            _Ty _Leftp1 = 1 + _Left;
            return log(_Leftp1) - ((_Leftp1 - 1) - _Left) / _Leftp1;
        }
    }

    static _Ty pow(_Ty _Left, _Ty _Right) {
        return :: powf(_Left, _Right);
    }

    static _Ty sin(_Ty _Left) {
        return :: sinf(_Left);
    }

    static _Ty sqrt(_Ty _Left) {
        return :: sqrtf(_Left);
    }

    static _Ty tan(_Ty _Left) {
        return :: tanf(_Left);
    }

    static _Ty hypot(_Ty _Left, _Ty _Right) {
        return :: hypotf(_Left, _Right);
    }
};

template <class _Ty>
struct _Complex_value {
    enum { _Re = 0, _Im = 1 };
    _Ty _Val[2];
};

template <class _Ty, class _Valbase>
class _Complex_base : public _Valbase {
public:
    using _Myctraits = _Ctraits<_Ty>;
    using value_type = _Ty;

    constexpr _Complex_base(const _Ty& _Realval, const _Ty& _Imagval) : _Valbase{{_Realval, _Imagval}} {}

    constexpr void real(const _Ty& _Right) { 
        this->_Val[0] = _Right;
    }

    constexpr void imag(const _Ty& _Right) { 
        this->_Val[1] = _Right;
    }

    [[nodiscard]] constexpr _Ty real() const { 
        return this->_Val[0];
    }

    [[nodiscard]] constexpr _Ty imag() const { 
        return this->_Val[1];
    }

protected:
    template <class _Other>
    constexpr void _Add(const complex<_Other>& _Right) {
        this->_Val[0] = this->_Val[0] + static_cast<_Ty>(_Right.real());
        this->_Val[1] = this->_Val[1] + static_cast<_Ty>(_Right.imag());
    }

    template <class _Other>
    constexpr void _Sub(const complex<_Other>& _Right) {
        this->_Val[0] = this->_Val[0] - static_cast<_Ty>(_Right.real());
        this->_Val[1] = this->_Val[1] - static_cast<_Ty>(_Right.imag());
    }

    template <class _Other>
    constexpr void _Mul(const complex<_Other>& _Right) {
        _Ty _Rightreal = static_cast<_Ty>(_Right.real());
        _Ty _Rightimag = static_cast<_Ty>(_Right.imag());

        _Ty _Tmp        = this->_Val[0] * _Rightreal - this->_Val[1] * _Rightimag;
        this->_Val[1] = this->_Val[0] * _Rightimag + this->_Val[1] * _Rightreal;
        this->_Val[0] = _Tmp;
    }

    template <class _Other>
    constexpr void _Div(const complex<_Other>& _Right) {
        using _Myctraits = _Ctraits<_Ty>;

        _Ty _Rightreal = static_cast<_Ty>(_Right.real());
        _Ty _Rightimag = static_cast<_Ty>(_Right.imag());

        if (_Myctraits::_Isnan(_Rightreal) || _Myctraits::_Isnan(_Rightimag)) { 
            this->_Val[0] = _Myctraits::_Nanv();
            this->_Val[1] = this->_Val[0];
        } else if ((_Rightimag < 0 ? -_Rightimag : +_Rightimag)
                   < (_Rightreal < 0 ? -_Rightreal : +_Rightreal)) { 
            _Ty _Wr = _Rightimag / _Rightreal;
            _Ty _Wd = _Rightreal + _Wr * _Rightimag;

            if (_Myctraits::_Isnan(_Wd) || _Wd == 0) { 
                this->_Val[0] = _Myctraits::_Nanv();
                this->_Val[1] = this->_Val[0];
            } else { 
                _Ty _Tmp        = (this->_Val[0] + this->_Val[1] * _Wr) / _Wd;
                this->_Val[1] = (this->_Val[1] - this->_Val[0] * _Wr) / _Wd;
                this->_Val[0] = _Tmp;
            }
        } else if (_Rightimag == 0) { 
            this->_Val[0] = _Myctraits::_Nanv();
            this->_Val[1] = this->_Val[0];
        } else { 
            _Ty _Wr = _Rightreal / _Rightimag;
            _Ty _Wd = _Rightimag + _Wr * _Rightreal;

            if (_Myctraits::_Isnan(_Wd) || _Wd == 0) { 
                this->_Val[0] = _Myctraits::_Nanv();
                this->_Val[1] = this->_Val[0];
            } else { 
                _Ty _Tmp        = (this->_Val[0] * _Wr + this->_Val[1]) / _Wd;
                this->_Val[1] = (this->_Val[1] * _Wr - this->_Val[0]) / _Wd;
                this->_Val[0] = _Tmp;
            }
        }
    }
};

template <>
class complex<float> : public _Complex_base<float, _Fcomplex_value> {
public:
    using _Ty = float;

    constexpr explicit complex(const complex<double>&); 
    constexpr explicit complex(const complex<long double>&); 

    constexpr complex(const _Ty& _Realval = 0, const _Ty& _Imagval = 0)
        : _Complex_base<float, _Fcomplex_value>(_Realval, _Imagval) {}

    constexpr complex& operator=(const _Ty& _Right) {
        _Val[0] = _Right;
        _Val[1] = 0;
        return *this;
    }

    constexpr complex& operator+=(const _Ty& _Right) {
        _Val[0] = _Val[0] + _Right;
        return *this;
    }

    constexpr complex& operator-=(const _Ty& _Right) {
        _Val[0] = _Val[0] - _Right;
        return *this;
    }

    constexpr complex& operator*=(const _Ty& _Right) {
        _Val[0] = _Val[0] * _Right;
        _Val[1] = _Val[1] * _Right;
        return *this;
    }

    constexpr complex& operator/=(const _Ty& _Right) {
        _Val[0] = _Val[0] / _Right;
        _Val[1] = _Val[1] / _Right;
        return *this;
    }

    constexpr complex& operator+=(const complex& _Right) {
        this->_Add(_Right);
        return *this;
    }

    constexpr complex& operator-=(const complex& _Right) {
        this->_Sub(_Right);
        return *this;
    }

    constexpr complex& operator*=(const complex& _Right) {
        this->_Mul(_Right);
        return *this;
    }

    constexpr complex& operator/=(const complex& _Right) {
        this->_Div(_Right);
        return *this;
    }

    template <class _Other>
    constexpr complex& operator=(const complex<_Other>& _Right) {
        _Val[0] = static_cast<_Ty>(_Right._Val[0]);
        _Val[1] = static_cast<_Ty>(_Right._Val[1]);
        return *this;
    }

    template <class _Other>
    constexpr complex& operator+=(const complex<_Other>& _Right) {
        this->_Add(_Right);
        return *this;
    }

    template <class _Other>
    constexpr complex& operator-=(const complex<_Other>& _Right) {
        this->_Sub(_Right);
        return *this;
    }

    template <class _Other>
    constexpr complex& operator*=(const complex<_Other>& _Right) {
        this->_Mul(_Right);
        return *this;
    }

    template <class _Other>
    constexpr complex& operator/=(const complex<_Other>& _Right) {
        this->_Div(_Right);
        return *this;
    }
};

template <>
class complex<double> : public _Complex_base<double, _Dcomplex_value> {
public:
    using _Ty = double;

    constexpr complex(const complex<float>&); 
    constexpr explicit complex(const complex<long double>&); 

    constexpr complex(const _Ty& _Realval = 0, const _Ty& _Imagval = 0)
        : _Complex_base<double, _Dcomplex_value>(_Realval, _Imagval) {}

    constexpr complex& operator=(const _Ty& _Right) {
        _Val[0] = _Right;
        _Val[1] = 0;
        return *this;
    }

    constexpr complex& operator+=(const _Ty& _Right) {
        _Val[0] = _Val[0] + _Right;
        return *this;
    }

    constexpr complex& operator-=(const _Ty& _Right) {
        _Val[0] = _Val[0] - _Right;
        return *this;
    }

    constexpr complex& operator*=(const _Ty& _Right) {
        _Val[0] = _Val[0] * _Right;
        _Val[1] = _Val[1] * _Right;
        return *this;
    }

    constexpr complex& operator/=(const _Ty& _Right) {
        _Val[0] = _Val[0] / _Right;
        _Val[1] = _Val[1] / _Right;
        return *this;
    }

    constexpr complex& operator+=(const complex& _Right) {
        this->_Add(_Right);
        return *this;
    }

    constexpr complex& operator-=(const complex& _Right) {
        this->_Sub(_Right);
        return *this;
    }

    constexpr complex& operator*=(const complex& _Right) {
        this->_Mul(_Right);
        return *this;
    }

    constexpr complex& operator/=(const complex& _Right) {
        this->_Div(_Right);
        return *this;
    }

    template <class _Other>
    constexpr complex& operator=(const complex<_Other>& _Right) {
        _Val[0] = static_cast<_Ty>(_Right._Val[0]);
        _Val[1] = static_cast<_Ty>(_Right._Val[1]);
        return *this;
    }

    template <class _Other>
    constexpr complex& operator+=(const complex<_Other>& _Right) {
        this->_Add(_Right);
        return *this;
    }

    template <class _Other>
    constexpr complex& operator-=(const complex<_Other>& _Right) {
        this->_Sub(_Right);
        return *this;
    }

    template <class _Other>
    constexpr complex& operator*=(const complex<_Other>& _Right) {
        this->_Mul(_Right);
        return *this;
    }

    template <class _Other>
    constexpr complex& operator/=(const complex<_Other>& _Right) {
        this->_Div(_Right);
        return *this;
    }
};

template <>
class complex<long double> : public _Complex_base<long double, _Lcomplex_value> {
public:
    using _Ty = long double;

    constexpr complex(const complex<float>&); 
    constexpr complex(const complex<double>&); 

    constexpr complex(const _Ty& _Realval = 0, const _Ty& _Imagval = 0)
        : _Complex_base<long double, _Lcomplex_value>(_Realval, _Imagval) {}

    constexpr complex& operator=(const _Ty& _Right) {
        _Val[0] = _Right;
        _Val[1] = 0;
        return *this;
    }

    constexpr complex& operator+=(const _Ty& _Right) {
        _Val[0] = _Val[0] + _Right;
        return *this;
    }

    constexpr complex& operator-=(const _Ty& _Right) {
        _Val[0] = _Val[0] - _Right;
        return *this;
    }

    constexpr complex& operator*=(const _Ty& _Right) {
        _Val[0] = _Val[0] * _Right;
        _Val[1] = _Val[1] * _Right;
        return *this;
    }

    constexpr complex& operator/=(const _Ty& _Right) {
        _Val[0] = _Val[0] / _Right;
        _Val[1] = _Val[1] / _Right;
        return *this;
    }

    constexpr complex& operator+=(const complex& _Right) {
        this->_Add(_Right);
        return *this;
    }

    constexpr complex& operator-=(const complex& _Right) {
        this->_Sub(_Right);
        return *this;
    }

    constexpr complex& operator*=(const complex& _Right) {
        this->_Mul(_Right);
        return *this;
    }

    constexpr complex& operator/=(const complex& _Right) {
        this->_Div(_Right);
        return *this;
    }

    template <class _Other>
    constexpr complex& operator=(const complex<_Other>& _Right) {
        _Val[0] = static_cast<_Ty>(_Right._Val[0]);
        _Val[1] = static_cast<_Ty>(_Right._Val[1]);
        return *this;
    }

    template <class _Other>
    constexpr complex& operator+=(const complex<_Other>& _Right) {
        this->_Add(_Right);
        return *this;
    }

    template <class _Other>
    constexpr complex& operator-=(const complex<_Other>& _Right) {
        this->_Sub(_Right);
        return *this;
    }

    template <class _Other>
    constexpr complex& operator*=(const complex<_Other>& _Right) {
        this->_Mul(_Right);
        return *this;
    }

    template <class _Other>
    constexpr complex& operator/=(const complex<_Other>& _Right) {
        this->_Div(_Right);
        return *this;
    }
};

constexpr complex<float>::complex(const complex<double>& _Right)
    : _Complex_base<float, _Fcomplex_value>(static_cast<_Ty>(_Right.real()), static_cast<_Ty>(_Right.imag())) {}

constexpr complex<float>::complex(const complex<long double>& _Right)
    : _Complex_base<float, _Fcomplex_value>(static_cast<_Ty>(_Right.real()), static_cast<_Ty>(_Right.imag())) {}

constexpr complex<double>::complex(const complex<float>& _Right)
    : _Complex_base<double, _Dcomplex_value>(_Right.real(), _Right.imag()) {}

constexpr complex<double>::complex(const complex<long double>& _Right)
    : _Complex_base<double, _Dcomplex_value>(static_cast<_Ty>(_Right.real()), static_cast<_Ty>(_Right.imag())) {}

constexpr complex<long double>::complex(const complex<float>& _Right)
    : _Complex_base<long double, _Lcomplex_value>(_Right.real(), _Right.imag()) {}

constexpr complex<long double>::complex(const complex<double>& _Right)
    : _Complex_base<long double, _Lcomplex_value>(_Right.real(), _Right.imag()) {}

template <class _Ty>
class complex : public _Complex_base<_Ty, _Complex_value<_Ty>> {
public:
    using _Mybase = _Complex_base<_Ty, _Complex_value<_Ty>>;

    constexpr complex(const _Ty& _Realval = _Ty(), const _Ty& _Imagval = _Ty()) : _Mybase(_Realval, _Imagval) {}

    constexpr complex& operator=(const _Ty& _Right) {
        this->_Val[0] = _Right;
        this->_Val[1] = _Ty();
        return *this;
    }

    template <class _Other>
    constexpr complex(const complex<_Other>& _Right)
        : _Mybase(static_cast<_Ty>(_Right.real()), static_cast<_Ty>(_Right.imag())) {}

    template <class _Other>
    constexpr complex& operator=(const complex<_Other>& _Right) {
        this->_Val[0] = static_cast<_Ty>(_Right.real());
        this->_Val[1] = static_cast<_Ty>(_Right.imag());
        return *this;
    }

    constexpr complex& operator+=(const _Ty& _Right) {
        this->_Val[0] = this->_Val[0] + _Right;
        return *this;
    }

    constexpr complex& operator-=(const _Ty& _Right) {
        this->_Val[0] = this->_Val[0] - _Right;
        return *this;
    }

    constexpr complex& operator*=(const _Ty& _Right) {
        this->_Val[0] = this->_Val[0] * _Right;
        this->_Val[1] = this->_Val[1] * _Right;
        return *this;
    }

    constexpr complex& operator/=(const _Ty& _Right) {
        this->_Val[0] = this->_Val[0] / _Right;
        this->_Val[1] = this->_Val[1] / _Right;
        return *this;
    }

    constexpr complex& operator+=(const complex& _Right) {
        this->_Add(_Right);
        return *this;
    }

    constexpr complex& operator-=(const complex& _Right) {
        this->_Sub(_Right);
        return *this;
    }

    constexpr complex& operator*=(const complex& _Right) {
        this->_Mul(_Right);
        return *this;
    }

    constexpr complex& operator/=(const complex& _Right) {
        this->_Div(_Right);
        return *this;
    }

    template <class _Other>
    constexpr complex& operator+=(const complex<_Other>& _Right) {
        this->_Add(_Right);
        return *this;
    }

    template <class _Other>
    constexpr complex& operator-=(const complex<_Other>& _Right) {
        this->_Sub(_Right);
        return *this;
    }

    template <class _Other>
    constexpr complex& operator*=(const complex<_Other>& _Right) {
        this->_Mul(_Right);
        return *this;
    }

    template <class _Other>
    constexpr complex& operator/=(const complex<_Other>& _Right) {
        this->_Div(_Right);
        return *this;
    }
};

template <class _Ty>
[[nodiscard]] constexpr complex<_Ty> operator+(const complex<_Ty>& _Left, const complex<_Ty>& _Right) {
    complex<_Ty> _Tmp(_Left);
    _Tmp += _Right;
    return _Tmp;
}

template <class _Ty>
[[nodiscard]] constexpr complex<_Ty> operator+(const complex<_Ty>& _Left, const _Ty& _Right) {
    complex<_Ty> _Tmp(_Left);
    _Tmp.real(_Tmp.real() + _Right);
    return _Tmp;
}

template <class _Ty>
[[nodiscard]] constexpr complex<_Ty> operator+(const _Ty& _Left, const complex<_Ty>& _Right) {
    complex<_Ty> _Tmp(_Left);
    _Tmp += _Right;
    return _Tmp;
}

template <class _Ty>
[[nodiscard]] constexpr complex<_Ty> operator-(const complex<_Ty>& _Left, const complex<_Ty>& _Right) {
    complex<_Ty> _Tmp(_Left);
    _Tmp -= _Right;
    return _Tmp;
}

template <class _Ty>
[[nodiscard]] constexpr complex<_Ty> operator-(const complex<_Ty>& _Left, const _Ty& _Right) {
    complex<_Ty> _Tmp(_Left);
    _Tmp.real(_Tmp.real() - _Right);
    return _Tmp;
}

template <class _Ty>
[[nodiscard]] constexpr complex<_Ty> operator-(const _Ty& _Left, const complex<_Ty>& _Right) {
    complex<_Ty> _Tmp(_Left);
    _Tmp -= _Right;
    return _Tmp;
}

template <class _Ty>
[[nodiscard]] constexpr complex<_Ty> operator*(const complex<_Ty>& _Left, const complex<_Ty>& _Right) {
    complex<_Ty> _Tmp(_Left);
    _Tmp *= _Right;
    return _Tmp;
}

template <class _Ty>
[[nodiscard]] constexpr complex<_Ty> operator*(const complex<_Ty>& _Left, const _Ty& _Right) {
    complex<_Ty> _Tmp(_Left);
    _Tmp.real(_Tmp.real() * _Right);
    _Tmp.imag(_Tmp.imag() * _Right);
    return _Tmp;
}

template <class _Ty>
[[nodiscard]] constexpr complex<_Ty> operator*(const _Ty& _Left, const complex<_Ty>& _Right) {
    complex<_Ty> _Tmp(_Left);
    _Tmp *= _Right;
    return _Tmp;
}

template <class _Ty>
[[nodiscard]] constexpr complex<_Ty> operator/(const complex<_Ty>& _Left, const complex<_Ty>& _Right) {
    complex<_Ty> _Tmp(_Left);
    _Tmp /= _Right;
    return _Tmp;
}

template <class _Ty>
[[nodiscard]] constexpr complex<_Ty> operator/(const complex<_Ty>& _Left, const _Ty& _Right) {
    complex<_Ty> _Tmp(_Left);
    _Tmp.real(_Tmp.real() / _Right);
    _Tmp.imag(_Tmp.imag() / _Right);
    return _Tmp;
}

template <class _Ty>
[[nodiscard]] constexpr complex<_Ty> operator/(const _Ty& _Left, const complex<_Ty>& _Right) {
    complex<_Ty> _Tmp(_Left);
    _Tmp /= _Right;
    return _Tmp;
}

template <class _Ty>
[[nodiscard]] constexpr complex<_Ty> operator+(const complex<_Ty>& _Left) {
    return _Left;
}

template <class _Ty>
[[nodiscard]] constexpr complex<_Ty> operator-(const complex<_Ty>& _Left) {
    return complex<_Ty>(-_Left.real(), -_Left.imag());
}

template <class _Ty>
[[nodiscard]] constexpr bool operator==(const complex<_Ty>& _Left, const complex<_Ty>& _Right) {
    return _Left.real() == _Right.real() && _Left.imag() == _Right.imag();
}

template <class _Ty>
[[nodiscard]] constexpr bool operator==(const complex<_Ty>& _Left, const _Ty& _Right) {
    return _Left.real() == _Right && _Left.imag() == 0;
}


#line 1506 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\complex"


#line 1523 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\complex"

template <class _Ty>
[[nodiscard]] constexpr _Ty imag(const complex<_Ty>& _Left) {
    return _Left.imag();
}

template <class _Ty>
[[nodiscard]] constexpr _Ty real(const complex<_Ty>& _Left) {
    return _Left.real();
}

template <class _Ty>
[[nodiscard]] complex<_Ty> sqrt(const complex<_Ty>& _Left);

template <class _Ty>
[[nodiscard]] _Ty abs(const complex<_Ty>& _Left) {
    return _Ctraits<_Ty>::hypot(_Left.real(), _Left.imag());
}

template <class _Ty>
[[nodiscard]] complex<_Ty> acos(const complex<_Ty>& _Left) {
    const _Ty _Arcbig = static_cast<_Ty>(0.25) * _Ctraits<_Ty>::sqrt(_Ctraits<_Ty>::_Flt_max());
    constexpr _Ty _Pi = static_cast<_Ty>(3.1415926535897932384626433832795029L);

    const _Ty _Re = real(_Left);
    const _Ty _Im = imag(_Left);
    _Ty _Ux;
    _Ty _Vx;

    if (_Ctraits<_Ty>::_Isnan(_Re) || _Ctraits<_Ty>::_Isnan(_Im)) { 
        _Ux = _Ctraits<_Ty>::_Nanv();
        _Vx = _Ux;
    } else if (_Ctraits<_Ty>::_Isinf(_Re)) { 
        if (_Ctraits<_Ty>::_Isinf(_Im)) {
            if (_Re < 0) {
                _Ux = static_cast<_Ty>(0.75) * _Pi; 
            } else {
                _Ux = static_cast<_Ty>(0.25) * _Pi; 
            }
        } else if (_Re < 0) {
            _Ux = _Pi; 
        } else {
            _Ux = 0; 
        }
        _Vx = -_Ctraits<_Ty>::_Copysign(_Ctraits<_Ty>::_Infv(), _Im);
    } else if (_Ctraits<_Ty>::_Isinf(_Im)) { 
        _Ux = static_cast<_Ty>(0.50) * _Pi; 
        _Vx = -_Im;
    } else { 
        const complex<_Ty> _Wx = sqrt(complex<_Ty>(1 + _Re, -_Im));
        const complex<_Ty> _Zx = sqrt(complex<_Ty>(1 - _Re, -_Im));
        const _Ty _Wr          = real(_Wx);
        const _Ty _Wi          = imag(_Wx);
        const _Ty _Zr          = real(_Zx);
        const _Ty _Zi          = imag(_Zx);
        _Ty _Alfa;
        _Ty _Beta;

        _Ux = 2 * _Ctraits<_Ty>::atan2(_Zr, _Wr);

        if (_Arcbig < _Wr) { 
            _Alfa = _Wr;
            _Beta = _Zi + _Wi * (_Zr / _Alfa);
        } else if (_Arcbig < _Wi) { 
            _Alfa = _Wi;
            _Beta = _Wr * (_Zi / _Alfa) + _Zr;
        } else if (_Wi < -_Arcbig) { 
            _Alfa = -_Wi;
            _Beta = _Wr * (_Zi / _Alfa) - _Zr;
        } else { 
            _Alfa = 0;
            _Beta = _Wr * _Zi + _Wi * _Zr; 
        }

        _Vx = _Ctraits<_Ty>::asinh(_Beta);
        if (_Alfa != 0) {
            if (0 <= _Vx) {
                _Vx += _Ctraits<_Ty>::log(_Alfa);
            } else {
                _Vx -= _Ctraits<_Ty>::log(_Alfa); 
            }
        }
    }
    return complex<_Ty>(_Ux, _Vx);
}

template <class _Ty>
[[nodiscard]] complex<_Ty> acosh(const complex<_Ty>& _Left) {
    const _Ty _Arcbig = static_cast<_Ty>(0.25) * _Ctraits<_Ty>::sqrt(_Ctraits<_Ty>::_Flt_max());
    constexpr _Ty _Pi = static_cast<_Ty>(3.1415926535897932384626433832795029L);

    const _Ty _Re = real(_Left);
    _Ty _Im       = imag(_Left);
    _Ty _Ux;
    _Ty _Vx;

    if (_Ctraits<_Ty>::_Isnan(_Re) || _Ctraits<_Ty>::_Isnan(_Im)) { 
        _Ux = _Ctraits<_Ty>::_Nanv();
        _Vx = _Ux;
    } else if (_Ctraits<_Ty>::_Isinf(_Re)) { 
        _Ux = _Ctraits<_Ty>::_Infv();

        if (_Ctraits<_Ty>::_Isinf(_Im)) {
            if (_Re < 0) {
                _Vx = static_cast<_Ty>(0.75) * _Pi; 
            } else {
                _Vx = static_cast<_Ty>(0.25) * _Pi; 
            }
        } else if (_Re < 0) {
            _Vx = _Pi; 
        } else {
            _Vx = 0; 
        }

        _Vx = _Ctraits<_Ty>::_Copysign(_Vx, _Im);
    } else if (_Ctraits<_Ty>::_Isinf(_Im)) { 
        _Ux = _Ctraits<_Ty>::_Infv();
        _Vx = _Ctraits<_Ty>::_Copysign(static_cast<_Ty>(0.50) * _Pi, _Im);
    } else { 
        const complex<_Ty> _Wx = sqrt(complex<_Ty>(_Re - 1, -_Im));
        const complex<_Ty> _Zx = sqrt(complex<_Ty>(_Re + 1, _Im));
        const _Ty _Wr          = real(_Wx);
        const _Ty _Wi          = imag(_Wx);
        const _Ty _Zr          = real(_Zx);
        const _Ty _Zi          = imag(_Zx);
        _Ty _Alfa;
        _Ty _Beta;

        if (_Arcbig < _Wr) { 
            _Alfa = _Wr;
            _Beta = _Zr - _Wi * (_Zi / _Alfa);
        } else if (_Arcbig < _Wi) { 
            _Alfa = _Wi;
            _Beta = _Wr * (_Zr / _Alfa) - _Zi;
        } else if (_Wi < -_Arcbig) { 
            _Alfa = -_Wi;
            _Beta = _Wr * (_Zr / _Alfa) + _Zi;
        } else { 
            _Alfa = 0;
            _Beta = _Wr * _Zr - _Wi * _Zi; 
        }

        _Ux = _Ctraits<_Ty>::asinh(_Beta);
        if (_Alfa != 0) {
            if (0 <= _Ux) {
                _Ux += _Ctraits<_Ty>::log(_Alfa);
            } else {
                _Ux -= _Ctraits<_Ty>::log(_Alfa); 
            }
        }

        _Vx = 2 * _Ctraits<_Ty>::atan2(imag(sqrt(complex<_Ty>(_Re - 1, _Im))), _Zr);
    }
    return complex<_Ty>(_Ux, _Vx);
}

template <class _Ty>
[[nodiscard]] complex<_Ty> asinh(const complex<_Ty>& _Left) {
    const _Ty _Arcbig = static_cast<_Ty>(0.25) * _Ctraits<_Ty>::sqrt(_Ctraits<_Ty>::_Flt_max());
    constexpr _Ty _Pi = static_cast<_Ty>(3.1415926535897932384626433832795029L);

    const _Ty _Re = real(_Left);
    _Ty _Im       = imag(_Left);
    _Ty _Ux;
    _Ty _Vx;

    if (_Ctraits<_Ty>::_Isnan(_Re) || _Ctraits<_Ty>::_Isnan(_Im)) { 
        _Ux = _Ctraits<_Ty>::_Nanv();
        _Vx = _Ux;
    } else if (_Ctraits<_Ty>::_Isinf(_Re)) { 
        _Ux = _Ctraits<_Ty>::_Infv();

        if (_Ctraits<_Ty>::_Isinf(_Im)) { 
            _Ux = _Re;
            _Vx = _Ctraits<_Ty>::_Copysign(static_cast<_Ty>(0.25) * _Pi, _Im);
        } else { 
            _Ux = _Re;
            _Vx = _Ctraits<_Ty>::_Copysign(_Ty{0}, _Im);
        }
    } else if (_Ctraits<_Ty>::_Isinf(_Im)) { 
        _Ux = _Ctraits<_Ty>::_Copysign(_Ctraits<_Ty>::_Infv(), _Re);
        _Vx = _Ctraits<_Ty>::_Copysign(static_cast<_Ty>(0.50) * _Pi, _Im);
    } else { 
        const complex<_Ty> _Wx = sqrt(complex<_Ty>(1 - _Im, _Re));
        const complex<_Ty> _Zx = sqrt(complex<_Ty>(1 + _Im, -_Re));
        const _Ty _Wr          = real(_Wx);
        const _Ty _Wi          = imag(_Wx);
        const _Ty _Zr          = real(_Zx);
        const _Ty _Zi          = imag(_Zx);
        _Ty _Alfa;
        _Ty _Beta;

        if (_Arcbig < _Wr) { 
            _Alfa = _Wr;
            _Beta = _Wi * (_Zr / _Alfa) - _Zi;
        } else if (_Arcbig < _Wi) { 
            _Alfa = _Wi;
            _Beta = _Zr - _Wr * (_Zi / _Alfa);
        } else if (_Wi < -_Arcbig) { 
            _Alfa = -_Wi;
            _Beta = -_Zr - _Wr * (_Zi / _Alfa);
        } else { 
            _Alfa = 0;
            _Beta = _Wi * _Zr - _Wr * _Zi; 
        }

        _Ux = _Ctraits<_Ty>::asinh(_Beta);
        if (_Alfa != 0) {
            if (0 <= _Ux) {
                _Ux += _Ctraits<_Ty>::log(_Alfa);
            } else {
                _Ux -= _Ctraits<_Ty>::log(_Alfa); 
            }
        }

        _Vx = _Ctraits<_Ty>::atan2(_Im, real(_Wx * _Zx));
    }

    return complex<_Ty>(_Ux, _Vx);
}

template <class _Ty>
[[nodiscard]] complex<_Ty> asin(const complex<_Ty>& _Left) {
    complex<_Ty> _Asinh = ::std:: asinh(complex<_Ty>(-imag(_Left), real(_Left)));

    return complex<_Ty>(imag(_Asinh), -real(_Asinh));
}

template <class _Ty>
[[nodiscard]] complex<_Ty> atanh(const complex<_Ty>& _Left) {
    const _Ty _Arcbig    = static_cast<_Ty>(0.25) * _Ctraits<_Ty>::sqrt(_Ctraits<_Ty>::_Flt_max());
    constexpr _Ty _Piby2 = static_cast<_Ty>(1.5707963267948966192313216916397514L);

    _Ty _Re = real(_Left);
    _Ty _Im = imag(_Left);
    _Ty _Ux;
    _Ty _Vx;

    if (_Ctraits<_Ty>::_Isnan(_Re) || _Ctraits<_Ty>::_Isnan(_Im)) { 
        _Ux = _Ctraits<_Ty>::_Nanv();
        _Vx = _Ux;
    } else if (_Ctraits<_Ty>::_Isinf(_Re)) { 
        _Ux = _Ctraits<_Ty>::_Copysign(_Ty{0}, _Re);
        _Vx = _Ctraits<_Ty>::_Copysign(_Piby2, _Im);
    } else { 
        const _Ty _Magim  = _Ctraits<_Ty>::_Abs(_Im);
        const _Ty _Old_re = _Re;

        _Re = _Ctraits<_Ty>::_Abs(_Re);

        if (_Arcbig < _Re) { 
            _Ty _Fx = _Im / _Re;

            _Ux = 1 / _Re / (1 + _Fx * _Fx);
            _Vx = _Ctraits<_Ty>::_Copysign(_Piby2, _Im);
        } else if (_Arcbig < _Magim) { 
            _Ty _Fx = _Re / _Im;

            _Ux = _Fx / _Im / (1 + _Fx * _Fx);
            _Vx = _Ctraits<_Ty>::_Copysign(_Piby2, _Im);
        } else if (_Re != 1) { 
            _Ty _Refrom1 = 1 - _Re;
            _Ty _Imeps2  = _Magim * _Magim;

            _Ux = static_cast<_Ty>(0.25) * _Ctraits<_Ty>::log1p(4 * _Re / (_Refrom1 * _Refrom1 + _Imeps2));
            _Vx = static_cast<_Ty>(0.50) * _Ctraits<_Ty>::atan2(2 * _Im, _Refrom1 * (1 + _Re) - _Imeps2);
        } else if (_Im == 0) { 
            _Ux = _Ctraits<_Ty>::_Infv();
            _Vx = _Im;
        } else { 
            _Ux = _Ctraits<_Ty>::log(
                _Ctraits<_Ty>::sqrt(_Ctraits<_Ty>::sqrt(4 + _Im * _Im)) / _Ctraits<_Ty>::sqrt(_Magim));
            _Vx = _Ctraits<_Ty>::_Copysign(static_cast<_Ty>(0.50) * (_Piby2 + _Ctraits<_Ty>::atan2(_Magim, 2)), _Im);
        }

        _Ux = _Ctraits<_Ty>::_Copysign(_Ux, _Old_re);
    }
    return complex<_Ty>(_Ux, _Vx);
}

template <class _Ty>
[[nodiscard]] complex<_Ty> atan(const complex<_Ty>& _Left) {
    complex<_Ty> _Atanh = ::std:: atanh(complex<_Ty>(-imag(_Left), real(_Left)));

    return complex<_Ty>(imag(_Atanh), -real(_Atanh));
}

template <class _Ty>
[[nodiscard]] complex<_Ty> cosh(const complex<_Ty>& _Left) {
    return complex<_Ty>(_Ctraits<_Ty>::_Cosh(real(_Left), _Ctraits<_Ty>::cos(imag(_Left))),
        _Ctraits<_Ty>::_Sinh(real(_Left), _Ctraits<_Ty>::sin(imag(_Left))));
}

template <class _Ty>
[[nodiscard]] complex<_Ty> _Polar_positive_nan_inf_zero_rho(const _Ty& _Rho, const _Ty& _Theta) { 
    if (_Ctraits<_Ty>::_Isnan(_Theta) || _Ctraits<_Ty>::_Isinf(_Theta)) { 
        if (_Ctraits<_Ty>::_Isinf(_Rho)) {
            return complex<_Ty>(_Rho, _Ctraits<_Ty>::sin(_Theta)); 
        } else {
            return complex<_Ty>(_Rho, _Ctraits<_Ty>::_Copysign(_Rho, _Theta)); 
        }
    } else if (_Theta == _Ty{0}) { 
        return complex<_Ty>(_Rho, _Theta); 
    } else { 
        
        return complex<_Ty>(_Rho * _Ctraits<_Ty>::cos(_Theta), _Rho * _Ctraits<_Ty>::sin(_Theta));
    }
}

template <class _Ty>
[[nodiscard]] complex<_Ty> exp(const complex<_Ty>& _Left) {
    const _Ty _Log_rho = ::std:: real(_Left);
    const _Ty _Theta   = ::std:: imag(_Left);

    if (!_Ctraits<_Ty>::_Isnan(_Log_rho) && !_Ctraits<_Ty>::_Isinf(_Log_rho)) { 
        _Ty _Real = _Log_rho;
        _Ty _Imag = _Log_rho;
        _Ctraits<_Ty>::_Exp(&_Real, _Ctraits<_Ty>::cos(_Theta), 0);
        _Ctraits<_Ty>::_Exp(&_Imag, _Ctraits<_Ty>::sin(_Theta), 0);
        return complex<_Ty>(_Real, _Imag);
    }

    
    if (_Ctraits<_Ty>::_Isinf(_Log_rho)) {
        if (_Log_rho < _Ty{0}) {
            return _Polar_positive_nan_inf_zero_rho(_Ty{0}, _Theta); 
        } else {
            return _Polar_positive_nan_inf_zero_rho(_Log_rho, _Theta); 
        }
    } else {
        return _Polar_positive_nan_inf_zero_rho(_Ctraits<_Ty>::_Abs(_Log_rho), _Theta); 
    }
}

template <class _Ty>
_Ty _Fabs(const complex<_Ty>& _Left, int* _Pexp) { 
                                                   
                                                   
    *_Pexp  = 0;
    _Ty _Av = _Ctraits<_Ty>::_Abs(::std:: real(_Left));
    _Ty _Bv = _Ctraits<_Ty>::_Abs(::std:: imag(_Left));

    if (_Ctraits<_Ty>::_Isinf(_Av) || _Ctraits<_Ty>::_Isinf(_Bv)) {
        return _Ctraits<_Ty>::_Infv(); 
    } else if (_Ctraits<_Ty>::_Isnan(_Av)) {
        return _Av; 
    } else if (_Ctraits<_Ty>::_Isnan(_Bv)) {
        return _Bv; 
    } else { 
        if (_Av < _Bv) { 
            ::std:: swap(_Av, _Bv);
        }

        if (_Av == 0) {
            return _Av; 
        }

        if (1 <= _Av) {
            *_Pexp = 4;
            _Av    = _Av * static_cast<_Ty>(0.0625);
            _Bv    = _Bv * static_cast<_Ty>(0.0625);
        } else {
            constexpr _Ty _Flt_eps = _Ctraits<_Ty>::_Flt_eps();
            
            constexpr _Ty _Leg_tiny = _Flt_eps == 0 ? _Ty{0} : 2 * _Ctraits<_Ty>::_Flt_norm_min() / _Flt_eps;

            if (_Av < _Leg_tiny) {
                constexpr int _Exponent = -2 * numeric_limits<_Ty>::digits;

                *_Pexp = _Exponent;
                _Av    = _Ctraits<_Ty>::ldexp(_Av, -_Exponent);
                _Bv    = _Ctraits<_Ty>::ldexp(_Bv, -_Exponent);
            } else {
                *_Pexp = -2;
                _Av    = _Av * 4;
                _Bv    = _Bv * 4;
            }
        }

        const _Ty _Tmp = _Av - _Bv;
        if (_Tmp == _Av) {
            return _Av; 
        } else if (_Bv < _Tmp) { 
            const _Ty _Qv = _Av / _Bv;
            return _Av + _Bv / (_Qv + _Ctraits<_Ty>::sqrt(_Qv * _Qv + 1));
        } else { 
            constexpr _Ty _Root2            = static_cast<_Ty>(1.4142135623730950488016887242096981L);
            constexpr _Ty _Oneplusroot2high = static_cast<_Ty>(10125945.0 / 4194304.0); 
            constexpr _Ty _Oneplusroot2low  = static_cast<_Ty>(1.4341252375973918872420969807856967e-7L);

            const _Ty _Qv = _Tmp / _Bv;
            const _Ty _Rv = (_Qv + 2) * _Qv;
            const _Ty _Sv = _Rv / (_Root2 + _Ctraits<_Ty>::sqrt(_Rv + 2)) + _Oneplusroot2low + _Qv + _Oneplusroot2high;
            return _Av + _Bv / _Sv;
        }
    }
}

template <class _Ty>
[[nodiscard]] _Ty _Log_abs(const complex<_Ty>& _Left) noexcept { 
    return static_cast<_Ty>(
        _Math_algorithms::_Log_hypot(static_cast<double>(::std:: real(_Left)), static_cast<double>(::std:: imag(_Left))));
}

[[nodiscard]] inline float _Log_abs(const complex<float>& _Left) noexcept {
    return _Math_algorithms::_Log_hypot(::std:: real(_Left), ::std:: imag(_Left));
}

template <class _Ty>
[[nodiscard]] complex<_Ty> log(const complex<_Ty>& _Left) {
    const _Ty _Log_abs_v = ::std:: _Log_abs(_Left); 
    const _Ty _Theta     = _Ctraits<_Ty>::atan2(::std:: imag(_Left), ::std:: real(_Left)); 
    return complex<_Ty>(_Log_abs_v, _Theta);
}

template <class _Ty>
complex<_Ty> _Pow(const _Ty& _Left, const _Ty& _Right) {
    if (0 <= _Left) {
        return complex<_Ty>(_Ctraits<_Ty>::pow(_Left, _Right), _Ctraits<_Ty>::_Copysign(_Ty{0}, _Right));
    } else {
        return exp(_Right * log(complex<_Ty>(_Left)));
    }
}

template <class _Ty>
[[nodiscard]] complex<_Ty> pow(const complex<_Ty>& _Left, const _Ty& _Right) {
    if (imag(_Left) == 0) {
        if (_Ctraits<_Ty>::_Signbit(imag(_Left))) {
            return conj(_Pow(real(_Left), _Right));
        } else {
            return _Pow(real(_Left), _Right);
        }
    } else {
        return exp(_Right * log(_Left));
    }
}

template <class _Ty>
[[nodiscard]] complex<_Ty> pow(const _Ty& _Left, const complex<_Ty>& _Right) {
    if (imag(_Right) == 0) {
        return _Pow(_Left, real(_Right));
    } else if (0 < _Left) {
        return exp(_Right * _Ctraits<_Ty>::log(_Left));
    } else {
        return exp(_Right * log(complex<_Ty>(_Left)));
    }
}

template <class _Ty>
[[nodiscard]] complex<_Ty> pow(const complex<_Ty>& _Left, const complex<_Ty>& _Right) {
    if (imag(_Right) == 0) {
        return pow(_Left, real(_Right));
    } else if (imag(_Left) == 0 && 0 < real(_Left)) {
        return exp(_Right * _Ctraits<_Ty>::log(real(_Left)));
    } else {
        return exp(_Right * log(_Left));
    }
}

template <class _Ty>
[[nodiscard]] complex<_Ty> sinh(const complex<_Ty>& _Left) {
    return complex<_Ty>(_Ctraits<_Ty>::_Sinh(real(_Left), _Ctraits<_Ty>::cos(imag(_Left))),
        _Ctraits<_Ty>::_Cosh(real(_Left), _Ctraits<_Ty>::sin(imag(_Left))));
}

template <class _Ty>
[[nodiscard]] complex<_Ty> sqrt(const complex<_Ty>& _Left) {
    int _Leftexp;
    _Ty _Rho = _Fabs(_Left, &_Leftexp); 

    if (_Leftexp == 0) {
        
        if (_Rho == 0) {
            return complex<_Ty>(_Ty{0}, imag(_Left));
        } else if (_Ctraits<_Ty>::_Isinf(_Rho)) {
            const _Ty _Re = real(_Left);
            const _Ty _Im = imag(_Left);

            if (_Ctraits<_Ty>::_Isinf(_Im)) {
                return complex<_Ty>(_Ctraits<_Ty>::_Infv(), _Im); 
            } else if (_Ctraits<_Ty>::_Isnan(_Im)) {
                if (_Re < 0) {
                    return complex<_Ty>(_Ctraits<_Ty>::_Abs(_Im), _Ctraits<_Ty>::_Copysign(_Re, _Im)); 
                } else {
                    return _Left; 
                }
            } else {
                if (_Re < 0) {
                    return complex<_Ty>(_Ty{0}, _Ctraits<_Ty>::_Copysign(_Re, _Im)); 
                } else {
                    return complex<_Ty>(_Re, _Ctraits<_Ty>::_Copysign(_Ty{0}, _Im)); 
                }
            }
        } else {
            return complex<_Ty>(_Rho, _Rho);
        }
    } else { 
        _Ty _Realmag = _Ctraits<_Ty>::ldexp(_Ctraits<_Ty>::_Abs(real(_Left)), -_Leftexp);
        _Rho         = _Ctraits<_Ty>::ldexp(_Ctraits<_Ty>::sqrt(2 * (_Realmag + _Rho)), _Leftexp / 2 - 1);

        if (0 <= real(_Left)) {
            return complex<_Ty>(_Rho, imag(_Left) / (2 * _Rho));
        } else {
            return complex<_Ty>(
                _Ctraits<_Ty>::_Abs(imag(_Left) / (2 * _Rho)), _Ctraits<_Ty>::_Copysign(_Rho, imag(_Left)));
        }
    }
}

template <class _Ty>
[[nodiscard]] complex<_Ty> tanh(const complex<_Ty>& _Left) {
    _Ty _Tv = _Ctraits<_Ty>::tan(imag(_Left));
    _Ty _Sv = _Ctraits<_Ty>::_Sinh(real(_Left), _Ty{1});
    _Ty _Bv = _Sv * (_Ty{1} + _Tv * _Tv);
    _Ty _Dv = _Ty{1} + _Bv * _Sv;

    if (_Ctraits<_Ty>::_Isinf(_Dv)) {
        _Ty _Real;

        if (_Sv < _Ty{0}) {
            _Real = -_Ty{1};
        } else {
            _Real = _Ty{1};
        }

        return complex<_Ty>(_Real, _Tv * _Ty{0});
    }

    return complex<_Ty>((_Ctraits<_Ty>::sqrt(_Ty{1} + _Sv * _Sv)) * _Bv / _Dv, _Tv / _Dv);
}

template <class _Ty>
[[nodiscard]] _Ty arg(const complex<_Ty>& _Left) { 
    return _Ctraits<_Ty>::atan2(imag(_Left), real(_Left));
}

template <class _Ty>
[[nodiscard]] constexpr complex<_Ty> conj(const complex<_Ty>& _Left) { 
    return complex<_Ty>(real(_Left), -imag(_Left));
}

template <class _Ty>
[[nodiscard]] complex<_Ty> proj(const complex<_Ty>& _Left) { 
    if (_Ctraits<_Ty>::_Isinf(real(_Left)) || _Ctraits<_Ty>::_Isinf(imag(_Left))) {
        const _Ty _Imag = _Ctraits<_Ty>::_Copysign(_Ty{0}, imag(_Left));
        return complex<_Ty>(_Ctraits<_Ty>::_Infv(), _Imag);
    }

    return _Left;
}

template <class _Ty>
[[nodiscard]] complex<_Ty> cos(const complex<_Ty>& _Left) {
    return complex<_Ty>(_Ctraits<_Ty>::_Cosh(imag(_Left), _Ctraits<_Ty>::cos(real(_Left))),
        -_Ctraits<_Ty>::_Sinh(imag(_Left), _Ctraits<_Ty>::sin(real(_Left))));
}

template <class _Ty>
[[nodiscard]] complex<_Ty> log10(const complex<_Ty>& _Left) {
    return log(_Left) * static_cast<_Ty>(0.43429448190325182765112891891660508L);
}

template <class _Ty>
[[nodiscard]] constexpr _Ty norm(const complex<_Ty>& _Left) { 
    return real(_Left) * real(_Left) + imag(_Left) * imag(_Left);
}

template <class _Ty>
[[nodiscard]] complex<_Ty> polar(const _Ty& _Rho, const _Ty& _Theta) { 
    if (!_Ctraits<_Ty>::_Isnan(_Rho) && !_Ctraits<_Ty>::_Isinf(_Rho) && _Rho != _Ty{0}) { 
        return complex<_Ty>(_Rho * _Ctraits<_Ty>::cos(_Theta), _Rho * _Ctraits<_Ty>::sin(_Theta));
    }

    
    if (_Ctraits<_Ty>::_Signbit(_Rho)) {
        return -_Polar_positive_nan_inf_zero_rho(-_Rho, _Theta);
    } else {
        return _Polar_positive_nan_inf_zero_rho(_Rho, _Theta);
    }
}

template <class _Ty>
[[nodiscard]] complex<_Ty> polar(const _Ty& _Rho) { 
    return complex<_Ty>(_Rho, _Ty{0});
}

template <class _Ty>
[[nodiscard]] complex<_Ty> sin(const complex<_Ty>& _Left) {
    return complex<_Ty>(_Ctraits<_Ty>::_Cosh(imag(_Left), _Ctraits<_Ty>::sin(real(_Left))),
        _Ctraits<_Ty>::_Sinh(imag(_Left), _Ctraits<_Ty>::cos(real(_Left))));
}

template <class _Ty>
[[nodiscard]] complex<_Ty> tan(const complex<_Ty>& _Left) {
    complex<_Ty> _Zv(tanh(complex<_Ty>(-imag(_Left), real(_Left))));
    return complex<_Ty>(imag(_Zv), -real(_Zv));
}

template <class _Ty>
using _Upgrade_to_double = conditional_t<is_integral_v<_Ty>, double, _Ty>;

template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>
[[nodiscard]] _Upgrade_to_double<_Ty> arg(_Ty _Left) {
    using _Upgraded = _Upgrade_to_double<_Ty>;
    const auto _Val = static_cast<_Upgraded>(_Left);

    return _Ctraits<_Upgraded>::atan2(0, _Val);
}

template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>
[[nodiscard]] constexpr _Upgrade_to_double<_Ty> imag(_Ty) {
    return 0;
}

template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>
[[nodiscard]] constexpr _Upgrade_to_double<_Ty> real(_Ty _Left) {
    using _Upgraded = _Upgrade_to_double<_Ty>;
    const auto _Val = static_cast<_Upgraded>(_Left);

    return _Val;
}

template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>
[[nodiscard]] constexpr _Upgrade_to_double<_Ty> norm(_Ty _Left) {
    using _Upgraded = _Upgrade_to_double<_Ty>;
    const auto _Val = static_cast<_Upgraded>(_Left);

    return _Val * _Val;
}

template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>
[[nodiscard]] constexpr complex<_Upgrade_to_double<_Ty>> conj(_Ty _Left) {
    using _Upgraded = _Upgrade_to_double<_Ty>;
    const auto _Val = static_cast<_Upgraded>(_Left);

    return complex<_Upgraded>(_Val, -_Upgraded{0});
}

template <class _Ty, enable_if_t<is_arithmetic_v<_Ty>, int> = 0>
[[nodiscard]] complex<_Upgrade_to_double<_Ty>> proj(_Ty _Left) {
    using _Upgraded = _Upgrade_to_double<_Ty>;
    const auto _Val = static_cast<_Upgraded>(_Left);

    if (_Ctraits<_Upgraded>::_Isinf(_Val)) {
        
        
        return complex<_Upgraded>(_Ctraits<_Upgraded>::_Infv(), 0);
    }

    return complex<_Upgraded>(_Val, 0);
}

template <class _Ty1, class _Ty2>
[[nodiscard]] complex<_Common_float_type_t<_Ty1, _Ty2>> pow(const complex<_Ty1>& _Left, const complex<_Ty2>& _Right) {
    using _Type = complex<_Common_float_type_t<_Ty1, _Ty2>>;
    return ::std:: pow(_Type(_Left), _Type(_Right));
}

template <class _Ty1, class _Ty2, enable_if_t<is_arithmetic_v<_Ty2>, int> = 0>
[[nodiscard]] complex<_Common_float_type_t<_Ty1, _Ty2>> pow(const complex<_Ty1>& _Left, const _Ty2& _Right) {
    using _Promoted = _Common_float_type_t<_Ty1, _Ty2>;
    using _Type     = complex<_Promoted>;
    return ::std:: pow(_Type(_Left), _Type(static_cast<_Promoted>(_Right)));
}

template <class _Ty1, class _Ty2, enable_if_t<is_arithmetic_v<_Ty1>, int> = 0>
[[nodiscard]] complex<_Common_float_type_t<_Ty1, _Ty2>> pow(const _Ty1& _Left, const complex<_Ty2>& _Right) {
    using _Promoted = _Common_float_type_t<_Ty1, _Ty2>;
    using _Type     = complex<_Promoted>;
    return ::std:: pow(_Type(static_cast<_Promoted>(_Left)), _Type(_Right));
}

template <class _Ty, class _Elem, class _Tr>
basic_istream<_Elem, _Tr>& operator>>(basic_istream<_Elem, _Tr>& _Istr, complex<_Ty>& _Right) {
    const ctype<_Elem>& _Ctype_fac = ::std:: use_facet<ctype<_Elem>>(_Istr.getloc());
    _Elem _Ch                      = 0;
    long double _Real              = 0;
    long double _Imag              = 0;

    if (_Istr >> _Ch && _Ch != _Ctype_fac.widen('(')) { 
        _Istr.putback(_Ch);
        _Istr >> _Real;
        _Imag = 0;
    } else if (_Istr >> _Real >> _Ch && _Ch != _Ctype_fac.widen(',')) {
        if (_Ch == _Ctype_fac.widen(')')) {
            _Imag = 0; 
        } else { 
            _Istr.putback(_Ch);
            _Istr.setstate(ios_base::failbit);
        }
    } else if (_Istr >> _Imag >> _Ch && _Ch != _Ctype_fac.widen(')')) { 
        _Istr.putback(_Ch);
        _Istr.setstate(ios_base::failbit);
    }

    if (!_Istr.fail()) { 
        _Ty _Tyreal(static_cast<_Ty>(_Real)), _Tyimag(static_cast<_Ty>(_Imag));
        _Right = complex<_Ty>(_Tyreal, _Tyimag);
    }
    return _Istr;
}

template <class _Ty, class _Elem, class _Tr>
basic_ostream<_Elem, _Tr>& operator<<(basic_ostream<_Elem, _Tr>& _Ostr, const complex<_Ty>& _Right) {
    const ctype<_Elem>& _Ctype_fac = ::std:: use_facet<ctype<_Elem>>(_Ostr.getloc());
    basic_ostringstream<_Elem, _Tr, allocator<_Elem>> _Sstr;

    _Sstr.flags(_Ostr.flags());
    _Sstr.imbue(_Ostr.getloc());
    _Sstr.precision(_Ostr.precision());
    _Sstr << _Ctype_fac.widen('(') << real(_Right) << _Ctype_fac.widen(',') << imag(_Right) << _Ctype_fac.widen(')');

    return _Ostr << _Sstr.str();
}

inline namespace literals {
    inline namespace complex_literals {
        [[nodiscard]] constexpr complex<long double> operator""il(long double _Val) {
            return complex<long double>(0.0L, static_cast<long double>(_Val));
        }

        [[nodiscard]] constexpr complex<long double> operator""il(unsigned long long _Val) {
            return complex<long double>(0.0L, static_cast<long double>(_Val));
        }

        [[nodiscard]] constexpr complex<double> operator""i(long double _Val) {
            return complex<double>(0.0, static_cast<double>(_Val));
        }

        [[nodiscard]] constexpr complex<double> operator""i(unsigned long long _Val) {
            return complex<double>(0.0, static_cast<double>(_Val));
        }

        [[nodiscard]] constexpr complex<float> operator""if(long double _Val) {
            return complex<float>(0.0f, static_cast<float>(_Val));
        }

        [[nodiscard]] constexpr complex<float> operator""if(unsigned long long _Val) {
            return complex<float>(0.0f, static_cast<float>(_Val));
        }
    } 
} 

}


#pragma warning(pop)
#pragma pack(pop)
#line 2278 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\complex"
#line 2279 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\complex"
#line 76 "all-std.cxx"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\numbers"


#pragma once


#line 14 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\numbers"


#line 19 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\numbers"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
namespace numbers {
    template <class _Ty>
    struct _Invalid {
        static_assert(_Always_false<_Ty>, "A program that instantiates a primary template of a mathematical constant "
                                          "variable template is ill-formed. (N4835 [math.constants]/3)");
    };

    template <class _Ty>
    inline constexpr _Ty e_v = _Invalid<_Ty>{};
    template <class _Ty>
    inline constexpr _Ty log2e_v = _Invalid<_Ty>{};
    template <class _Ty>
    inline constexpr _Ty log10e_v = _Invalid<_Ty>{};
    template <class _Ty>
    inline constexpr _Ty pi_v = _Invalid<_Ty>{};
    template <class _Ty>
    inline constexpr _Ty inv_pi_v = _Invalid<_Ty>{};
    template <class _Ty>
    inline constexpr _Ty inv_sqrtpi_v = _Invalid<_Ty>{};
    template <class _Ty>
    inline constexpr _Ty ln2_v = _Invalid<_Ty>{};
    template <class _Ty>
    inline constexpr _Ty ln10_v = _Invalid<_Ty>{};
    template <class _Ty>
    inline constexpr _Ty sqrt2_v = _Invalid<_Ty>{};
    template <class _Ty>
    inline constexpr _Ty sqrt3_v = _Invalid<_Ty>{};
    template <class _Ty>
    inline constexpr _Ty inv_sqrt3_v = _Invalid<_Ty>{};
    template <class _Ty>
    inline constexpr _Ty egamma_v = _Invalid<_Ty>{};
    template <class _Ty>
    inline constexpr _Ty phi_v = _Invalid<_Ty>{};


    template <floating_point _Floating>
    inline constexpr _Floating e_v<_Floating> = static_cast<_Floating>(2.718281828459045);
    template <floating_point _Floating>
    inline constexpr _Floating log2e_v<_Floating> = static_cast<_Floating>(1.4426950408889634);
    template <floating_point _Floating>
    inline constexpr _Floating log10e_v<_Floating> = static_cast<_Floating>(0.4342944819032518);
    template <floating_point _Floating>
    inline constexpr _Floating pi_v<_Floating> = static_cast<_Floating>(3.141592653589793);
    template <floating_point _Floating>
    inline constexpr _Floating inv_pi_v<_Floating> = static_cast<_Floating>(0.3183098861837907);
    template <floating_point _Floating>
    inline constexpr _Floating inv_sqrtpi_v<_Floating> = static_cast<_Floating>(0.5641895835477563);
    template <floating_point _Floating>
    inline constexpr _Floating ln2_v<_Floating> = static_cast<_Floating>(0.6931471805599453);
    template <floating_point _Floating>
    inline constexpr _Floating ln10_v<_Floating> = static_cast<_Floating>(2.302585092994046);
    template <floating_point _Floating>
    inline constexpr _Floating sqrt2_v<_Floating> = static_cast<_Floating>(1.4142135623730951);
    template <floating_point _Floating>
    inline constexpr _Floating sqrt3_v<_Floating> = static_cast<_Floating>(1.7320508075688772);
    template <floating_point _Floating>
    inline constexpr _Floating inv_sqrt3_v<_Floating> = static_cast<_Floating>(0.5773502691896257);
    template <floating_point _Floating>
    inline constexpr _Floating egamma_v<_Floating> = static_cast<_Floating>(0.5772156649015329);
    template <floating_point _Floating>
    inline constexpr _Floating phi_v<_Floating> = static_cast<_Floating>(1.618033988749895);


#line 171 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\numbers"

    inline constexpr double e          = e_v<double>;
    inline constexpr double log2e      = log2e_v<double>;
    inline constexpr double log10e     = log10e_v<double>;
    inline constexpr double pi         = pi_v<double>;
    inline constexpr double inv_pi     = inv_pi_v<double>;
    inline constexpr double inv_sqrtpi = inv_sqrtpi_v<double>;
    inline constexpr double ln2        = ln2_v<double>;
    inline constexpr double ln10       = ln10_v<double>;
    inline constexpr double sqrt2      = sqrt2_v<double>;
    inline constexpr double sqrt3      = sqrt3_v<double>;
    inline constexpr double inv_sqrt3  = inv_sqrt3_v<double>;
    inline constexpr double egamma     = egamma_v<double>;
    inline constexpr double phi        = phi_v<double>;
} 
}


#pragma warning(pop)
#pragma pack(pop)
#line 193 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\numbers"
#line 194 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\numbers"
#line 195 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\numbers"
#line 77 "all-std.cxx"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


#pragma warning(disable : 4127) 

namespace std {


template <class _Seed_seq, class _Self, class _Engine = _Self>
using _Enable_if_seed_seq_t = enable_if_t<
    !is_convertible_v<remove_cv_t<_Seed_seq>,
        typename _Self::
            result_type> && !is_same_v<remove_cv_t<_Seed_seq>, _Self> && !is_same_v<remove_cv_t<_Seed_seq>, _Engine>,
    int>;

inline constexpr long double _Pi    = 3.14159265358979323846264338327950288L;
inline constexpr long double _Exp1  = 2.71828182845904523536028747135266250L;
inline constexpr long double _Two32 = 4294967296.0L;
inline constexpr long double _Two31 = 2147483648.0L;

 float __cdecl _XLgamma(float);
 double __cdecl _XLgamma(double);
 long double __cdecl _XLgamma(long double);

inline constexpr int _Nwords = 4;

template <class _Elem, class _Traits>
basic_ostream<_Elem, _Traits>& _Write(
    basic_ostream<_Elem, _Traits>& _Os, long double _Dx) { 
    int _Ex;
    long double _Frac = :: frexpl(_Dx, &_Ex);
    for (int _Nw = 0; _Nw < _Nwords; ++_Nw) { 
        _Frac *= _Two31;
        long _Digits = static_cast<long>(_Frac);
        _Frac -= _Digits;
        _Os << ' ' << _Digits;
    }
    _Os << ' ' << _Ex;
    return _Os;
}

template <class _Elem, class _Traits>
basic_istream<_Elem, _Traits>& _Read(
    basic_istream<_Elem, _Traits>& _Is, long double& _Dx) { 
    long double _Frac = 0.0;
    long _Digits;
    for (int _Nw = 0; _Nw < _Nwords; ++_Nw) { 
        _Is >> _Digits;
        long double _Temp = _Digits / _Two31;
        for (int _Idx = 0; _Idx < _Nw; ++_Idx) {
            _Temp /= _Two31;
        }

        _Frac += _Temp;
    }
    _Is >> _Digits;
    _Dx = :: ldexpl(_Frac, _Digits);
    return _Is;
}

template <class _Elem, class _Traits, class _Ty>
basic_istream<_Elem, _Traits>& _In(basic_istream<_Elem, _Traits>& _Is, _Ty& _Dx) { 
    long double _Vx;
    _Ty _Max = (numeric_limits<_Ty>::max)();
    _Read(_Is, _Vx);
    if (:: fabsl(_Vx) <= _Max) {
        _Dx = static_cast<_Ty>(_Vx);
    } else if (_Vx < 0) {
        _Dx = -_Max;
    } else {
        _Dx = _Max;
    }

    return _Is;
}

template <class _Elem, class _Traits, class _Ty>
basic_ostream<_Elem, _Traits>& _Out(basic_ostream<_Elem, _Traits>& _Os, _Ty _Dx) { 
    return _Write(_Os, _Dx);
}

template <class _Elem, class _Traits, class _Ty>
class _Wrap_istream { 
public:
    _Wrap_istream(basic_istream<_Elem, _Traits>& _Is) : _Str(_Is) {}

    _Ty operator()() { 
        _Ty _Data;
        _Str >> _Data;
        if (!_Str) {
            _Xinvalid_argument("input stream corrupted");
        }

        return _Data;
    }

    _Wrap_istream& operator=(const _Wrap_istream&) = delete;

private:
    basic_istream<_Elem, _Traits>& _Str;
};

class seed_seq { 
public:
    using result_type = unsigned int;

    seed_seq() noexcept {}

    template <class _Ty, enable_if_t<is_integral_v<_Ty>, int> = 0>
    seed_seq(initializer_list<_Ty> _Ilist) {
        _Construct(_Ilist.begin(), _Ilist.end());
    }

    template <class _InIt>
    seed_seq(_InIt _First, _InIt _Last) {
        _Construct(_First, _Last);
    }

    template <class _RanIt>
    void generate(_RanIt _First, _RanIt _Last) const { 
        _Adl_verify_range(_First, _Last);
        auto _UFirst   = _Get_unwrapped(_First);
        const auto _Nx = static_cast<size_t>(_Get_unwrapped(_Last) - _UFirst);

        if (0 < _Nx) { 
            const size_t _Sx = _Myvec.size();
            const size_t _Tx = 623 <= _Nx ? 11 : 68 <= _Nx ? 7 : 39 <= _Nx ? 5 : 7 <= _Nx ? 3 : (_Nx - 1) / 2;
            const size_t _Px = (_Nx - _Tx) / 2;
            const size_t _Qx = _Px + _Tx;
            const size_t _Mx = _Nx <= _Sx ? _Sx + 1 : _Nx;
            size_t _Kx;

            _Iter_value_t<_RanIt> _Mask = _Iter_value_t<_RanIt>(1) << 31;
            _Mask <<= 1; 
            _Mask -= 1;

            for (_Kx = 0; _Kx < _Nx; ++_Kx) {
                _UFirst[_Kx] = 0x8b8b8b8b;
            }

            for (_Kx = 0; _Kx < _Mx; ++_Kx) { 
                result_type _Rx1 =
                    1664525 * _Xor27(_UFirst[_Kx % _Nx] ^ _UFirst[(_Kx + _Px) % _Nx] ^ _UFirst[(_Kx - 1) % _Nx]);

                size_t _Off;
                if (_Kx == 0) {
                    _Off = _Sx;
                } else if (_Kx <= _Sx) {
                    _Off = _Kx % _Nx + _Myvec[_Kx - 1];
                } else {
                    _Off = _Kx % _Nx;
                }
                result_type _Rx2 = static_cast<result_type>((_Rx1 + _Off) & _Mask);

                _UFirst[(_Kx + _Px) % _Nx] = (_UFirst[(_Kx + _Px) % _Nx] + _Rx1) & _Mask;
                _UFirst[(_Kx + _Qx) % _Nx] = (_UFirst[(_Kx + _Qx) % _Nx] + _Rx2) & _Mask;
                _UFirst[_Kx % _Nx]         = _Rx2;
            }
            for (; _Kx < _Mx + _Nx; ++_Kx) { 
                result_type _Rx3 =
                    1566083941 * _Xor27(_UFirst[_Kx % _Nx] + _UFirst[(_Kx + _Px) % _Nx] + _UFirst[(_Kx - 1) % _Nx]);
                result_type _Rx4 = static_cast<result_type>((_Rx3 - _Kx % _Nx) & _Mask);

                _UFirst[(_Kx + _Px) % _Nx] = (_UFirst[(_Kx + _Px) % _Nx] ^ _Rx3) & _Mask;
                _UFirst[(_Kx + _Qx) % _Nx] = (_UFirst[(_Kx + _Qx) % _Nx] ^ _Rx4) & _Mask;
                _UFirst[_Kx % _Nx]         = _Rx4;
            }
        }
    }

    template <class _OutIt>
    void param(_OutIt _Dest) const { 
        ::std:: copy(_Myvec.begin(), _Myvec.end(), _Dest);
    }

    [[nodiscard]] size_t size() const noexcept { 
        return _Myvec.size();
    }

    seed_seq(const seed_seq&) = delete;
    void operator=(const seed_seq&) = delete;

private:
    template <class _InIt>
    void _Construct(_InIt _First, _InIt _Last) {
        for (; _First != _Last; ++_First) {
            _Myvec.push_back(static_cast<unsigned int>(*_First));
        }
    }

    result_type _Xor27(result_type _Val) const { 
        return _Val ^ (_Val >> 27);
    }

    vector<result_type> _Myvec;
};

[[nodiscard]] constexpr int _Generate_canonical_iterations(const int _Bits, const uint64_t _Gmin, const uint64_t _Gmax) {
    
    
    ;

    if (_Bits == 0 || (_Gmax == 0xffffffffffffffffui64 && _Gmin == 0)) {
        return 1;
    }

    const auto _Range  = (_Gmax - _Gmin) + 1;
    const auto _Target = ~uint64_t{0} >> (64 - _Bits);
    uint64_t _Prod     = 1;
    int _Ceil          = 0;
    while (_Prod <= _Target) {
        ++_Ceil;
        if (_Prod > 0xffffffffffffffffui64 / _Range) {
            break;
        }

        _Prod *= _Range;
    }

    return _Ceil;
}

template <class _Real, size_t _Bits, class _Gen>
[[nodiscard]] _Real generate_canonical(_Gen& _Gx) { 
    static_assert(_Is_any_of_v<_Real, float, double, long double>, "invalid template argument for " "generate_canonical" ": N4659 29.6.1.1 [rand.req.genl]/1d requires one of " "float, double, or long double");

    constexpr auto _Digits  = static_cast<size_t>(numeric_limits<_Real>::digits);
    constexpr auto _Minbits = static_cast<int>(_Digits < _Bits ? _Digits : _Bits);

    constexpr auto _Gxmin = static_cast<_Real>((_Gen::min)());
    constexpr auto _Gxmax = static_cast<_Real>((_Gen::max)());
    constexpr auto _Rx    = (_Gxmax - _Gxmin) + _Real{1};

    constexpr int _Kx = _Generate_canonical_iterations(_Minbits, (_Gen::min)(), (_Gen::max)());

    _Real _Ans{0};
    _Real _Factor{1};

    for (int _Idx = 0; _Idx < _Kx; ++_Idx) { 
        _Ans += (static_cast<_Real>(_Gx()) - _Gxmin) * _Factor;
        _Factor *= _Rx;
    }

    return _Ans / _Factor;
}

template <class _Gen, class = void>
struct _Has_static_min_max : false_type {};


template <class _Gen>
struct _Has_static_min_max<_Gen, void_t<decltype(bool_constant<(_Gen::min)() < (_Gen::max)()>::value)>> : true_type {};

template <class _Real, class _Gen>
[[nodiscard]] _Real _Nrand_impl(_Gen& _Gx) { 
    static_assert(_Is_any_of_v<_Real, float, double, long double>, "invalid template argument for " "_Nrand_impl" ": N4659 29.6.1.1 [rand.req.genl]/1d requires one of " "float, double, or long double");

    constexpr auto _Digits  = static_cast<size_t>(numeric_limits<_Real>::digits);
    constexpr auto _Bits    = ~size_t{0};
    constexpr auto _Minbits = _Digits < _Bits ? _Digits : _Bits;

    if constexpr (_Has_static_min_max<_Gen>::value && _Minbits <= 64) {
        return ::std:: generate_canonical<_Real, _Minbits>(_Gx);
    } else { 
        const _Real _Gxmin = static_cast<_Real>((_Gx.min)());
        const _Real _Gxmax = static_cast<_Real>((_Gx.max)());
        const _Real _Rx    = (_Gxmax - _Gxmin) + _Real{1};

        const int _Ceil = static_cast<int>(::std:: ceil(static_cast<_Real>(_Minbits) / ::std:: log2(_Rx)));
        const int _Kx   = _Ceil < 1 ? 1 : _Ceil;

        _Real _Ans{0};
        _Real _Factor{1};

        for (int _Idx = 0; _Idx < _Kx; ++_Idx) { 
            _Ans += (static_cast<_Real>(_Gx()) - _Gxmin) * _Factor;
            _Factor *= _Rx;
        }

        return _Ans / _Factor;
    }
}


inline constexpr int _MP_len = 5;
using _MP_arr                     = uint64_t[_MP_len];

[[nodiscard]]  uint64_t __cdecl _MP_Get(_MP_arr) noexcept;
 void __cdecl _MP_Add(_MP_arr, uint64_t) noexcept;
 void __cdecl _MP_Mul(_MP_arr, uint64_t, uint64_t) noexcept;
 void __cdecl _MP_Rem(_MP_arr, uint64_t) noexcept;

template <class _Uint, _Uint _Ax, _Uint _Cx, _Uint _Mx>
[[nodiscard]] _Uint _Next_linear_congruential_value(_Uint _Prev) noexcept {
    
    
    if constexpr (_Ax == 0) { 
        return static_cast<_Uint>(_Cx); 
    } else if constexpr (_Mx == 0) {
        
        
        return static_cast<_Uint>(static_cast<_Uint>(_Ax * _Prev) + _Cx);
    } else if constexpr (_Cx <= 0xffffffff && static_cast<_Uint>(_Mx - 1) <= (0xffffffff - _Cx) / _Ax) {
        
        const auto _Mul =
            static_cast<unsigned int>(_Prev) * static_cast<unsigned int>(_Ax) + static_cast<unsigned int>(_Cx);
        return static_cast<_Uint>(_Mul % _Mx);
    } else if constexpr (_Cx <= 0xffffffffffffffffui64 && static_cast<_Uint>(_Mx - 1) <= (0xffffffffffffffffui64 - _Cx) / _Ax) {
        
        const auto _Mul = static_cast<unsigned long long>(_Prev) * _Ax + _Cx;
        return static_cast<_Uint>(_Mul % _Mx);
    } else { 
        _MP_arr _Wx;
        _MP_Mul(_Wx, _Prev, _Ax);
        _MP_Add(_Wx, _Cx);
        _MP_Rem(_Wx, _Mx);
        return static_cast<_Uint>(_MP_Get(_Wx));
    }
}

template <class _Seed_seq>
[[nodiscard]] constexpr unsigned int _Seed_seq_to_uint(_Seed_seq& _Seq) {
    unsigned int _Arr[4]{};
    _Seq.generate(_Arr, _Arr + 4);
    return _Arr[3];
}

template <class _Seed_seq>
[[nodiscard]] constexpr unsigned long long _Seed_seq_to_ull(_Seed_seq& _Seq) {
    unsigned int _Arr[5]{};
    _Seq.generate(_Arr, _Arr + 5);
    unsigned long long _Result = _Arr[4];
    _Result <<= 32;
    _Result |= _Arr[3];
    return _Result;
}

template <class _Uint, _Uint _Cx, _Uint _Mx>
[[nodiscard]] constexpr _Uint _Get_linear_congruential_seed(_Uint _Sx) noexcept { 
    if constexpr (_Mx != 0) {
        _Sx %= _Mx;
    }

    if constexpr (_Cx == 0) {
        if (_Sx == 0) {
            _Sx = _Uint{1};
        }
    }

    return _Sx;
}

template <class _Uint, _Uint _Cx, _Uint _Mx, class _Seed_seq>
[[nodiscard]] _Uint _Get_linear_congruential_seed_from_seq(_Seed_seq& _Seq) { 
    _Uint _Sx;
    if constexpr (_Mx == 0) {
        if constexpr (sizeof(_Uint) <= sizeof(unsigned int)) {
            _Sx = static_cast<_Uint>(_Seed_seq_to_uint(_Seq));
        } else {
            _Sx = static_cast<_Uint>(_Seed_seq_to_ull(_Seq));
        }
    } else if constexpr (_Mx <= 0xffffffff) {
        _Sx = static_cast<_Uint>(_Seed_seq_to_uint(_Seq) % _Mx);
    } else {
        _Sx = static_cast<_Uint>(_Seed_seq_to_ull(_Seq) % _Mx);
    }

    return _Get_linear_congruential_seed<_Uint, _Cx, _Mx>(_Sx);
}

template <class _Uint, _Uint _Ax, _Uint _Cx, _Uint _Mx>
class linear_congruential_engine { 
public:
    static_assert(_Is_any_of_v<_Uint, unsigned short, unsigned int, unsigned long, unsigned long long>, "invalid template argument for " "linear_congruential_engine" ": N4659 29.6.1.1 [rand.req.genl]/1f requires one of " "unsigned short, unsigned int, unsigned long, or unsigned long long"); static_assert(!_Is_character<_Uint>::value, "note: char, signed char, unsigned char, char8_t, int8_t, and uint8_t are not allowed");

    static_assert(0 == _Mx || (_Ax < _Mx && _Cx < _Mx), "invalid template argument for linear_congruential_engine");

    using result_type                       = _Uint;
    static constexpr result_type multiplier = _Ax;
    static constexpr result_type increment  = _Cx;
    static constexpr result_type modulus    = _Mx;

    [[nodiscard]] static constexpr result_type(min)() noexcept  {
        
        return _Cx == 0;
    }

#pragma warning(push)
#pragma warning(disable : 4309) 
    [[nodiscard]] static constexpr result_type(max)() noexcept  {
        
        return static_cast<result_type>(_Mx - 1u); 
    }
#pragma warning(pop)

    static constexpr result_type default_seed = 1u;

    linear_congruential_engine() noexcept 
        : _Prev(_Get_linear_congruential_seed<result_type, _Cx, _Mx>(default_seed)) {}

    explicit linear_congruential_engine(result_type _Sx) noexcept 
        : _Prev(_Get_linear_congruential_seed<result_type, _Cx, _Mx>(_Sx)) {}

    template <class _Seed_seq, _Enable_if_seed_seq_t<_Seed_seq, linear_congruential_engine> = 0>
    explicit linear_congruential_engine(_Seed_seq& _Seq)
        : _Prev(_Get_linear_congruential_seed_from_seq<result_type, _Cx, _Mx>(_Seq)) {}

    void seed(result_type _Sx = default_seed) noexcept  {
        
        _Prev = _Get_linear_congruential_seed<result_type, _Cx, _Mx>(_Sx);
    }

    template <class _Seed_seq, _Enable_if_seed_seq_t<_Seed_seq, linear_congruential_engine> = 0>
    void seed(_Seed_seq& _Seq) { 
        _Prev = _Get_linear_congruential_seed_from_seq<result_type, _Cx, _Mx>(_Seq);
    }

    [[nodiscard]] _Uint operator()() noexcept {
        _Prev = _Next_linear_congruential_value<result_type, _Ax, _Cx, _Mx>(_Prev);
        return _Prev;
    }

    void discard(unsigned long long _Nskip) noexcept  {
        
        auto _Temp = _Prev;
        for (; 0 < _Nskip; --_Nskip) {
            _Temp = _Next_linear_congruential_value<_Uint, _Ax, _Cx, _Mx>(_Temp);
        }

        _Prev = _Temp;
    }

    [[nodiscard]] friend bool operator==(
        const linear_congruential_engine& _Lhs, const linear_congruential_engine& _Rhs) noexcept
     {
        return _Lhs._Prev == _Rhs._Prev;
    }


#line 501 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

    template <class _Elem, class _Traits>
    friend basic_istream<_Elem, _Traits>& operator>>(
        basic_istream<_Elem, _Traits>& _Istr, linear_congruential_engine& _Eng) {
        return _Istr >> _Eng._Prev;
    }

    template <class _Elem, class _Traits>
    friend basic_ostream<_Elem, _Traits>& operator<<(
        basic_ostream<_Elem, _Traits>& _Ostr, const linear_congruential_engine& _Eng) {
        return _Ostr << _Eng._Prev;
    }

private:
    result_type _Prev;
};

template <class _Uint, _Uint _Ax, _Uint _Cx, _Uint _Mx>
class linear_congruential { 
public:
    static_assert(_Is_any_of_v<_Uint, unsigned short, unsigned int, unsigned long, unsigned long long>, "invalid template argument for " "linear_congruential" ": N4659 29.6.1.1 [rand.req.genl]/1f requires one of " "unsigned short, unsigned int, unsigned long, or unsigned long long"); static_assert(!_Is_character<_Uint>::value, "note: char, signed char, unsigned char, char8_t, int8_t, and uint8_t are not allowed");

    static_assert(0 == _Mx || (_Ax < _Mx && _Cx < _Mx), "invalid template argument for linear_congruential");

    using result_type = _Uint;

    static constexpr _Uint multiplier = _Ax;
    static constexpr _Uint increment  = _Cx;
    static constexpr _Uint modulus    = _Mx;

    linear_congruential() noexcept 
        : _Prev(_Get_linear_congruential_seed<_Uint, _Cx, _Mx>(1u)) {}

    explicit linear_congruential(_Uint _Xx0) noexcept 
        : _Prev(_Get_linear_congruential_seed<_Uint, _Cx, _Mx>(_Xx0)) {}

    template <class _Gen, _Enable_if_seed_seq_t<_Gen, linear_congruential> = 0>
    linear_congruential(_Gen& _Seq) : _Prev(_Get_linear_congruential_seed<_Uint, _Cx, _Mx>(_Seq())) {}

    void seed(_Uint _Xx0 = 1u) noexcept  {
        
        _Prev = _Get_linear_congruential_seed<_Uint, _Cx, _Mx>(_Xx0);
    }

    template <class _Gen, _Enable_if_seed_seq_t<_Gen, linear_congruential> = 0>
    void seed(_Gen& _Seq) { 
        _Prev = _Get_linear_congruential_seed<_Uint, _Cx, _Mx>(_Seq());
    }

    [[nodiscard]] _Uint(min)() const noexcept  {
        
        return _Cx == 0;
    }

#pragma warning(push)
#pragma warning(disable : 4309) 
    [[nodiscard]] _Uint(max)() const noexcept  {
        
        return static_cast<_Uint>(_Mx - 1u); 
    }
#pragma warning(pop)

    [[nodiscard]] _Uint operator()() noexcept  {
        
        _Prev = _Next_linear_congruential_value<_Uint, _Ax, _Cx, _Mx>(_Prev);
        return _Prev;
    }

    void discard(unsigned long long _Nskip) noexcept  {
        
        auto _Temp = _Prev;
        for (; 0 < _Nskip; --_Nskip) {
            _Temp = _Next_linear_congruential_value<_Uint, _Ax, _Cx, _Mx>(_Temp);
        }

        _Prev = _Temp;
    }

    [[nodiscard]] friend bool operator==(const linear_congruential& _Lhs, const linear_congruential& _Rhs) noexcept
     {
        return _Lhs._Prev == _Rhs._Prev;
    }


#line 590 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

    template <class _Elem, class _Traits>
    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr, linear_congruential& _Eng) {
        return _Istr >> _Eng._Prev;
    }

    template <class _Elem, class _Traits>
    friend basic_ostream<_Elem, _Traits>& operator<<(
        basic_ostream<_Elem, _Traits>& _Ostr, const linear_congruential& _Eng) {
        return _Ostr << _Eng._Prev;
    }

private:
    _Uint _Prev;
};

template <class _Ty, size_t _Nw>
struct _Circ_buf { 
    _Ty _At(size_t _Ix) const {
        return _Ax[_Base(_Ix)];
    }

    bool _Equals(const _Circ_buf& _Right) const {
        const _Ty* _Last1 = _Ax + _Idx;
        const _Ty* _Last2 = _Right._Ax + _Right._Idx;
        const _Ty* _First;
        const _Ty* _Last;
        const _Ty* _Other;
        bool _Use2 = _Base() < _Right._Base();

        if (_Use2) { 
                     
            _First = _Right._Ax + _Right._Base();
            _Last  = _Last2;
            _Other = _Ax + _Base();
        } else { 
                 
            _First = _Ax + _Base();
            _Last  = _Last1;
            _Other = _Right._Ax + _Right._Base();
        }

        ptrdiff_t _Nx0 = _Nw;
        while (0 < _Nx0) { 
                           
                           
            const _Ty* _Limit = _First < _Last ? _Last : _Use2 ? _Right._Ax + 2 * _Nw : _Ax + 2 * _Nw;
            _Nx0 -= _Limit - _First;
            while (_First != _Limit) {
                if (*_First++ != *_Other++) {
                    return false;
                }
            }

            _First = _Other;
            _Last  = _Use2 ? _Last1 : _Last2;
            _Other = _Use2 ? _Right._Ax : _Ax;
            _Use2  = !_Use2;
        }
        return true;
    }

    size_t _Base(size_t _Ix = 0) const {
        return (_Ix += _Idx) < _Nw ? (_Ix + _Nw) : (_Ix - _Nw);
    }

    unsigned int _Idx;
    _Ty _Ax[2 * _Nw];
};

template <class _Ty, size_t _Sx, size_t _Rx, class _Swc_Traits>
class _Swc_base : public _Circ_buf<_Ty, _Rx> { 
public:
    using result_type = _Ty;
    using _Traits     = _Swc_Traits;
    using _Mybase     = _Circ_buf<_Ty, _Rx>;
    using _Seed_t     = typename _Swc_Traits::_Seed_t;

    static constexpr size_t short_lag     = _Sx;
    static constexpr size_t long_lag      = _Rx;
    static constexpr _Seed_t default_seed = static_cast<_Seed_t>(19780503U);

    _Swc_base() {
        seed();
    }

    _Swc_base(_Seed_t _Xx0) {
        seed(_Xx0);
    }

    template <class _Gen, _Enable_if_seed_seq_t<_Gen, _Swc_base> = 0>
    _Swc_base(_Gen& _Gx) {
        seed(_Gx);
    }

    void seed(_Seed_t _Value = default_seed) { 
        _Seed(_Value, false, true_type{});
    }

    template <class _Gen>
    void seed(_Gen& _Gx, bool _Readcy = false) { 
        _Seed(_Gx, _Readcy, is_arithmetic<_Gen>{});
    }

    [[nodiscard]] result_type(min)() const {
        return 0;
    }

    [[nodiscard]] result_type(max)() const {
        return _Swc_Traits::_Max;
    }

    [[nodiscard]] result_type operator()() {
        const auto _Ix = 2 * _Rx <= this->_Idx ? 0 : this->_Idx;
        if (_Ix < _Sx) {
            _Setx(_Ix, this->_Ax[_Ix + 2 * _Rx - _Sx], this->_Ax[_Ix + _Rx]);
        } else if (_Ix < _Rx) {
            _Setx(_Ix, this->_Ax[_Ix - _Sx], this->_Ax[_Ix + _Rx]);
        } else {
            _Setx(_Ix, this->_Ax[_Ix - _Sx], this->_Ax[_Ix - _Rx]);
        }

        this->_Idx = _Ix + 1;
        return this->_Ax[_Ix];
    }

    void discard(unsigned long long _Nskip) { 
        for (; 0 < _Nskip; --_Nskip) {
            (void) (*this)();
        }
    }

    [[nodiscard]] friend bool operator==(const _Swc_base& _Left, const _Swc_base& _Right) {
        return static_cast<const _Swc_base::_Mybase&>(_Left)._Equals(_Right) && _Left._Carry == _Right._Carry;
    }


#line 733 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

    template <class _Elem, class _Traits>
    friend basic_istream<_Elem, _Traits>& operator>>(
        basic_istream<_Elem, _Traits>& _Istr, _Swc_base& _Eng) { 
        _Wrap_istream<_Elem, _Traits, typename _Swc_Traits::_Seed_t> _Gen(_Istr);
        _Eng.seed(_Gen, true);
        return _Istr;
    }

    template <class _Elem, class _Traits>
    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
        const _Swc_base& _Eng) { 
        _Swc_base::_Traits::_Write(_Ostr, _Eng, _Eng._Carry);
        return _Ostr;
    }

    template <class _Elem, class _Traits>
    basic_ostream<_Elem, _Traits>& _Write_full(basic_ostream<_Elem, _Traits>& _Ostr) const { 
        _Swc_Traits::_Write_full(_Ostr, *this, _Carry);
        return _Ostr;
    }

protected:
    template <class _Gen>
    void _Seed(_Gen& _Gx, bool _Readcy, true_type) { 
        linear_congruential<_Seed_t, 40014U, 0U, 2147483563U> _Lc(_Gx == 0U ? default_seed : _Gx);
        _Reset(_Lc, _Readcy);
    }

    template <class _Gen>
    void _Seed(_Gen& _Gx, bool _Readcy, false_type) { 
        _Reset(_Gx, _Readcy);
    }

    template <class _Gen>
    void _Reset(_Gen& _Gx, bool _Readcy) { 
        _Carry     = _Swc_Traits::_Reset(_Gx, this->_Ax, _Readcy);
        this->_Idx = _Rx;
    }

    void _Setx(size_t _Ix, _Ty _Xis, _Ty _Xir) { 
        bool _Underflowed = false;
        _Ty _Newx         = _Xis;
        if (_Newx < _Xir) {
            _Underflowed = true;
        }

        _Newx -= _Xir;
        if (_Newx < static_cast<typename _Swc_Traits::_UCy_t>(_Carry)) {
            _Underflowed = true;
        }

        _Newx -= _Carry;
        if (_Underflowed) { 
            _Newx += _Swc_Traits::_Mod;
            _Carry = _Swc_Traits::_Cy;
        } else {
            _Carry = 0;
        }

        this->_Ax[_Ix] = _Newx;
    }

    typename _Swc_Traits::_Cy_t _Carry;
};

template <class _Ty, size_t _Sx, size_t _Rx, class _Swc_Traits>
const size_t _Swc_base<_Ty, _Sx, _Rx, _Swc_Traits>::short_lag;

template <class _Ty, size_t _Sx, size_t _Rx, class _Swc_Traits>
const size_t _Swc_base<_Ty, _Sx, _Rx, _Swc_Traits>::long_lag;

template <class _Ty, _Ty _Mx, size_t _Nw>
struct _Swc_traits { 
    using _Cy_t   = int;
    using _UCy_t  = unsigned int;
    using _Mod_t  = _Ty;
    using _Seed_t = _Ty;

    static constexpr _Cy_t _Cy   = 1;
    static constexpr _Mod_t _Mod = _Mx;
    static constexpr _Ty _Max    = _Mx - 1;

    static int _Get_wc() { 
        int _Kx;

        if constexpr (_Mx == 0) {
            _Kx = (8 * sizeof(_Ty) + 31) / 32;
        } else { 
            unsigned long long _Val = 1ULL << 32;
            for (_Kx = 1; 0 < _Val && _Val < _Mx; ++_Kx) {
                _Val = _Val << 32;
            }
        }

        return _Kx;
    }

    template <class _Gen>
    static _Cy_t _Reset(_Gen& _Gx, _Ty* _Ax, bool _Readcy) { 
                                                             
                                                             
        int _Kx = _Get_wc();

        for (size_t _Ix = 0; _Ix < _Nw; ++_Ix) { 
            _Ax[_Ix] = _Gx();
            for (int _Jx = 1; _Jx < _Kx; ++_Jx) {
                _Ax[_Ix] |= static_cast<_Ty>(_Gx()) << (32 * _Jx);
            }
        }

        _Cy_t _Ans = _Reduce(_Ax);
        if (!_Readcy) {
            return _Ans;
        } else {
            return static_cast<_Cy_t>(_Gx()); 
        }
    }

#pragma warning(push)
#pragma warning(disable : 4724) 
    static _Cy_t _Reduce(_Ty* _Ax) { 
        if constexpr (_Mx != 0) {
            for (size_t _Ix = 0; _Ix < _Nw; ++_Ix) {
                _Ax[_Ix] = _Ax[_Ix] % _Mx;
            }
        }

        return _Ax[_Nw - 1] == 0;
    }
#pragma warning(pop)

    template <class _Elem, class _Traits>
    static void _Write(
        basic_ostream<_Elem, _Traits>& _Ostr, const _Circ_buf<_Ty, _Nw>& _Buf, _Cy_t _Cy) { 
        int _Kx = _Get_wc();

        for (size_t _Ix = 0; _Ix < _Nw; ++_Ix) {
            for (int _Jx = 0; _Jx < _Kx; ++_Jx) { 
                const unsigned int _Word = static_cast<unsigned int>(_Buf._At(_Ix) >> (_Jx * 32));
                _Ostr << _Word << ' ';
            }
        }

        _Ostr << _Cy;
    }

    template <class _Elem, class _Traits>
    static void _Write_full(
        basic_ostream<_Elem, _Traits>& _Ostr, const _Circ_buf<_Ty, _Nw>& _Buf, _Cy_t _Cy) { 
        for (size_t _Ix = 0; _Ix < _Nw; ++_Ix) {
            _Ostr << _Buf._At(_Ix) << ' ';
        }

        _Ostr << _Cy;
    }
};

template <class _Ty, _Ty _Mx, size_t _Sx, size_t _Rx>
class subtract_with_carry
    : public _Swc_base<_Ty, _Sx, _Rx, _Swc_traits<_Ty, _Mx, _Rx>> { 
public:
    using _Mybase = _Swc_base<_Ty, _Sx, _Rx, _Swc_traits<_Ty, _Mx, _Rx>>;

    static constexpr _Ty modulus = _Mx;

    using _Mybase::default_seed;

    subtract_with_carry() : _Mybase(default_seed) {}

    explicit subtract_with_carry(_Ty _Xx0) : _Mybase(_Xx0) {}

    template <class _Gen, _Enable_if_seed_seq_t<_Gen, subtract_with_carry> = 0>
    subtract_with_carry(_Gen& _Gx) : _Mybase(_Gx) {}
};

template <class _Ty, size_t _Wx, size_t _Sx, size_t _Rx>
class subtract_with_carry_engine : public subtract_with_carry<_Ty, (_Ty{1} << (_Wx - 1)) << 1, _Sx, _Rx> {
    
public:
    static_assert(_Is_any_of_v<_Ty, unsigned short, unsigned int, unsigned long, unsigned long long>, "invalid template argument for " "subtract_with_carry_engine" ": N4659 29.6.1.1 [rand.req.genl]/1f requires one of " "unsigned short, unsigned int, unsigned long, or unsigned long long"); static_assert(!_Is_character<_Ty>::value, "note: char, signed char, unsigned char, char8_t, int8_t, and uint8_t are not allowed");

    static_assert(0U < _Sx && _Sx < _Rx && 0 < _Wx && _Wx <= numeric_limits<_Ty>::digits,
        "invalid template argument for subtract_with_carry_engine");

    static constexpr _Ty _Mx          = (_Ty{1} << (_Wx - 1)) << 1;
    static constexpr size_t word_size = _Wx;
    static constexpr size_t short_lag = _Sx;
    static constexpr size_t long_lag  = _Rx;

    using _Mybase     = subtract_with_carry<_Ty, _Mx, _Sx, _Rx>;
    using _Traits     = typename _Mybase::_Traits;
    using result_type = _Ty;

    using _Mybase::default_seed;

    subtract_with_carry_engine() : _Mybase(default_seed) {}

    explicit subtract_with_carry_engine(_Ty _Xx0) : _Mybase(_Xx0) {}

    template <class _Seed_seq, _Enable_if_seed_seq_t<_Seed_seq, subtract_with_carry_engine> = 0>
    explicit subtract_with_carry_engine(_Seed_seq& _Seq) : _Mybase() {
        seed(_Seq);
    }

    void seed(_Ty _Value = default_seed) { 
        this->_Seed(_Value, false, true_type{});
    }

    static constexpr int _Kx = (8 * sizeof(_Ty) + 31) / 32;

    template <class _Seed_seq, _Enable_if_seed_seq_t<_Seed_seq, subtract_with_carry_engine> = 0>
    void seed(_Seed_seq& _Seq) { 
        unsigned long _Arr[_Kx * _Rx];
        _Seq.generate(&_Arr[0], &_Arr[_Kx * _Rx]);

        size_t _Idx0 = 0;
        for (size_t _Ix = 0; _Ix < _Rx; ++_Ix, _Idx0 += _Kx) { 
            this->_Ax[_Ix] = _Arr[_Idx0];
            for (int _Jx = 1; _Jx < _Kx; ++_Jx) {
                this->_Ax[_Ix] |= static_cast<_Ty>(_Arr[_Idx0 + _Jx]) << (32 * _Jx);
            }

            constexpr bool _Mod_non_zero = _Traits::_Mod != 0;
            if constexpr (_Mod_non_zero) {
                this->_Ax[_Ix] %= _Traits::_Mod;
            }
        }

        this->_Carry = _Traits::_Reduce(this->_Ax);
        this->_Idx   = _Rx;
    }

    [[nodiscard]] static constexpr _Ty(min)() {
        return 0;
    }

    [[nodiscard]] static constexpr _Ty(max)() {
        return _Mx - 1;
    }

    template <class _Elem, class _Traits>
    friend basic_ostream<_Elem, _Traits>& operator<<(
        basic_ostream<_Elem, _Traits>& _Ostr, const subtract_with_carry_engine& _Eng) {
        const auto _Save_flags = _Ostr.flags(ios_base::dec | ios_base::left);
        const auto _Save_fill  = _Ostr.fill(' ');
        _Eng._Write_full(_Ostr);
        _Ostr.flags(_Save_flags);
        _Ostr.fill(_Save_fill);
        return _Ostr;
    }

    template <class _Elem, class _Traits>
    friend basic_istream<_Elem, _Traits>& operator>>(
        basic_istream<_Elem, _Traits>& _Istr, subtract_with_carry_engine& _Eng) {
        constexpr auto _Nx = long_lag;
        result_type _Buffer[_Nx];
        typename _Mybase::_Traits::_Cy_t _Carry_buf;
        const auto _Save_flags = _Istr.flags(ios_base::dec | ios_base::skipws);
        for (size_t _Ix = 0; _Ix < _Nx; ++_Ix) {
            _Istr >> _Buffer[_Ix];
        }

        _Istr >> _Carry_buf;
        if (_Istr) {
            for (size_t _Ix = 0; _Ix < _Nx; ++_Ix) {
                _Eng._Ax[_Ix] = _Buffer[_Ix];
            }

            _Eng._Carry = _Carry_buf;
            _Eng._Idx   = _Nx;
        } else {
            _Istr.setstate(ios_base::failbit);
        }

        _Istr.flags(_Save_flags);
        return _Istr;
    }
};


#line 1107 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

template <class _Ty, int _Wx, int _Nx, int _Mx, int _Rx, _Ty _Px, int _Ux, int _Sx, _Ty _Bx, int _Tx, _Ty _Cx, int _Lx>
class mersenne_twister : public _Circ_buf<_Ty, _Nx> { 
public:
    using result_type = _Ty;

    static constexpr int word_size   = _Wx;
    static constexpr int state_size  = _Nx;
    static constexpr int shift_size  = _Mx;
    static constexpr int mask_bits   = _Rx;
    static constexpr _Ty parameter_a = _Px;
    static constexpr int output_u    = _Ux;
    static constexpr int output_s    = _Sx;
    static constexpr _Ty output_b    = _Bx;
    static constexpr int output_t    = _Tx;
    static constexpr _Ty output_c    = _Cx;
    static constexpr int output_l    = _Lx;

    static constexpr _Ty default_seed = 5489U;

    mersenne_twister() : _Dxval(_WMSK) {
        seed(default_seed, static_cast<_Ty>(1812433253));
    }

    explicit mersenne_twister(_Ty _Xx0, _Ty _Dxarg = _WMSK, _Ty _Fxarg = static_cast<_Ty>(1812433253))
        : _Dxval(_Dxarg) {
        seed(_Xx0, _Fxarg);
    }

    template <class _Gen, _Enable_if_seed_seq_t<_Gen, mersenne_twister> = 0>
    explicit mersenne_twister(_Gen& _Gx) : _Dxval(_WMSK) {
        seed(_Gx);
    }

    void seed(_Ty _Xx0 = default_seed, _Ty _Fx = static_cast<_Ty>(1812433253)) {
        
        _Ty _Prev = this->_Ax[0] = _Xx0 & _WMSK;
        for (size_t _Ix = 1; _Ix < _Nx; ++_Ix) {
            _Prev = this->_Ax[_Ix] = (_Ix + _Fx * (_Prev ^ (_Prev >> (_Wx - 2)))) & _WMSK;
        }

        this->_Idx = _Nx;
    }

    template <class _Gen, _Enable_if_seed_seq_t<_Gen, mersenne_twister> = 0>
    void seed(_Gen& _Gx, bool = false) { 
        for (size_t _Ix = 0; _Ix < _Nx; ++_Ix) {
            this->_Ax[_Ix] = _Gx() & _WMSK;
        }

        this->_Idx = _Nx;
    }

    [[nodiscard]] friend bool operator==(const mersenne_twister& _Left, const mersenne_twister& _Right) {
        return _Left._Equals(_Right);
    }


#line 1169 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

    template <class _Elem, class _S_Traits>
    friend basic_istream<_Elem, _S_Traits>& operator>>(basic_istream<_Elem, _S_Traits>& _Istr,
        mersenne_twister& _Eng) { 
        _Wrap_istream<_Elem, _S_Traits, _Ty> _Gen(_Istr);
        _Eng.seed(_Gen);
        return _Istr;
    }

    template <class _Elem, class _S_Traits>
    friend basic_ostream<_Elem, _S_Traits>& operator<<(basic_ostream<_Elem, _S_Traits>& _Ostr,
        const mersenne_twister& _Eng) { 
        _Ostr << _Eng._At(0);

        for (size_t _Ix = 1; _Ix < mersenne_twister::state_size; ++_Ix) {
            _Ostr << ' ' << _Eng._At(_Ix);
        }

        return _Ostr;
    }

    [[nodiscard]] result_type(min)() const {
        return 0;
    }

    [[nodiscard]] result_type(max)() const {
        return _WMSK;
    }

    [[nodiscard]] result_type operator()() {
        if (this->_Idx == _Nx) {
            _Refill_upper();
        } else if (2 * _Nx <= this->_Idx) {
            _Refill_lower();
        }

        _Ty _Res = this->_Ax[this->_Idx++] & _WMSK;
        _Res ^= (_Res >> _Ux) & _Dxval;
        _Res ^= (_Res << _Sx) & _Bx;
        _Res ^= (_Res << _Tx) & _Cx;
        _Res ^= (_Res & _WMSK) >> _Lx;
        return _Res;
    }

    void discard(unsigned long long _Nskip) { 
        for (; 0 < _Nskip; --_Nskip) {
            (void) (*this)();
        }
    }

protected:
     

        void _Refill_lower() { 
        constexpr size_t _Wrap_bound_one = _Nx - _One_mod_n;
        constexpr size_t _Wrap_bound_m   = _Nx - _M_mod_n;

        if constexpr (_M_mod_n == 0) {
            for (size_t _Ix = 0; _Ix < _Wrap_bound_one; ++_Ix) { 
                const _Ty _Tmp = (this->_Ax[_Ix + _Nx] & _HMSK) | (this->_Ax[_Ix + _Nx + _One_mod_n] & _LMSK);
                this->_Ax[_Ix] = (_Tmp >> 1) ^ (_Tmp & 1 ? _Px : 0) ^ this->_Ax[_Ix + _Nx + _M_mod_n];
            }

            if constexpr (_One_mod_n == 1) { 
                constexpr size_t _Ix = _Wrap_bound_one;

                const _Ty _Tmp = (this->_Ax[_Ix + _Nx] & _HMSK) | (this->_Ax[_Ix - _Nx + _One_mod_n] & _LMSK);
                this->_Ax[_Ix] = (_Tmp >> 1) ^ (_Tmp & 1 ? _Px : 0) ^ this->_Ax[_Ix + _Nx + _M_mod_n];
            }
        } else {
            for (size_t _Ix = 0; _Ix < _Wrap_bound_m; ++_Ix) { 
                const _Ty _Tmp = (this->_Ax[_Ix + _Nx] & _HMSK) | (this->_Ax[_Ix + _Nx + _One_mod_n] & _LMSK);
                this->_Ax[_Ix] = (_Tmp >> 1) ^ (_Tmp & 1 ? _Px : 0) ^ this->_Ax[_Ix + _Nx + _M_mod_n];
            }

            for (size_t _Ix = _Wrap_bound_m; _Ix < _Wrap_bound_one; ++_Ix) {
                
                const _Ty _Tmp = (this->_Ax[_Ix + _Nx] & _HMSK) | (this->_Ax[_Ix + _Nx + _One_mod_n] & _LMSK);
                this->_Ax[_Ix] = (_Tmp >> 1) ^ (_Tmp & 1 ? _Px : 0) ^ this->_Ax[_Ix - _Nx + _M_mod_n];
            }

            if constexpr (_One_mod_n == 1) { 
                constexpr size_t _Ix = _Wrap_bound_one;

                const _Ty _Tmp = (this->_Ax[_Ix + _Nx] & _HMSK) | (this->_Ax[_Ix - _Nx + _One_mod_n] & _LMSK);
                this->_Ax[_Ix] = (_Tmp >> 1) ^ (_Tmp & 1 ? _Px : 0) ^ this->_Ax[_Ix - _Nx + _M_mod_n];
            }
        }

        this->_Idx = 0;
    }

    void _Refill_upper() { 
        for (size_t _Ix = _Nx; _Ix < 2 * _Nx; ++_Ix) { 
            const _Ty _Tmp = (this->_Ax[_Ix - _Nx] & _HMSK) | (this->_Ax[_Ix - _Nx + _One_mod_n] & _LMSK);
            this->_Ax[_Ix] = (_Tmp >> 1) ^ (_Tmp & 1 ? _Px : 0) ^ this->_Ax[_Ix - _Nx + _M_mod_n];
        }
    }

    _Ty _Dxval;

    static constexpr _Ty _WMSK = ~((~_Ty{0} << (_Wx - 1)) << 1);
    static constexpr _Ty _HMSK = (_WMSK << _Rx) & _WMSK;
    static constexpr _Ty _LMSK = ~_HMSK & _WMSK;

    static constexpr int _One_mod_n = 1 % _Nx; 
    static constexpr int _M_mod_n   = _Mx % _Nx;
};

template <class _Ty, size_t _Wx, size_t _Nx, size_t _Mx, size_t _Rx, _Ty _Px, size_t _Ux, _Ty _Dx, size_t _Sx, _Ty _Bx,
    size_t _Tx, _Ty _Cx, size_t _Lx, _Ty _Fx>
class mersenne_twister_engine : public mersenne_twister<_Ty, _Wx, _Nx, _Mx, _Rx, _Px, _Ux, _Sx, _Bx, _Tx, _Cx, _Lx> {
public:
    static constexpr unsigned long long _Max = (((1ULL << (_Wx - 1)) - 1) << 1) + 1;

    static_assert(_Is_any_of_v<_Ty, unsigned short, unsigned int, unsigned long, unsigned long long>, "invalid template argument for " "mersenne_twister_engine" ": N4659 29.6.1.1 [rand.req.genl]/1f requires one of " "unsigned short, unsigned int, unsigned long, or unsigned long long"); static_assert(!_Is_character<_Ty>::value, "note: char, signed char, unsigned char, char8_t, int8_t, and uint8_t are not allowed");

    static_assert(0 < _Mx && _Mx <= _Nx && 2U < _Wx && _Rx <= _Wx && _Ux <= _Wx && _Sx <= _Wx && _Tx <= _Wx
                      && _Lx <= _Wx && _Wx <= numeric_limits<_Ty>::digits && _Px <= _Max && _Bx <= _Max && _Cx <= _Max
                      && _Dx <= _Max && _Fx <= _Max,
        "invalid template argument for mersenne_twister_engine");

    using _Mybase     = mersenne_twister<_Ty, _Wx, _Nx, _Mx, _Rx, _Px, _Ux, _Sx, _Bx, _Tx, _Cx, _Lx>;
    using result_type = _Ty;

    static constexpr size_t word_size              = _Wx;
    static constexpr size_t state_size             = _Nx;
    static constexpr size_t shift_size             = _Mx;
    static constexpr size_t mask_bits              = _Rx;
    static constexpr _Ty xor_mask                  = _Px;
    static constexpr size_t tempering_u            = _Ux;
    static constexpr _Ty tempering_d               = _Dx;
    static constexpr size_t tempering_s            = _Sx;
    static constexpr _Ty tempering_b               = _Bx;
    static constexpr size_t tempering_t            = _Tx;
    static constexpr _Ty tempering_c               = _Cx;
    static constexpr size_t tempering_l            = _Lx;
    static constexpr _Ty initialization_multiplier = _Fx;

    static constexpr result_type default_seed = 5489U;

    mersenne_twister_engine() : _Mybase(default_seed, _Dx, _Fx) {}

    explicit mersenne_twister_engine(result_type _Xx0) : _Mybase(_Xx0, _Dx, _Fx) {}

    template <class _Seed_seq, _Enable_if_seed_seq_t<_Seed_seq, mersenne_twister_engine> = 0>
    explicit mersenne_twister_engine(_Seed_seq& _Seq) : _Mybase(default_seed, _Dx, _Fx) {
        seed(_Seq);
    }

    void seed(result_type _Xx0 = default_seed) { 
        _Mybase::seed(_Xx0, _Fx);
    }

    template <class _Seed_seq, _Enable_if_seed_seq_t<_Seed_seq, mersenne_twister_engine> = 0>
    void seed(_Seed_seq& _Seq) { 
        constexpr int _Kx = (_Wx + 31) / 32;
        unsigned long _Arr[_Kx * _Nx];
        _Seq.generate(&_Arr[0], &_Arr[_Kx * _Nx]);

        int _Idx0 = 0;
        _Ty _Sum  = 0;
        for (size_t _Ix = 0; _Ix < _Nx; ++_Ix, _Idx0 += _Kx) { 
            this->_Ax[_Ix] = static_cast<_Ty>(_Arr[_Idx0]);
            for (int _Jx = 1; _Jx < _Kx; ++_Jx) {
                this->_Ax[_Ix] |= static_cast<_Ty>(_Arr[_Idx0 + _Jx]) << (32 * _Jx);
            }

            this->_Ax[_Ix] &= this->_WMSK;

            if (_Ix == 0) {
                _Sum = this->_Ax[_Ix] >> _Rx;
            } else {
                _Sum |= this->_Ax[_Ix];
            }
        }

        if (_Sum == 0) {
            this->_Ax[0] = _Ty{1} << (_Wx - 1);
        }

        this->_Idx = _Nx;
    }

    [[nodiscard]] static constexpr result_type(min)() {
        return 0;
    }

    [[nodiscard]] static constexpr result_type(max)() {
        return _Mybase::_WMSK;
    }
};

template <class _Engine, int _Px, int _Rx>
class discard_block { 
public:
    using base_type   = _Engine;
    using result_type = typename _Engine::result_type;

    static constexpr int block_size = _Px;
    static constexpr int used_block = _Rx;

    discard_block() : _Eng(), _Nx(0) {}

    explicit discard_block(const _Engine& _Ex) : _Eng(_Ex), _Nx(0) {}

    explicit discard_block(result_type _Seed) : _Eng(_Seed), _Nx(0) {}

    template <class _Seed_seq, _Enable_if_seed_seq_t<_Seed_seq, discard_block, _Engine> = 0>
    explicit discard_block(_Seed_seq& _Seq) : _Eng(_Seq), _Nx(0) {}

    void seed() { 
        _Eng.seed();
        _Nx = 0;
    }

    void seed(result_type _Xx0) { 
        _Eng.seed(_Xx0);
        _Nx = 0;
    }

    template <class _Seed_seq, _Enable_if_seed_seq_t<_Seed_seq, discard_block> = 0>
    void seed(_Seed_seq& _Seq) { 
        _Eng.seed(_Seq);
        _Nx = 0;
    }

    [[nodiscard]] const base_type& base() const noexcept {
        return _Eng;
    }

    [[nodiscard]] result_type(min)() const {
        return (_Eng.min)();
    }

    [[nodiscard]] result_type(max)() const {
        return (_Eng.max)();
    }

    [[nodiscard]] result_type operator()() {
        if (_Rx <= _Nx) { 
            while (_Nx++ < _Px) {
                (void) _Eng();
            }

            _Nx = 0;
        }
        ++_Nx;
        return _Eng();
    }

    void discard(unsigned long long _Nskip) { 
        for (; 0 < _Nskip; --_Nskip) {
            (void) (*this)();
        }
    }

    [[nodiscard]] friend bool operator==(const discard_block& _Left, const discard_block& _Right) {
        return _Left._Eng == _Right._Eng && _Left._Nx == _Right._Nx;
    }


#line 1435 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

    template <class _Elem, class _Traits>
    friend basic_istream<_Elem, _Traits>& operator>>(
        basic_istream<_Elem, _Traits>& _Istr, discard_block& _Eng) { 
        return _Istr >> _Eng._Eng >> _Eng._Nx;
    }

    template <class _Elem, class _Traits>
    friend basic_ostream<_Elem, _Traits>& operator<<(
        basic_ostream<_Elem, _Traits>& _Ostr, const discard_block& _Eng) { 
        return _Ostr << _Eng._Eng << ' ' << _Eng._Nx;
    }

private:
    base_type _Eng;
    int _Nx;
};

template <class _Engine, int _Px, int _Rx>
const int discard_block<_Engine, _Px, _Rx>::block_size;

template <class _Engine, int _Px, int _Rx>
const int discard_block<_Engine, _Px, _Rx>::used_block;

template <class _Engine, size_t _Px, size_t _Rx>
class discard_block_engine : public discard_block<_Engine, _Px, _Rx> { 
public:
    static_assert(0 < _Rx && _Rx <= _Px, "invalid template argument for discard_block_engine");

    using _Mybase     = discard_block<_Engine, _Px, _Rx>;
    using result_type = typename _Engine::result_type;

    discard_block_engine() : _Mybase() {}

    explicit discard_block_engine(const _Engine& _Ex) : _Mybase(_Ex) {}

    explicit discard_block_engine(_Engine&& _Ex) : _Mybase(::std:: move(_Ex)) {}

    explicit discard_block_engine(result_type _Xx0) : _Mybase(_Xx0) {}

    template <class _Seed_seq, _Enable_if_seed_seq_t<_Seed_seq, discard_block_engine, _Engine> = 0>
    explicit discard_block_engine(_Seed_seq& _Seq) : _Mybase(_Seq) {}

    [[nodiscard]] static constexpr typename _Engine::result_type(min)() {
        return (_Engine::min)();
    }

    [[nodiscard]] static constexpr typename _Engine::result_type(max)() {
        return (_Engine::max)();
    }
};

template <class _Engine, size_t _Wx, class _UIntType>
class independent_bits_engine { 
public:
    static_assert(_Is_any_of_v<_UIntType, unsigned short, unsigned int, unsigned long, unsigned long long>, "invalid template argument for " "independent_bits_engine" ": N4659 29.6.1.1 [rand.req.genl]/1f requires one of " "unsigned short, unsigned int, unsigned long, or unsigned long long"); static_assert(!_Is_character<_UIntType>::value, "note: char, signed char, unsigned char, char8_t, int8_t, and uint8_t are not allowed");

    static_assert(
        0 < _Wx && _Wx <= numeric_limits<_UIntType>::digits, "invalid template argument for independent_bits_engine");

    using base_type   = _Engine;
    using result_type = _UIntType;
    using _Eres       = typename _Engine::result_type;

    independent_bits_engine() {
        _Init();
    }

    explicit independent_bits_engine(const _Engine& _Ex) : _Eng(_Ex) {
        _Init();
    }

    explicit independent_bits_engine(_Engine&& _Ex) : _Eng(::std:: move(_Ex)) {
        _Init();
    }

    explicit independent_bits_engine(result_type _Xx0) : _Eng(static_cast<_Eres>(_Xx0)) {
        _Init();
    }

    template <class _Seed_seq, _Enable_if_seed_seq_t<_Seed_seq, independent_bits_engine, _Engine> = 0>
    explicit independent_bits_engine(_Seed_seq& _Seq) : _Eng(_Seq) {
        _Init();
    }

    void seed() { 
        _Eng.seed();
    }

    void seed(result_type _Xx0) { 
        _Eng.seed(static_cast<_Eres>(_Xx0));
    }

    template <class _Seed_seq, _Enable_if_seed_seq_t<_Seed_seq, independent_bits_engine> = 0>
    void seed(_Seed_seq& _Seq) { 
        _Eng.seed(_Seq);
    }

    [[nodiscard]] const _Engine& base() const noexcept {
        return _Eng;
    }

    [[nodiscard]] static constexpr result_type(min)() {
        return 0;
    }

    [[nodiscard]] static constexpr result_type(max)() {
        return ((result_type{1} << (_Wx - 1)) << 1) - 1;
    }

    [[nodiscard]] result_type operator()() {
        size_t _Idx       = 0;
        result_type _Res  = 0;
        result_type _Mask = ((result_type{1} << (_Wx0 - 1)) << 1) - 1;
        _Eres _Val;

        for (; _Idx < _Nx0; ++_Idx) { 
            for (;;) { 
                _Val = _Eng() - (_Engine::min)();
                if (_Val <= _Yx0) {
                    break;
                }
            }
            _Res = _Res << _Wx0 | (static_cast<result_type>(_Val) & _Mask);
        }

        _Mask = _Mask << 1 | 1;
        for (; _Idx < _Nx; ++_Idx) { 
            for (;;) { 
                _Val = _Eng() - (_Engine::min)();
                if (_Val <= _Yx1) {
                    break;
                }
            }
            _Res = _Res << (_Wx0 + 1) | (static_cast<result_type>(_Val) & _Mask);
        }
        return _Res;
    }

    void discard(unsigned long long _Nskip) { 
        for (; 0 < _Nskip; --_Nskip) {
            (void) (*this)();
        }
    }

    [[nodiscard]] friend bool operator==(const independent_bits_engine& _Left, const independent_bits_engine& _Right) {
        return _Left.base() == _Right.base();
    }


#line 1589 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

    template <class _Elem, class _Traits>
    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
        independent_bits_engine& _Eng) { 
        return _Istr >> _Eng._Eng;
    }

    template <class _Elem, class _Traits>
    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
        const independent_bits_engine& _Eng) { 
        return _Ostr << _Eng._Eng;
    }

private:
    void _Init() { 
        size_t _Mx = 0;
        _Eres _Rx  = (_Engine::max)() - (_Engine::min)() + 1;

        _Eres _Tmp = _Rx;
        if (_Tmp == 0) { 
            _Mx = 1;
            --_Tmp;
        }
        for (; 1 < _Tmp; _Tmp >>= 1) {
            ++_Mx; 
        }

        for (size_t _Nfix = 0;; ++_Nfix) { 
            _Nx  = (_Wx + _Mx - 1) / _Mx + _Nfix; 
            _Wx0 = _Wx / _Nx;
            _Nx0 = _Nx - _Wx % _Nx;
            _Yx0 = (_Rx >> _Wx0) << _Wx0;
            _Yx1 = (((_Rx >> _Wx0) >> 1) << _Wx0) << 1;
            if (_Nfix == 1 || _Rx - _Yx0 <= _Yx0 / _Nx) {
                break; 
            }
        }
        --_Yx0;
        --_Yx1;
    }

    _Engine _Eng; 
    size_t _Nx0; 
    size_t _Nx; 
    size_t _Wx0; 
    _Eres _Yx0; 
    _Eres _Yx1; 
};

template <class _Engine, size_t _Kx>
class shuffle_order_engine { 
public:
    static_assert(0 < _Kx, "invalid template argument for shuffle_order_engine");

    using base_type   = _Engine;
    using result_type = typename _Engine::result_type;

    static constexpr size_t table_size = _Kx;

    shuffle_order_engine() {
        _Init();
    }

    explicit shuffle_order_engine(const _Engine& _Ex) : _Eng(_Ex) {
        _Init();
    }

    explicit shuffle_order_engine(_Engine&& _Ex) : _Eng(::std:: move(_Ex)) {
        _Init();
    }

    explicit shuffle_order_engine(result_type _Xx0) : _Eng(_Xx0) {
        _Init();
    }

    template <class _Seed_seq, _Enable_if_seed_seq_t<_Seed_seq, shuffle_order_engine, _Engine> = 0>
    explicit shuffle_order_engine(_Seed_seq& _Seq) : _Eng(_Seq) {
        _Init();
    }

    void seed() { 
        _Eng.seed();
        _Init();
    }

    void seed(result_type _Xx0) { 
        _Eng.seed(_Xx0);
        _Init();
    }

    template <class _Seed_seq, _Enable_if_seed_seq_t<_Seed_seq, shuffle_order_engine> = 0>
    void seed(_Seed_seq& _Seq) { 
        _Eng.seed(_Seq);
        _Init();
    }

    [[nodiscard]] const _Engine& base() const noexcept {
        return _Eng;
    }

    [[nodiscard]] static constexpr result_type(min)() {
        return (_Engine::min)();
    }

    [[nodiscard]] static constexpr result_type(max)() {
        return (_Engine::max)();
    }

    [[nodiscard]] result_type operator()() {
        size_t _Idx = static_cast<size_t>(static_cast<double>(_Yx - (_Eng.min)()) * _Scale);

        _Yx        = _Arr[_Idx];
        _Arr[_Idx] = _Eng();
        return _Yx;
    }

    void discard(unsigned long long _Nskip) { 
        for (; 0 < _Nskip; --_Nskip) {
            (void) (*this)();
        }
    }

    [[nodiscard]] friend bool operator==(const shuffle_order_engine& _Left, const shuffle_order_engine& _Right) {
        return _Left.base() == _Right.base();
    }


#line 1720 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

    template <class _Elem, class _Traits>
    friend basic_istream<_Elem, _Traits>& operator>>(
        basic_istream<_Elem, _Traits>& _Istr, shuffle_order_engine& _Eng) { 
        _Istr >> _Eng._Eng;
        for (size_t _Idx = 0; _Idx < shuffle_order_engine::table_size; ++_Idx) {
            _Istr >> _Eng._Arr[_Idx];
        }

        return _Istr >> _Eng._Yx;
    }

    template <class _Elem, class _Traits>
    friend basic_ostream<_Elem, _Traits>& operator<<(
        basic_ostream<_Elem, _Traits>& _Ostr, const shuffle_order_engine& _Eng) { 
        _Ostr << _Eng._Eng;
        for (size_t _Idx = 0; _Idx < shuffle_order_engine::table_size; ++_Idx) {
            _Ostr << ' ' << _Eng._Arr[_Idx];
        }

        return _Ostr << ' ' << _Eng._Yx;
    }

private:
    void _Init() { 
        for (size_t _Idx = 0; _Idx < _Kx; ++_Idx) {
            _Arr[_Idx] = _Eng();
        }

        _Yx = _Eng();
        _Scale =
            static_cast<double>(_Kx) / (static_cast<double>((_Eng.max)()) - static_cast<double>((_Eng.min)()) + 1.0);
    }

    _Engine _Eng; 
    result_type _Arr[_Kx];
    result_type _Yx;
    double _Scale;
};

template <class _Ty = int>
class uniform_int { 
public:
    using result_type = _Ty;

    struct param_type { 
        using distribution_type = uniform_int;

        param_type() {
            _Init(0, 9);
        }

        explicit param_type(result_type _Min0, result_type _Max0 = 9) {
            _Init(_Min0, _Max0);
        }

        [[nodiscard]] friend bool operator==(const param_type& _Left, const param_type& _Right) {
            return _Left._Min == _Right._Min && _Left._Max == _Right._Max;
        }


#line 1785 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

        [[nodiscard]] result_type a() const {
            return _Min;
        }

        [[nodiscard]] result_type b() const {
            return _Max;
        }

        void _Init(_Ty _Min0, _Ty _Max0) { 
            ;
            _Min = _Min0;
            _Max = _Max0;
        }

        result_type _Min;
        result_type _Max;
    };

    uniform_int() : _Par(0, 9) {}

    explicit uniform_int(_Ty _Min0, _Ty _Max0 = 9) : _Par(_Min0, _Max0) {}

    explicit uniform_int(const param_type& _Par0) : _Par(_Par0) {}

    [[nodiscard]] result_type a() const {
        return _Par.a();
    }

    [[nodiscard]] result_type b() const {
        return _Par.b();
    }

    [[nodiscard]] param_type param() const {
        return _Par;
    }

    void param(const param_type& _Par0) { 
        _Par = _Par0;
    }

    [[nodiscard]] result_type(min)() const {
        return _Par._Min;
    }

    [[nodiscard]] result_type(max)() const {
        return _Par._Max;
    }

    void reset() {} 

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng) const {
        return _Eval(_Eng, _Par._Min, _Par._Max);
    }

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng, const param_type& _Par0) const {
        return _Eval(_Eng, _Par0._Min, _Par0._Max);
    }

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng, result_type _Nx) const {
        return _Eval(_Eng, 0, _Nx - 1);
    }

    template <class _Elem, class _Traits>
    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
        uniform_int& _Dist) { 
        uniform_int::result_type _Min0;
        uniform_int::result_type _Max0;
        _Istr >> _Min0 >> _Max0;
        _Dist._Par._Init(_Min0, _Max0);
        return _Istr;
    }

    template <class _Elem, class _Traits>
    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
        const uniform_int& _Dist) { 
        return _Ostr << _Dist._Par._Min << ' ' << _Dist._Par._Max;
    }

private:
    using _Uty = make_unsigned_t<_Ty>;

    template <class _Engine>
    result_type _Eval(_Engine& _Eng, _Ty _Min, _Ty _Max) const { 
        _Rng_from_urng<_Uty, _Engine> _Generator(_Eng);

        const _Uty _Umin = _Adjust(static_cast<_Uty>(_Min));
        const _Uty _Umax = _Adjust(static_cast<_Uty>(_Max));

        _Uty _Uret;

        if (_Umax - _Umin == static_cast<_Uty>(-1)) {
            _Uret = static_cast<_Uty>(_Generator._Get_all_bits());
        } else {
            _Uret = static_cast<_Uty>(_Generator(static_cast<_Uty>(_Umax - _Umin + 1)));
        }

        return static_cast<_Ty>(_Adjust(static_cast<_Uty>(_Uret + _Umin)));
    }

    static _Uty _Adjust(_Uty _Uval) { 
        if constexpr (is_signed_v<_Ty>) {
            const _Uty _Adjuster = (static_cast<_Uty>(-1) >> 1) + 1; 

            if (_Uval < _Adjuster) {
                return static_cast<_Uty>(_Uval + _Adjuster);
            } else {
                return static_cast<_Uty>(_Uval - _Adjuster);
            }
        } else { 
            return _Uval;
        }
    }

    param_type _Par;
};

template <class _Ty = int>
class uniform_int_distribution : public uniform_int<_Ty> { 
public:
    static_assert(_Is_any_of_v<_Ty, short, int, long, long long, unsigned short, unsigned int, unsigned long, unsigned long long>, "invalid template argument for " "uniform_int_distribution" ": N4659 29.6.1.1 [rand.req.genl]/1e requires one of " "short, int, long, long long, unsigned short, unsigned int, unsigned long, or unsigned long long"); static_assert(!_Is_character<_Ty>::value, "note: char, signed char, unsigned char, char8_t, int8_t, and uint8_t are not allowed");

    using _Mybase     = uniform_int<_Ty>;
    using _Mypbase    = typename _Mybase::param_type;
    using result_type = typename _Mybase::result_type;

    struct param_type : _Mypbase { 
        using distribution_type = uniform_int_distribution;

        param_type() : _Mypbase(0, (numeric_limits<_Ty>::max)()) {}

        explicit param_type(result_type _Min0, result_type _Max0 = (numeric_limits<_Ty>::max)())
            : _Mypbase(_Min0, _Max0) {}

        param_type(const _Mypbase& _Right) : _Mypbase(_Right) {}
    };

    uniform_int_distribution() : _Mybase(0, (numeric_limits<_Ty>::max)()) {}

    explicit uniform_int_distribution(_Ty _Min0, _Ty _Max0 = (numeric_limits<_Ty>::max)()) : _Mybase(_Min0, _Max0) {}

    explicit uniform_int_distribution(const param_type& _Par0) : _Mybase(_Par0) {}

    [[nodiscard]] friend bool operator==(const uniform_int_distribution& _Left, const uniform_int_distribution& _Right) {
        return _Left.param() == _Right.param();
    }


#line 1940 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"
};

class bernoulli_distribution { 
public:
    using result_type = bool;

    struct param_type { 
        using distribution_type = bernoulli_distribution;

        param_type() {
            _Init(0.5);
        }

        explicit param_type(double _Px0) {
            _Init(_Px0);
        }

        [[nodiscard]] friend bool operator==(const param_type& _Left, const param_type& _Right) {
            return _Left._Px == _Right._Px;
        }


#line 1966 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

        [[nodiscard]] double p() const {
            return _Px;
        }

        void _Init(double _Px0) { 
            ;

            _Px = _Px0;
        }

        double _Px;
    };

    bernoulli_distribution() : _Par(0.5) {}

    explicit bernoulli_distribution(double _Px0) : _Par(_Px0) {}

    explicit bernoulli_distribution(const param_type& _Par0) : _Par(_Par0) {}

    [[nodiscard]] double p() const {
        return _Par.p();
    }

    [[nodiscard]] param_type param() const {
        return _Par;
    }

    void param(const param_type& _Par0) { 
        _Par = _Par0;
    }

    [[nodiscard]] result_type(min)() const { 
        return false;
    }

    [[nodiscard]] result_type(max)() const { 
        return true;
    }

    void reset() {} 

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng) const {
        return _Eval(_Eng, _Par);
    }

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng, const param_type& _Par0) const {
        return _Eval(_Eng, _Par0);
    }

    [[nodiscard]] friend bool operator==(const bernoulli_distribution& _Left, const bernoulli_distribution& _Right) {
        return _Left.param() == _Right.param();
    }


#line 2027 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

    template <class _Elem, class _Traits>
    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
        bernoulli_distribution& _Dist) { 
        double _Px0;
        _In(_Istr, _Px0);
        _Dist._Par._Init(_Px0);
        return _Istr;
    }

    template <class _Elem, class _Traits>
    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
        const bernoulli_distribution& _Dist) { 
        _Out(_Ostr, _Dist._Par._Px);
        return _Ostr;
    }

private:
    template <class _Engine>
    result_type _Eval(_Engine& _Eng, const param_type& _Par0) const {
        return (_Nrand_impl<double>(_Eng)) < _Par0._Px;
    }

    param_type _Par;
};


template <class _Flt, class _Ty>
[[nodiscard]] _Flt _Float_upper_bound(_Ty _Val) {
    static_assert(is_unsigned_v<_Ty> && is_integral_v<_Ty> && is_floating_point_v<_Flt>,
        "invalid template argument for _Float_upper_bound");
    constexpr auto _Ty_digits  = numeric_limits<_Ty>::digits;
    constexpr auto _Flt_digits = numeric_limits<_Flt>::digits;
    using _Ty_32or64           = conditional_t<_Ty_digits <= 32, uint32_t, uint64_t>;

    if constexpr (_Ty_digits <= _Flt_digits) {
        return static_cast<_Flt>(_Val) + _Flt{1};
    } else {
#pragma warning(push)
#pragma warning(disable : 4146 4293) 
        constexpr auto _Mask = static_cast<_Ty>(-1) << (_Ty_digits - _Flt_digits);


        const auto _Log_plus1 = _Bit_scan_reverse(static_cast<_Ty_32or64>(_Val | _Ty{1}));
#line 2077 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"
        const auto _Shifted_mask = _Mask >> (_Ty_digits - _Log_plus1);
        const auto _Ceil_ulp     = _Shifted_mask & -_Shifted_mask;
        _Val &= _Shifted_mask;
        if (_Val == _Mask) {
            
            constexpr auto _Big_ulp = static_cast<_Flt>(_Mask & -_Mask);
            return static_cast<_Flt>(_Val) + _Big_ulp;
        } else {
            return static_cast<_Flt>(_Val + _Ceil_ulp);
        }
#pragma warning(pop)
    }
}

template <class _Ty = int>
class geometric_distribution { 
public:
    using _Ty1 = double;

    using result_type = _Ty;

    static_assert(_Is_any_of_v<_Ty, short, int, long, long long, unsigned short, unsigned int, unsigned long, unsigned long long>, "invalid template argument for " "geometric_distribution" ": N4659 29.6.1.1 [rand.req.genl]/1e requires one of " "short, int, long, long long, unsigned short, unsigned int, unsigned long, or unsigned long long"); static_assert(!_Is_character<_Ty>::value, "note: char, signed char, unsigned char, char8_t, int8_t, and uint8_t are not allowed");

    struct param_type { 
        using distribution_type = geometric_distribution;

        param_type() {
            _Init(_Ty1(0.5));
        }

        explicit param_type(_Ty1 _Px0) {
            _Init(_Px0);
        }

        [[nodiscard]] friend bool operator==(const param_type& _Left, const param_type& _Right) {
            return _Left._Px == _Right._Px;
        }


#line 2120 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

        [[nodiscard]] _Ty1 p() const {
            return _Px;
        }

        void _Init(_Ty1 _Px0) { 
            ;
            _Px      = _Px0;
            _Log_1_p = :: log(1 - _Px);
        }

        _Ty1 _Px;
        _Ty1 _Log_1_p;
    };

    geometric_distribution() : _Par(_Ty1(0.5)) {}

    explicit geometric_distribution(_Ty1 _Px0) : _Par(_Px0) {}

    explicit geometric_distribution(const param_type& _Par0) : _Par(_Par0) {}

    [[nodiscard]] _Ty1 p() const {
        return _Par.p();
    }

    [[nodiscard]] param_type param() const {
        return _Par;
    }

    void param(const param_type& _Par0) { 
        _Par = _Par0;
    }

    [[nodiscard]] result_type(min)() const { 
        return 0;
    }

    [[nodiscard]] result_type(max)() const { 
        return (numeric_limits<result_type>::max)();
    }

    void reset() {} 

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng) const {
        return _Eval(_Eng, _Par);
    }

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng, const param_type& _Par0) const {
        return _Eval(_Eng, _Par0);
    }

    [[nodiscard]] friend bool operator==(const geometric_distribution& _Left, const geometric_distribution& _Right) {
        return _Left.param() == _Right.param();
    }


#line 2182 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

    template <class _Elem, class _Traits>
    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
        geometric_distribution& _Dist) { 
        geometric_distribution::_Ty1 _Px0;
        _In(_Istr, _Px0);
        _Dist._Par._Init(_Px0);
        return _Istr;
    }

    template <class _Elem, class _Traits>
    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
        const geometric_distribution& _Dist) { 
        _Out(_Ostr, _Dist._Par._Px);
        return _Ostr;
    }

private:
    template <class _Engine>
    result_type _Eval(_Engine& _Eng, const param_type& _Par0) const {
        using _Uty = make_unsigned_t<_Ty>;
        constexpr auto _Ty_max{(numeric_limits<_Ty>::max)()};
        const auto _Ty1_max{_Float_upper_bound<_Ty1>(static_cast<_Uty>(_Ty_max))};

        _Ty1 _Val;
        do {
            _Val = :: log((_Nrand_impl<_Ty1>(_Eng))) / _Par0._Log_1_p;
        } while (_Val >= _Ty1_max);
        return static_cast<_Ty>(_Val);
    }

    param_type _Par;
};

template <class _Ty = int>
class _Small_poisson_distribution { 
public:
    using _Ty1 = double;

    template <class _Engine>
    [[nodiscard]] _Ty operator()(_Engine& _Eng) const {
        _Ty _Res;
        _Ty1 _Val;
        for (_Res = 0, _Val = 1.0;; ++_Res) { 
            _Val *= (_Nrand_impl<_Ty1>(_Eng));
            if (_Val <= _Gx0) {
                break;
            }
        }
        return _Res;
    }

    void _Init(const _Ty1& _Mean0) { 
        _Gx0 = :: exp(-_Mean0);
    }

private:
    _Ty1 _Gx0;
};

template <class _Ty = int>
class poisson_distribution { 
public:
    using _Ty1 = double;

    using result_type = _Ty;

    static_assert(_Is_any_of_v<_Ty, short, int, long, long long, unsigned short, unsigned int, unsigned long, unsigned long long>, "invalid template argument for " "poisson_distribution" ": N4659 29.6.1.1 [rand.req.genl]/1e requires one of " "short, int, long, long long, unsigned short, unsigned int, unsigned long, or unsigned long long"); static_assert(!_Is_character<_Ty>::value, "note: char, signed char, unsigned char, char8_t, int8_t, and uint8_t are not allowed");

    struct param_type { 
        using distribution_type = poisson_distribution;

        param_type() {
            _Init(_Ty1(1));
        }

        explicit param_type(_Ty1 _Mean0) {
            _Init(_Mean0);
        }

        [[nodiscard]] friend bool operator==(const param_type& _Left, const param_type& _Right) {
            return _Left._Mean == _Right._Mean;
        }


#line 2271 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

        [[nodiscard]] _Ty1 mean() const {
            return _Mean;
        }

        void _Init(_Ty1 _Mean0) { 
            ;
            _Mean = _Mean0;
            _Sqrt = :: sqrt(2.0 * _Mean0);
            _Logm = :: log(_Mean0);
            _Gx1  = _Mean0 * _Logm - _XLgamma(_Mean0 + 1.0);
            _Small._Init(_Mean0);
        }

        _Ty1 _Mean;
        _Ty1 _Sqrt;
        _Ty1 _Logm;
        _Ty1 _Gx1;

        _Small_poisson_distribution<_Ty> _Small;
    };

    poisson_distribution() : _Par(_Ty1(1)) {}

    explicit poisson_distribution(_Ty1 _Mean0) : _Par(_Mean0) {}

    explicit poisson_distribution(const param_type& _Par0) : _Par(_Par0) {}

    [[nodiscard]] _Ty1 mean() const {
        return _Par.mean();
    }

    [[nodiscard]] param_type param() const {
        return _Par;
    }

    void param(const param_type& _Par0) { 
        _Par = _Par0;
    }

    [[nodiscard]] result_type(min)() const { 
        return 0;
    }

    [[nodiscard]] result_type(max)() const { 
        return (numeric_limits<result_type>::max)();
    }

    void reset() {} 

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng) const {
        return _Eval(_Eng, _Par);
    }

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng, const param_type& _Par0) const {
        return _Eval(_Eng, _Par0);
    }

    [[nodiscard]] friend bool operator==(const poisson_distribution& _Left, const poisson_distribution& _Right) {
        return _Left.param() == _Right.param();
    }


#line 2340 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

    template <class _Elem, class _Traits>
    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
        poisson_distribution& _Dist) { 
        poisson_distribution::_Ty1 _Mean0;
        _In(_Istr, _Mean0);
        _Dist._Par._Init(_Mean0);
        return _Istr;
    }

    template <class _Elem, class _Traits>
    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
        const poisson_distribution& _Dist) { 
        _Out(_Ostr, _Dist._Par._Mean);
        return _Ostr;
    }

private:
    template <class _Engine>
    result_type _Eval(_Engine& _Eng, const param_type& _Par0) const {
        if (_Par0._Mean < 12.0) {
            return _Par0._Small(_Eng);
        }

        for (;;) { 
            using _Uty = make_unsigned_t<_Ty>;
            constexpr auto _Ty_max{(numeric_limits<_Ty>::max)()};
            const auto _Ty1_max{_Float_upper_bound<_Ty1>(static_cast<_Uty>(_Ty_max))};

            _Ty _Res;
            _Ty1 _Yx;
            for (;;) { 
                _Yx = static_cast<_Ty1>(:: tan(_Pi * (_Nrand_impl<_Ty1>(_Eng))));
                const _Ty1 _Mx{_Par0._Sqrt * _Yx + _Par0._Mean};
                if (0.0 <= _Mx && _Mx < _Ty1_max) {
                    _Res = static_cast<_Ty>(_Mx);
                    break;
                }
            }

            if ((_Nrand_impl<_Ty1>(_Eng))
                <= 0.9 * (1.0 + _Yx * _Yx) * :: exp(_Res * _Par0._Logm - _XLgamma(_Res + 1.0) - _Par0._Gx1)) {
                return _Res;
            }
        }
    }

    param_type _Par;
};

template <class _Ty = int>
class binomial_distribution { 
public:
    using _Ty1 = double;

    using result_type = _Ty;

    static_assert(_Is_any_of_v<_Ty, short, int, long, long long, unsigned short, unsigned int, unsigned long, unsigned long long>, "invalid template argument for " "binomial_distribution" ": N4659 29.6.1.1 [rand.req.genl]/1e requires one of " "short, int, long, long long, unsigned short, unsigned int, unsigned long, or unsigned long long"); static_assert(!_Is_character<_Ty>::value, "note: char, signed char, unsigned char, char8_t, int8_t, and uint8_t are not allowed");

    struct param_type { 
        using distribution_type = binomial_distribution;

        param_type() {
            _Init(1, _Ty1(0.5));
        }

        explicit param_type(_Ty _Tx0, _Ty1 _Px0 = _Ty1(0.5)) {
            _Init(_Tx0, _Px0);
        }

        [[nodiscard]] friend bool operator==(const param_type& _Left, const param_type& _Right) {
            return _Left._Tx == _Right._Tx && _Left._Px == _Right._Px;
        }


#line 2419 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

        [[nodiscard]] _Ty t() const {
            return _Tx;
        }

        [[nodiscard]] _Ty1 p() const {
            return _Px;
        }

        void _Init(_Ty _Tx0, _Ty1 _Px0) { 
            ;
            ;
            _Tx    = _Tx0;
            _Px    = _Px0;
            _Pp    = _Px < 0.5 ? _Px : (1.0 - _Px);
            _Mean  = _Tx * _Pp;
            _Gx1   = _XLgamma(_Tx + 1.0);
            _Sqrt  = :: sqrt(2 * _Mean * (1 - _Pp));
            _Logp  = :: log(_Pp);
            _Logp1 = :: log(1.0 - _Pp);
            _Small._Init(_Mean);
        }

        _Ty _Tx;
        _Ty1 _Px;
        _Ty1 _Pp;
        _Ty1 _Mean;
        _Ty1 _Gx1;
        _Ty1 _Sqrt;
        _Ty1 _Logp;
        _Ty1 _Logp1;

        _Small_poisson_distribution<_Ty> _Small; 
    };

    binomial_distribution() : _Par(1, _Ty1(0.5)) {}

    explicit binomial_distribution(_Ty _Tx0, _Ty1 _Px0 = _Ty1(0.5)) : _Par(_Tx0, _Px0) {}

    explicit binomial_distribution(const param_type& _Par0) : _Par(_Par0) {}

    [[nodiscard]] _Ty t() const {
        return _Par.t();
    }

    [[nodiscard]] _Ty1 p() const {
        return _Par.p();
    }

    [[nodiscard]] param_type param() const {
        return _Par;
    }

    void param(const param_type& _Par0) { 
        _Par = _Par0;
    }

    [[nodiscard]] result_type(min)() const { 
        return 0;
    }

    [[nodiscard]] result_type(max)() const { 
        return _Par.t();
    }

    void reset() {} 

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng) const {
        return _Eval(_Eng, _Par);
    }

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng, const param_type& _Par0) const {
        return _Eval(_Eng, _Par0);
    }

    [[nodiscard]] friend bool operator==(const binomial_distribution& _Left, const binomial_distribution& _Right) {
        return _Left.param() == _Right.param();
    }


#line 2505 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

    template <class _Elem, class _Traits>
    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
        binomial_distribution& _Dist) { 
        binomial_distribution::result_type _Tx0;
        binomial_distribution::_Ty1 _Px0;
        _In(_Istr, _Px0);
        _In(_Istr, _Tx0);
        _Dist._Par._Init(_Tx0, _Px0);
        return _Istr;
    }

    template <class _Elem, class _Traits>
    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
        const binomial_distribution& _Dist) { 
        _Out(_Ostr, _Dist._Par._Px);
        _Out(_Ostr, _Dist._Par._Tx);
        return _Ostr;
    }

private:
    template <class _Engine>
    result_type _Eval(
        _Engine& _Eng, const param_type& _Par0) const { 
        _Ty _Res;
        if (_Par0._Tx < 25) { 
            _Res = 0;
            for (_Ty _Ix = 0; _Ix < _Par0._Tx; ++_Ix) {
                if ((_Nrand_impl<_Ty1>(_Eng)) < _Par0._Px) {
                    ++_Res;
                }
            }

            return _Res;
        } else if (_Par0._Mean < 1.0) {
            
            const _Ty1 _Rand = (_Nrand_impl<_Ty1>(_Eng));

            
            const _Ty1 _Ub =
                (::std:: min)(_Par0._Mean, _Ty1{3.678794411714423216e-1} * _Par0._Pp + _Ty1{6.32120558828557678e-1});
            if (_Rand > _Ub) {
                _Res = _Ty{0};
            } else {
                _Ty _Denom = _Par0._Tx;
                _Ty1 _Sum  = :: log(_Ty1{1.0} - _Rand) / _Denom;
                while (_Sum >= _Par0._Logp1 && --_Denom != 0) {
                    _Sum += :: log(_Ty1{1.0} - (_Nrand_impl<_Ty1>(_Eng))) / _Denom;
                }
                _Res = static_cast<_Ty>(_Par0._Tx - _Denom);
            }
        } else { 
            using _Uty = make_unsigned_t<_Ty>;
            const auto _Ty1_Tx{_Float_upper_bound<_Ty1>(static_cast<_Uty>(_Par0._Tx))};

            for (;;) { 
                _Ty1 _Yx;
                for (;;) { 
                    _Yx = static_cast<_Ty1>(:: tan(_Pi * (_Nrand_impl<_Ty1>(_Eng))));
                    const _Ty1 _Mx{_Par0._Sqrt * _Yx + _Par0._Mean};
                    if (0.0 <= _Mx && _Mx < _Ty1_Tx) {
                        _Res = static_cast<_Ty>(_Mx);
                        break;
                    }
                }
                if ((_Nrand_impl<_Ty1>(_Eng))
                    <= 1.2 * _Par0._Sqrt * (1.0 + _Yx * _Yx)
                           * :: exp(_Par0._Gx1 - _XLgamma(_Res + 1.0) - _XLgamma(_Par0._Tx - _Res + 1.0)
                                       + _Res * _Par0._Logp + (_Par0._Tx - _Res) * _Par0._Logp1)) {
                    break;
                }
            }
        }
        return _Par0._Px == _Par0._Pp ? _Res : static_cast<_Ty>(_Par0._Tx - _Res);
    }

    param_type _Par;
};

template <class _Ty = double>
class uniform_real { 
public:
    using result_type = _Ty;

    struct param_type { 
        using distribution_type = uniform_real;

        param_type() {
            _Init(_Ty{0}, _Ty{1});
        }

        explicit param_type(_Ty _Min0, _Ty _Max0 = _Ty{1}) {
            _Init(_Min0, _Max0);
        }

        [[nodiscard]] friend bool operator==(const param_type& _Left, const param_type& _Right) {
            return _Left._Min == _Right._Min && _Left._Max == _Right._Max;
        }


#line 2613 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

        [[nodiscard]] result_type a() const {
            return _Min;
        }

        [[nodiscard]] result_type b() const {
            return _Max;
        }

        void _Init(_Ty _Min0, _Ty _Max0) { 
            ;
#line 2625 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"
            _Min = _Min0;
            _Max = _Max0;
        }

        result_type _Min;
        result_type _Max;
    };

    uniform_real() : _Par(_Ty{0}, _Ty{1}) {}

    explicit uniform_real(_Ty _Min0, _Ty _Max0 = _Ty{1}) : _Par(_Min0, _Max0) {}

    explicit uniform_real(const param_type& _Par0) : _Par(_Par0) {}

    [[nodiscard]] result_type a() const {
        return _Par.a();
    }

    [[nodiscard]] result_type b() const {
        return _Par.b();
    }

    [[nodiscard]] param_type param() const {
        return _Par;
    }

    void param(const param_type& _Par0) { 
        _Par = _Par0;
    }

    [[nodiscard]] result_type(min)() const {
        return _Par._Min;
    }

    [[nodiscard]] result_type(max)() const {
        return _Par._Max;
    }

    void reset() {} 

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng) const {
        return _Eval(_Eng, _Par);
    }

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng, const param_type& _Par0) const {
        return _Eval(_Eng, _Par0);
    }

    template <class _Elem, class _Traits>
    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
        uniform_real& _Dist) { 
        return _Dist._Read(_Istr);
    }

    template <class _Elem, class _Traits>
    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
        const uniform_real& _Dist) { 
        return _Dist._Write(_Ostr);
    }

    template <class _Elem, class _Traits>
    basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { 
        _Ty _Min0;
        _Ty _Max0;
        _In(_Istr, _Min0);
        _In(_Istr, _Max0);
        _Par._Init(_Min0, _Max0);
        return _Istr;
    }

    template <class _Elem, class _Traits>
    basic_ostream<_Elem, _Traits>& _Write(basic_ostream<_Elem, _Traits>& _Ostr) const { 
        _Out(_Ostr, _Par._Min);
        _Out(_Ostr, _Par._Max);
        return _Ostr;
    }

private:
    template <class _Engine>
    result_type _Eval(_Engine& _Eng, const param_type& _Par0) const {
        return (_Nrand_impl<_Ty>(_Eng)) * (_Par0._Max - _Par0._Min) + _Par0._Min;
    }

    param_type _Par;
};

template <class _Ty = double>
class uniform_real_distribution : public uniform_real<_Ty> { 
public:
    static_assert(_Is_any_of_v<_Ty, float, double, long double>, "invalid template argument for " "uniform_real_distribution" ": N4659 29.6.1.1 [rand.req.genl]/1d requires one of " "float, double, or long double");

    using _Mybase     = uniform_real<_Ty>;
    using _Mypbase    = typename _Mybase::param_type;
    using result_type = typename _Mybase::result_type;

    struct param_type : _Mypbase { 
        using distribution_type = uniform_real_distribution;

        param_type() : _Mypbase(_Ty{0}, _Ty{1}) {}

        explicit param_type(_Ty _Min0, _Ty _Max0 = _Ty{1}) : _Mypbase(_Min0, _Max0) {}

        param_type(const _Mypbase& _Right) : _Mypbase(_Right) {}
    };

    uniform_real_distribution() : _Mybase(_Ty{0}, _Ty{1}) {}

    explicit uniform_real_distribution(_Ty _Min0, _Ty _Max0 = _Ty{1}) : _Mybase(_Min0, _Max0) {}

    explicit uniform_real_distribution(const param_type& _Par0) : _Mybase(_Par0) {}

    [[nodiscard]] friend bool operator==(const uniform_real_distribution& _Left, const uniform_real_distribution& _Right) {
        return _Left.param() == _Right.param();
    }


#line 2747 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"
};

template <class _Ty = double>
class exponential_distribution { 
public:
    static_assert(_Is_any_of_v<_Ty, float, double, long double>, "invalid template argument for " "exponential_distribution" ": N4659 29.6.1.1 [rand.req.genl]/1d requires one of " "float, double, or long double");

    using result_type = _Ty;

    struct param_type { 
        using distribution_type = exponential_distribution;

        param_type() {
            _Init(_Ty{1});
        }

        explicit param_type(_Ty _Lambda0) {
            _Init(_Lambda0);
        }

        [[nodiscard]] friend bool operator==(const param_type& _Left, const param_type& _Right) {
            return _Left._Lambda == _Right._Lambda;
        }


#line 2776 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

        [[nodiscard]] _Ty lambda() const {
            return _Lambda;
        }

        void _Init(_Ty _Lambda0) { 
            ;
            _Lambda = _Lambda0;
        }

        _Ty _Lambda;
    };

    exponential_distribution() : _Par(_Ty{1}) {}

    explicit exponential_distribution(_Ty _Lambda0) : _Par(_Lambda0) {}

    explicit exponential_distribution(const param_type& _Par0) : _Par(_Par0) {}

    [[nodiscard]] _Ty lambda() const {
        return _Par.lambda();
    }

    [[nodiscard]] param_type param() const {
        return _Par;
    }

    void param(const param_type& _Par0) { 
        _Par = _Par0;
    }

    [[nodiscard]] result_type(min)() const { 
        return 0;
    }

    [[nodiscard]] result_type(max)() const { 
        return numeric_limits<result_type>::infinity();
    }

    void reset() {} 

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng) const {
        return _Eval(_Eng, _Par);
    }

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng, const param_type& _Par0) const {
        return _Eval(_Eng, _Par0);
    }

    [[nodiscard]] friend bool operator==(const exponential_distribution& _Left, const exponential_distribution& _Right) {
        return _Left.param() == _Right.param();
    }


#line 2836 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

    template <class _Elem, class _Traits>
    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
        exponential_distribution& _Dist) { 
        exponential_distribution::result_type _Lambda0;
        _In(_Istr, _Lambda0);
        _Dist._Par._Init(_Lambda0);
        return _Istr;
    }

    template <class _Elem, class _Traits>
    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
        const exponential_distribution& _Dist) { 
        _Out(_Ostr, _Dist._Par._Lambda);
        return _Ostr;
    }

private:
    template <class _Engine>
    result_type _Eval(_Engine& _Eng, const param_type& _Par0) const {
        return -:: log(_Ty{1} - (_Nrand_impl<_Ty>(_Eng))) / _Par0._Lambda;
    }

    param_type _Par;
};

template <class _Ty = double>
class normal_distribution { 
public:
    static_assert(_Is_any_of_v<_Ty, float, double, long double>, "invalid template argument for " "normal_distribution" ": N4659 29.6.1.1 [rand.req.genl]/1d requires one of " "float, double, or long double");

    using result_type = _Ty;

    struct param_type { 
        using distribution_type = normal_distribution;

        param_type() {
            _Init(0.0, 1.0);
        }

        explicit param_type(_Ty _Mean0, _Ty _Sigma0 = 1.0) {
            _Init(_Mean0, _Sigma0);
        }

        [[nodiscard]] friend bool operator==(const param_type& _Left, const param_type& _Right) {
            return _Left._Mean == _Right._Mean && _Left._Sigma == _Right._Sigma;
        }


#line 2889 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

        [[nodiscard]] _Ty mean() const {
            return _Mean;
        }

        [[nodiscard]] _Ty sigma() const {
            return _Sigma;
        }

        [[nodiscard]] _Ty stddev() const {
            return _Sigma;
        }

        void _Init(_Ty _Mean0, _Ty _Sigma0) { 
            ;
            _Mean  = _Mean0;
            _Sigma = _Sigma0;
        }

        _Ty _Mean;
        _Ty _Sigma;
    };

    normal_distribution() : _Par(0.0, 1.0), _Valid(false), _Xx2(0) {}

    explicit normal_distribution(_Ty _Mean0, _Ty _Sigma0 = 1.0) : _Par(_Mean0, _Sigma0), _Valid(false), _Xx2(0) {}

    explicit normal_distribution(const param_type& _Par0) : _Par(_Par0), _Valid(false), _Xx2(0) {}

    [[nodiscard]] _Ty mean() const {
        return _Par.mean();
    }

    [[nodiscard]] _Ty sigma() const {
        return _Par.sigma();
    }

    [[nodiscard]] _Ty stddev() const {
        return _Par.sigma();
    }

    [[nodiscard]] param_type param() const {
        return _Par;
    }

    void param(const param_type& _Par0) { 
        _Par = _Par0;
        reset();
    }

    [[nodiscard]] result_type(min)() const { 
        return -numeric_limits<result_type>::infinity();
    }

    [[nodiscard]] result_type(max)() const { 
        return numeric_limits<result_type>::infinity();
    }

    void reset() { 
        _Valid = false;
    }

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng) {
        return _Eval(_Eng, _Par);
    }

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng, const param_type& _Par0) {
        reset();
        return _Eval(_Eng, _Par0, false);
    }

    [[nodiscard]] friend bool operator==(const normal_distribution& _Left, const normal_distribution& _Right) {
        return _Left.param() == _Right.param();
    }


#line 2971 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

    template <class _Elem, class _Traits>
    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
        normal_distribution& _Dist) { 
        normal_distribution::result_type _Mean0;
        normal_distribution::result_type _Sigma0;
        _In(_Istr, _Mean0);
        _In(_Istr, _Sigma0);
        _Dist._Par._Init(_Mean0, _Sigma0);

        _Istr >> _Dist._Valid;
        _In(_Istr, _Dist._Xx2);
        return _Istr;
    }

    template <class _Elem, class _Traits>
    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
        const normal_distribution& _Dist) { 
        _Out(_Ostr, _Dist._Par._Mean);
        _Out(_Ostr, _Dist._Par._Sigma);

        _Ostr << ' ' << _Dist._Valid;
        _Out(_Ostr, _Dist._Xx2);
        return _Ostr;
    }

private:
    template <class _Engine>
    result_type _Eval(_Engine& _Eng, const param_type& _Par0,
        bool _Keep = true) { 
                             
        _Ty _Res;
        if (_Keep && _Valid) {
            _Res   = _Xx2;
            _Valid = false;
        } else { 
            _Ty _Vx1;
            _Ty _Vx2;
            _Ty _Sx;
            for (;;) { 
                _Vx1 = 2 * (_Nrand_impl<_Ty>(_Eng)) - 1;
                _Vx2 = 2 * (_Nrand_impl<_Ty>(_Eng)) - 1;
                _Sx  = _Vx1 * _Vx1 + _Vx2 * _Vx2;
                if (_Sx < _Ty{1} && _Vx1 != _Ty{0} && _Vx2 != _Ty{0}) {
                    
                    break;
                }
            }

            _Ty _LogSx;
            if (_Sx > _Ty{1e-4}) {
                _LogSx = ::std:: log(_Sx);
            } else {
                
                
                const _Ty _Ln2{_Ty{0.69314718055994530941723212145818}};
                const _Ty _Maxabs{(::std:: max)(::std:: abs(_Vx1), ::std:: abs(_Vx2))};
                const int _ExpMax{::std:: ilogb(_Maxabs)};
                _Vx1   = ::std:: scalbn(_Vx1, -_ExpMax);
                _Vx2   = ::std:: scalbn(_Vx2, -_ExpMax);
                _Sx    = _Vx1 * _Vx1 + _Vx2 * _Vx2;
                _LogSx = ::std:: log(_Sx) + static_cast<_Ty>(_ExpMax) * (_Ln2 * 2);
            }

            const _Ty _Fx{::std:: sqrt(_Ty{-2} * _LogSx / _Sx)};
            if (_Keep) { 
                _Xx2   = _Fx * _Vx2;
                _Valid = true;
            }
            _Res = _Fx * _Vx1;
        }
        return _Res * _Par0._Sigma + _Par0._Mean;
    }

    param_type _Par;
    bool _Valid;
    _Ty _Xx2;
};

template <class _Ty = double>
class gamma_distribution { 
public:
    static_assert(_Is_any_of_v<_Ty, float, double, long double>, "invalid template argument for " "gamma_distribution" ": N4659 29.6.1.1 [rand.req.genl]/1d requires one of " "float, double, or long double");

    using result_type = _Ty;

    struct param_type { 
        using distribution_type = gamma_distribution;

        param_type() {
            _Init(_Ty{1}, _Ty{1});
        }

        explicit param_type(_Ty _Alpha0, _Ty _Beta0 = _Ty{1}) {
            _Init(_Alpha0, _Beta0);
        }

        [[nodiscard]] friend bool operator==(const param_type& _Left, const param_type& _Right) {
            return _Left._Alpha == _Right._Alpha && _Left._Beta == _Right._Beta;
        }


#line 3077 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

        [[nodiscard]] _Ty alpha() const {
            return _Alpha;
        }

        [[nodiscard]] _Ty beta() const {
            return _Beta;
        }

        void _Init(_Ty _Alpha0, _Ty _Beta0) { 
            ;
            ;
            _Alpha = _Alpha0;
            _Beta  = _Beta0;
            _Px    = static_cast<_Ty>(_Exp1 / (_Alpha + _Exp1));
            _Sqrt  = :: sqrt(2 * _Alpha - 1);
        }

        _Ty _Alpha;
        _Ty _Beta;
        _Ty _Px;
        _Ty _Sqrt;
        exponential_distribution<_Ty> _Exp;
    };

    gamma_distribution() : _Par(_Ty{1}, _Ty{1}) {}

    explicit gamma_distribution(_Ty _Alpha0, _Ty _Beta0 = _Ty{1}) : _Par(_Alpha0, _Beta0) {}

    explicit gamma_distribution(const param_type& _Par0) : _Par(_Par0) {}

    [[nodiscard]] _Ty alpha() const {
        return _Par.alpha();
    }

    [[nodiscard]] _Ty beta() const {
        return _Par.beta();
    }

    [[nodiscard]] param_type param() const {
        return _Par;
    }

    void param(const param_type& _Par0) { 
        _Par = _Par0;
    }

    [[nodiscard]] result_type(min)() const { 
        return result_type{0.0};
    }

    [[nodiscard]] result_type(max)() const { 
        return numeric_limits<result_type>::infinity();
    }

    void reset() {} 

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng) const {
        return _Eval(_Eng, _Par);
    }

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng, const param_type& _Par0) const {
        return _Eval(_Eng, _Par0);
    }

    [[nodiscard]] friend bool operator==(const gamma_distribution& _Left, const gamma_distribution& _Right) {
        return _Left.param() == _Right.param();
    }


#line 3153 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

    template <class _Elem, class _Traits>
    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
        gamma_distribution& _Dist) { 
        gamma_distribution::result_type _Alpha0;
        gamma_distribution::result_type _Beta0;
        _In(_Istr, _Alpha0);
        _In(_Istr, _Beta0);
        _Dist._Par._Init(_Alpha0, _Beta0);
        return _Istr;
    }

    template <class _Elem, class _Traits>
    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
        const gamma_distribution& _Dist) { 
        _Out(_Ostr, _Dist._Par._Alpha);
        _Out(_Ostr, _Dist._Par._Beta);
        return _Ostr;
    }

private:
    template <class _Engine>
    result_type _Eval(_Engine& _Eng, param_type _Par0) const {
        _Ty _Ux;
        _Ty _Vx;
        _Ty _Xx;
        _Ty _Yx;
        _Ty _Qx;
        int _Count;
        if (_Par0._Alpha < 1) { 
                                
            for (;;) { 
                _Ux = (_Nrand_impl<_Ty>(_Eng));
                do {
                    _Vx = (_Nrand_impl<_Ty>(_Eng));
                } while (_Vx == 0);

                if (_Ux < _Par0._Px) { 
                    _Xx = :: pow(_Vx, _Ty{1} / _Par0._Alpha);
                    _Qx = :: exp(-_Xx);
                } else { 
                    _Xx = 1 - :: log(_Vx);
                    _Qx = :: pow(_Xx, _Par0._Alpha - 1);
                }

                if ((_Nrand_impl<_Ty>(_Eng)) < _Qx) {
                    return _Par0._Beta * _Xx;
                }
            }
        }

        if (_Par0._Alpha == 1) {
            return _Par0._Beta * _Par0._Exp(_Eng);
        }

        if (_Par0._Alpha < 20.0 && (_Count = static_cast<int>(_Par0._Alpha)) == _Par0._Alpha) {
            
            _Yx = (_Nrand_impl<_Ty>(_Eng));
            while (--_Count) { 
                do {
                    _Ux = (_Nrand_impl<_Ty>(_Eng));
                } while (_Ux == 0);

                _Yx *= _Ux;
            }
            return _Par0._Beta * -:: log(_Yx);
        }

        
        for (;;) { 
            _Yx = static_cast<_Ty>(:: tan(_Pi * (_Nrand_impl<_Ty>(_Eng))));
            _Xx = _Par0._Sqrt * _Yx + _Par0._Alpha - 1;
            if (0 < _Xx
                && (_Nrand_impl<_Ty>(_Eng)) <= (1 + _Yx * _Yx)
                                            * :: exp((_Par0._Alpha - 1) * :: log(_Xx / (_Par0._Alpha - 1))
                                                        - _Par0._Sqrt * _Yx)) {
                return _Par0._Beta * _Xx;
            }
        }
    }

    param_type _Par;
};

template <class _Ty = double>
class weibull_distribution { 
public:
    static_assert(_Is_any_of_v<_Ty, float, double, long double>, "invalid template argument for " "weibull_distribution" ": N4659 29.6.1.1 [rand.req.genl]/1d requires one of " "float, double, or long double");

    using result_type = _Ty;

    struct param_type { 
        using distribution_type = weibull_distribution;

        param_type() {
            _Init(_Ty{1}, _Ty{1});
        }

        explicit param_type(_Ty _Ax0, _Ty _Bx0 = _Ty{1}) {
            _Init(_Ax0, _Bx0);
        }

        [[nodiscard]] friend bool operator==(const param_type& _Left, const param_type& _Right) {
            return _Left._Ax == _Right._Ax && _Left._Bx == _Right._Bx;
        }


#line 3264 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

        [[nodiscard]] _Ty a() const {
            return _Ax;
        }

        [[nodiscard]] _Ty b() const {
            return _Bx;
        }

        void _Init(_Ty _Ax0, _Ty _Bx0) { 
            ;
            ;
            _Ax = _Ax0;
            _Bx = _Bx0;
        }

        _Ty _Ax;
        _Ty _Bx;
    };

    weibull_distribution() : _Par(_Ty{1}, _Ty{1}) {}

    explicit weibull_distribution(_Ty _Ax0, _Ty _Bx0 = _Ty{1}) : _Par(_Ax0, _Bx0) {}

    explicit weibull_distribution(const param_type& _Par0) : _Par(_Par0) {}

    [[nodiscard]] _Ty a() const {
        return _Par.a();
    }

    [[nodiscard]] _Ty b() const {
        return _Par.b();
    }

    [[nodiscard]] param_type param() const {
        return _Par;
    }

    void param(const param_type& _Par0) { 
        _Par = _Par0;
    }

    [[nodiscard]] result_type(min)() const { 
        return 0;
    }

    [[nodiscard]] result_type(max)() const { 
        return numeric_limits<result_type>::infinity();
    }

    void reset() {} 

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng) const {
        return _Eval(_Eng, _Par);
    }

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng, const param_type& _Par0) const {
        return _Eval(_Eng, _Par0);
    }

    [[nodiscard]] friend bool operator==(const weibull_distribution& _Left, const weibull_distribution& _Right) {
        return _Left.param() == _Right.param();
    }


#line 3335 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

    template <class _Elem, class _Traits>
    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
        weibull_distribution& _Dist) { 
        weibull_distribution::result_type _Ax0;
        weibull_distribution::result_type _Bx0;
        _In(_Istr, _Ax0);
        _In(_Istr, _Bx0);
        _Dist._Par._Init(_Ax0, _Bx0);
        return _Istr;
    }

    template <class _Elem, class _Traits>
    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
        const weibull_distribution& _Dist) { 
        _Out(_Ostr, _Dist._Par._Ax);
        _Out(_Ostr, _Dist._Par._Bx);
        return _Ostr;
    }

private:
    template <class _Engine>
    result_type _Eval(_Engine& _Eng, const param_type& _Par0) const { 
        _Ty _Px = (_Ty{1} - (_Nrand_impl<_Ty>(_Eng)));
        return _Par0._Bx * :: pow(-:: log(_Px), _Ty{1} / _Par0._Ax);
    }

    param_type _Par;
};

template <class _Ty = double>
class extreme_value_distribution { 
public:
    static_assert(_Is_any_of_v<_Ty, float, double, long double>, "invalid template argument for " "extreme_value_distribution" ": N4659 29.6.1.1 [rand.req.genl]/1d requires one of " "float, double, or long double");

    using result_type = _Ty;

    struct param_type { 
        using distribution_type = extreme_value_distribution;

        param_type() {
            _Init(_Ty{0}, _Ty{1});
        }

        explicit param_type(_Ty _Ax0, _Ty _Bx0 = _Ty{1}) {
            _Init(_Ax0, _Bx0);
        }

        [[nodiscard]] friend bool operator==(const param_type& _Left, const param_type& _Right) {
            return _Left._Ax == _Right._Ax && _Left._Bx == _Right._Bx;
        }


#line 3392 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

        [[nodiscard]] _Ty a() const {
            return _Ax;
        }

        [[nodiscard]] _Ty b() const {
            return _Bx;
        }

        void _Init(_Ty _Ax0, _Ty _Bx0) { 
            ;
            _Ax = _Ax0;
            _Bx = _Bx0;
        }

        _Ty _Ax;
        _Ty _Bx;
    };

    extreme_value_distribution() : _Par(_Ty{0}, _Ty{1}) {}

    explicit extreme_value_distribution(_Ty _Ax0, _Ty _Bx0 = _Ty{1}) : _Par(_Ax0, _Bx0) {}

    explicit extreme_value_distribution(const param_type& _Par0) : _Par(_Par0) {}

    [[nodiscard]] _Ty a() const {
        return _Par.a();
    }

    [[nodiscard]] _Ty b() const {
        return _Par.b();
    }

    [[nodiscard]] param_type param() const {
        return _Par;
    }

    void param(const param_type& _Par0) { 
        _Par = _Par0;
    }

    [[nodiscard]] result_type(min)() const { 
        return -numeric_limits<result_type>::infinity();
    }

    [[nodiscard]] result_type(max)() const { 
        return numeric_limits<result_type>::infinity();
    }

    void reset() {} 

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng) const {
        return _Eval(_Eng, _Par);
    }

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng, const param_type& _Par0) const {
        return _Eval(_Eng, _Par0);
    }

    [[nodiscard]] friend bool operator==(
        const extreme_value_distribution& _Left, const extreme_value_distribution& _Right) {
        return _Left.param() == _Right.param();
    }


#line 3464 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

    template <class _Elem, class _Traits>
    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
        extreme_value_distribution& _Dist) { 
        extreme_value_distribution::result_type _Ax0;
        extreme_value_distribution::result_type _Bx0;
        _In(_Istr, _Ax0);
        _In(_Istr, _Bx0);
        _Dist._Par._Init(_Ax0, _Bx0);
        return _Istr;
    }

    template <class _Elem, class _Traits>
    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
        const extreme_value_distribution& _Dist) { 
        _Out(_Ostr, _Dist._Par._Ax);
        _Out(_Ostr, _Dist._Par._Bx);
        return _Ostr;
    }

private:
    template <class _Engine>
    result_type _Eval(_Engine& _Eng, const param_type& _Par0) const { 
        _Ty _Px = (_Nrand_impl<_Ty>(_Eng));
        return _Par0._Ax - _Par0._Bx * :: log(-:: log(_Px));
    }

    param_type _Par;
};

template <class _Ty = double>
class lognormal_distribution { 
public:
    static_assert(_Is_any_of_v<_Ty, float, double, long double>, "invalid template argument for " "lognormal_distribution" ": N4659 29.6.1.1 [rand.req.genl]/1d requires one of " "float, double, or long double");

    using result_type = _Ty;

    struct param_type { 
        using distribution_type = lognormal_distribution;

        param_type() {
            _Init(_Ty{0}, _Ty{1});
        }

        explicit param_type(_Ty _Mx0, _Ty _Sx0 = _Ty{1}) {
            _Init(_Mx0, _Sx0);
        }

        [[nodiscard]] friend bool operator==(const param_type& _Left, const param_type& _Right) {
            return _Left._Mx == _Right._Mx && _Left._Sx == _Right._Sx;
        }


#line 3521 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

        [[nodiscard]] _Ty m() const {
            return _Mx;
        }

        [[nodiscard]] _Ty s() const {
            return _Sx;
        }

        void _Init(_Ty _Mx0, _Ty _Sx0) { 
            ;
            _Mx = _Mx0;
            _Sx = _Sx0;
        }

        _Ty _Mx;
        _Ty _Sx;
    };

    lognormal_distribution() : _Par(_Ty{0}, _Ty{1}) {}

    explicit lognormal_distribution(_Ty _Mx0, _Ty _Sx0 = _Ty{1}) : _Par(_Mx0, _Sx0) {}

    explicit lognormal_distribution(const param_type& _Par0) : _Par(_Par0) {}

    [[nodiscard]] _Ty m() const {
        return _Par.m();
    }

    [[nodiscard]] _Ty s() const {
        return _Par.s();
    }

    [[nodiscard]] param_type param() const {
        return _Par;
    }

    void param(const param_type& _Par0) { 
        _Par = _Par0;
    }

    [[nodiscard]] result_type(min)() const { 
        return result_type{0.0};
    }

    [[nodiscard]] result_type(max)() const { 
        return numeric_limits<result_type>::infinity();
    }

    void reset() {} 

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng) const {
        return _Eval(_Eng, _Par);
    }

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng, const param_type& _Par0) const {
        return _Eval(_Eng, _Par0);
    }

    [[nodiscard]] friend bool operator==(const lognormal_distribution& _Left, const lognormal_distribution& _Right) {
        return _Left.param() == _Right.param();
    }


#line 3591 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

    template <class _Elem, class _Traits>
    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
        lognormal_distribution& _Dist) { 
        lognormal_distribution::result_type _Mx0;
        lognormal_distribution::result_type _Sx0;
        _In(_Istr, _Mx0);
        _In(_Istr, _Sx0);
        _Dist._Par._Init(_Mx0, _Sx0);
        return _Istr;
    }

    template <class _Elem, class _Traits>
    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
        const lognormal_distribution& _Dist) { 
        _Out(_Ostr, _Dist._Par._Mx);
        _Out(_Ostr, _Dist._Par._Sx);
        return _Ostr;
    }

private:
    template <class _Engine>
    result_type _Eval(_Engine& _Eng, param_type _Par0) const { 
        normal_distribution<_Ty> _Dist(_Par0._Mx, _Par0._Sx);
        return :: exp(_Dist(_Eng));
    }

    param_type _Par;
};

template <class _Ty = double>
class chi_squared_distribution { 
public:
    static_assert(_Is_any_of_v<_Ty, float, double, long double>, "invalid template argument for " "chi_squared_distribution" ": N4659 29.6.1.1 [rand.req.genl]/1d requires one of " "float, double, or long double");

    using result_type = _Ty;

    struct param_type { 
        using distribution_type = chi_squared_distribution;

        param_type() {
            _Init(_Ty{1});
        }

        explicit param_type(_Ty _Nx0) {
            _Init(_Nx0);
        }

        [[nodiscard]] friend bool operator==(const param_type& _Left, const param_type& _Right) {
            return _Left._Nx == _Right._Nx;
        }


#line 3648 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

        [[nodiscard]] _Ty n() const {
            return _Nx;
        }

        void _Init(_Ty _Nx0) { 
            ;
            _Nx = _Nx0;
        }

        _Ty _Nx;
    };

    chi_squared_distribution() : _Par(_Ty{1}) {}

    explicit chi_squared_distribution(_Ty _Nx0) : _Par(_Nx0) {}

    explicit chi_squared_distribution(const param_type& _Par0) : _Par(_Par0) {}

    [[nodiscard]] _Ty n() const {
        return _Par.n();
    }

    [[nodiscard]] param_type param() const {
        return _Par;
    }

    void param(const param_type& _Par0) { 
        _Par = _Par0;
    }

    [[nodiscard]] result_type(min)() const { 
        return result_type{0.0};
    }

    [[nodiscard]] result_type(max)() const { 
        return numeric_limits<result_type>::infinity();
    }

    void reset() {} 

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng) const {
        return _Eval(_Eng, _Par);
    }

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng, const param_type& _Par0) const {
        return _Eval(_Eng, _Par0);
    }

    [[nodiscard]] friend bool operator==(const chi_squared_distribution& _Left, const chi_squared_distribution& _Right) {
        return _Left.param() == _Right.param();
    }


#line 3708 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

    template <class _Elem, class _Traits>
    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
        chi_squared_distribution& _Dist) { 
        chi_squared_distribution::result_type _Nx0;
        _Istr >> _Nx0;
        _Dist._Par._Init(_Nx0);
        return _Istr;
    }

    template <class _Elem, class _Traits>
    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
        const chi_squared_distribution& _Dist) { 
        return _Ostr << ' ' << _Dist._Par._Nx;
    }

private:
    template <class _Engine>
    result_type _Eval(_Engine& _Eng, const param_type& _Par0) const {
        gamma_distribution<_Ty> _Dist(static_cast<_Ty>(_Par0._Nx) * static_cast<_Ty>(0.5), _Ty{2});
        return _Dist(_Eng);
    }

    param_type _Par;
};

template <class _Ty = double>
class cauchy_distribution { 
public:
    static_assert(_Is_any_of_v<_Ty, float, double, long double>, "invalid template argument for " "cauchy_distribution" ": N4659 29.6.1.1 [rand.req.genl]/1d requires one of " "float, double, or long double");

    using result_type = _Ty;

    struct param_type { 
        using distribution_type = cauchy_distribution;

        param_type() {
            _Init(_Ty{0}, _Ty{1});
        }

        explicit param_type(_Ty _Ax0, _Ty _Bx0 = _Ty{1}) {
            _Init(_Ax0, _Bx0);
        }

        [[nodiscard]] friend bool operator==(const param_type& _Left, const param_type& _Right) {
            return _Left._Ax == _Right._Ax && _Left._Bx == _Right._Bx;
        }


#line 3761 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

        [[nodiscard]] _Ty a() const {
            return _Ax;
        }

        [[nodiscard]] _Ty b() const {
            return _Bx;
        }

        void _Init(_Ty _Ax0, _Ty _Bx0) { 
            ;
            _Ax = _Ax0;
            _Bx = _Bx0;
        }

        _Ty _Ax;
        _Ty _Bx;
    };

    cauchy_distribution() : _Par(_Ty{0}, _Ty{1}) {}

    explicit cauchy_distribution(_Ty _Ax0, _Ty _Bx0 = _Ty{1}) : _Par(_Ax0, _Bx0) {}

    explicit cauchy_distribution(const param_type& _Par0) : _Par(_Par0) {}

    [[nodiscard]] _Ty a() const {
        return _Par.a();
    }

    [[nodiscard]] _Ty b() const {
        return _Par.b();
    }

    [[nodiscard]] param_type param() const {
        return _Par;
    }

    void param(const param_type& _Par0) { 
        _Par = _Par0;
    }

    [[nodiscard]] result_type(min)() const { 
        return -numeric_limits<result_type>::infinity();
    }

    [[nodiscard]] result_type(max)() const { 
        return numeric_limits<result_type>::infinity();
    }

    void reset() {} 

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng) const {
        return _Eval(_Eng, _Par);
    }

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng, const param_type& _Par0) const {
        return _Eval(_Eng, _Par0);
    }

    [[nodiscard]] friend bool operator==(const cauchy_distribution& _Left, const cauchy_distribution& _Right) {
        return _Left.param() == _Right.param();
    }


#line 3831 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

    template <class _Elem, class _Traits>
    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
        cauchy_distribution& _Dist) { 
        cauchy_distribution::result_type _Ax0;
        cauchy_distribution::result_type _Bx0;
        _In(_Istr, _Ax0);
        _In(_Istr, _Bx0);
        _Dist._Par._Init(_Ax0, _Bx0);
        return _Istr;
    }

    template <class _Elem, class _Traits>
    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
        const cauchy_distribution& _Dist) { 
        _Out(_Ostr, _Dist._Par._Ax);
        _Out(_Ostr, _Dist._Par._Bx);
        return _Ostr;
    }

private:
    template <class _Engine>
    result_type _Eval(_Engine& _Eng, const param_type& _Par0) const { 
        _Ty Px = (_Nrand_impl<_Ty>(_Eng));
        return static_cast<_Ty>(_Par0._Ax + _Par0._Bx * :: tan(_Pi * (Px - static_cast<_Ty>(0.5))));
    }

    param_type _Par;
};

template <class _Ty = double>
class _Beta_distribution { 
public:
    using result_type = _Ty;

    explicit _Beta_distribution(const _Ty& _Ax0 = _Ty{1}, const _Ty& _Bx0 = _Ty{1}) {
        _Init(_Ax0, _Bx0);
    }

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng) const {
        if (_Ax < _Ty{1} && _Bx < _Ty{1}) { 
            _Ty _Wx;
            _Ty _Px1;
            _Ty _Px2;
            for (;;) { 
                _Px1 = (_Nrand_impl<_Ty>(_Eng));
                _Px2 = (_Nrand_impl<_Ty>(_Eng));
                _Px1 = :: pow(_Px1, _Ty{1} / _Ax);
                _Px2 = :: pow(_Px2, _Ty{1} / _Bx);
                _Wx  = _Px1 + _Px2;
                if (_Wx <= _Ty{1} && _Wx != _Ty{0}) {
                    break;
                }
            }
            return _Px1 / _Wx;
        } else { 
            _Ty _Px1;
            _Ty _Px2;
            _Ty _PSum;
            gamma_distribution<_Ty> _Dist1(_Ax, 1);
            gamma_distribution<_Ty> _Dist2(_Bx, 1);

            for (;;) { 
                _Px1  = _Dist1(_Eng);
                _Px2  = _Dist2(_Eng);
                _PSum = _Px1 + _Px2;

                if (_PSum != _Ty{0}) {
                    break;
                }
            }

            return _Px1 / _PSum;
        }
    }

private:
    void _Init(_Ty _Ax0, _Ty _Bx0) { 
        ;
        ;
        _Ax = _Ax0;
        _Bx = _Bx0;
    }

    _Ty _Ax;
    _Ty _Bx;
};

template <class _Ty = double>
class fisher_f_distribution { 
public:
    static_assert(_Is_any_of_v<_Ty, float, double, long double>, "invalid template argument for " "fisher_f_distribution" ": N4659 29.6.1.1 [rand.req.genl]/1d requires one of " "float, double, or long double");

    using result_type = _Ty;

    struct param_type { 
        using distribution_type = fisher_f_distribution;

        param_type() {
            _Init(_Ty{1}, _Ty{1});
        }

        explicit param_type(_Ty _Mx0, _Ty _Nx0 = _Ty{1}) {
            _Init(_Mx0, _Nx0);
        }

        [[nodiscard]] friend bool operator==(const param_type& _Left, const param_type& _Right) {
            return _Left._Mx == _Right._Mx && _Left._Nx == _Right._Nx;
        }


#line 3947 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

        [[nodiscard]] _Ty m() const {
            return _Mx;
        }

        [[nodiscard]] _Ty n() const {
            return _Nx;
        }

        void _Init(_Ty _Mx0, _Ty _Nx0) { 
            ;
            ;
            _Mx = _Mx0;
            _Nx = _Nx0;
        }

        _Ty _Mx;
        _Ty _Nx;
    };

    fisher_f_distribution() : _Par(_Ty{1}, _Ty{1}) {}

    explicit fisher_f_distribution(_Ty _Mx0, _Ty _Nx0 = _Ty{1}) : _Par(_Mx0, _Nx0) {}

    explicit fisher_f_distribution(const param_type& _Par0) : _Par(_Par0) {}

    [[nodiscard]] _Ty m() const {
        return _Par.m();
    }

    [[nodiscard]] _Ty n() const {
        return _Par.n();
    }

    [[nodiscard]] param_type param() const {
        return _Par;
    }

    void param(const param_type& _Par0) { 
        _Par = _Par0;
    }

    [[nodiscard]] result_type(min)() const { 
        return result_type(0);
    }

    [[nodiscard]] result_type(max)() const { 
        return numeric_limits<result_type>::infinity();
    }

    void reset() {} 

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng) const {
        return _Eval(_Eng, _Par);
    }

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng, const param_type& _Par0) const {
        return _Eval(_Eng, _Par0);
    }

    [[nodiscard]] friend bool operator==(const fisher_f_distribution& _Left, const fisher_f_distribution& _Right) {
        return _Left.param() == _Right.param();
    }


#line 4018 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

    template <class _Elem, class _Traits>
    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
        fisher_f_distribution& _Dist) { 
        fisher_f_distribution::result_type _Mx0;
        fisher_f_distribution::result_type _Nx0;
        _Istr >> _Mx0 >> _Nx0;
        _Dist._Par._Init(_Mx0, _Nx0);
        return _Istr;
    }

    template <class _Elem, class _Traits>
    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
        const fisher_f_distribution& _Dist) { 
        _Ostr << ' ' << _Dist._Par._Mx << ' ' << _Dist._Par._Nx;
        return _Ostr;
    }

private:
    template <class _Engine>
    result_type _Eval(_Engine& _Eng, const param_type& _Par0) const {
        _Ty _Px;
        _Ty _Vx1;
        _Ty _Vx2;
        const _Ty _Vx3{1};
        _Vx1 = static_cast<_Ty>(_Par0._Mx) * static_cast<_Ty>(0.5);
        _Vx2 = static_cast<_Ty>(_Par0._Nx) * static_cast<_Ty>(0.5);
        _Beta_distribution<_Ty> _Dist(_Vx1, _Vx2);
        for (;;) { 
            _Px = _Dist(_Eng);
            if (_Px != _Vx3) {
                break;
            }
        }

        return (_Vx2 / _Vx1) * (_Px / (_Vx3 - _Px));
    }

    param_type _Par;
};

template <class _Ty = double>
class student_t_distribution { 
public:
    static_assert(_Is_any_of_v<_Ty, float, double, long double>, "invalid template argument for " "student_t_distribution" ": N4659 29.6.1.1 [rand.req.genl]/1d requires one of " "float, double, or long double");

    using result_type = _Ty;

    struct param_type { 
        using distribution_type = student_t_distribution;

        param_type() {
            _Init(_Ty{1});
        }

        explicit param_type(_Ty _Nx0) {
            _Init(_Nx0);
        }

        [[nodiscard]] friend bool operator==(const param_type& _Left, const param_type& _Right) {
            return _Left._Nx == _Right._Nx;
        }


#line 4086 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

        [[nodiscard]] _Ty n() const {
            return _Nx;
        }

        void _Init(_Ty _Nx0) { 
            ;
            _Nx = _Nx0;
        }

        _Ty _Nx;
    };

    student_t_distribution() : _Par(_Ty{1}) {}

    explicit student_t_distribution(_Ty _Nx0) : _Par(_Nx0) {}

    explicit student_t_distribution(const param_type& _Par0) : _Par(_Par0) {}

    [[nodiscard]] _Ty n() const {
        return _Par.n();
    }

    [[nodiscard]] param_type param() const {
        return _Par;
    }

    void param(const param_type& _Par0) { 
        _Par = _Par0;
    }

    [[nodiscard]] result_type(min)() const { 
        return -numeric_limits<result_type>::infinity();
    }

    [[nodiscard]] result_type(max)() const { 
        return numeric_limits<result_type>::infinity();
    }

    void reset() {} 

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng) const {
        return _Eval(_Eng, _Par);
    }

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng, const param_type& _Par0) const {
        return _Eval(_Eng, _Par0);
    }

    [[nodiscard]] friend bool operator==(const student_t_distribution& _Left, const student_t_distribution& _Right) {
        return _Left.param() == _Right.param();
    }


#line 4146 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

    template <class _Elem, class _Traits>
    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
        student_t_distribution& _Dist) { 
        student_t_distribution::result_type _Nx0;
        _Istr >> _Nx0;
        _Dist._Par._Init(_Nx0);
        return _Istr;
    }

    template <class _Elem, class _Traits>
    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
        const student_t_distribution& _Dist) { 
        return _Ostr << ' ' << _Dist._Par._Nx;
    }

private:
    template <class _Engine>
    result_type _Eval(_Engine& _Eng, const param_type& _Par0) const {
        _Ty _Vx1;
        _Ty _Vx2;
        _Ty _Rx0;
        _Ty _Rs;
        uniform_real<_Ty> _Dist(-1, 1);
        for (;;) { 
            _Vx1 = _Dist(_Eng);
            _Vx2 = _Dist(_Eng);
            _Rs  = _Vx1 * _Vx1 + _Vx2 * _Vx2;

            
            if (_Rs < _Ty{1} && _Rs > _Ty{1e-12}) {
                break;
            }
        }
        _Rx0 = ::std:: sqrt(_Rs);
        return _Vx1 * ::std:: sqrt(_Par0._Nx * (::std:: pow(_Rx0, -_Ty{4} / _Par0._Nx) - _Ty{1}) / _Rs);
    }

    param_type _Par;
};

template <class _Ty = int>
class negative_binomial_distribution { 
public:
    static_assert(_Is_any_of_v<_Ty, short, int, long, long long, unsigned short, unsigned int, unsigned long, unsigned long long>, "invalid template argument for " "negative_binomial_distribution" ": N4659 29.6.1.1 [rand.req.genl]/1e requires one of " "short, int, long, long long, unsigned short, unsigned int, unsigned long, or unsigned long long"); static_assert(!_Is_character<_Ty>::value, "note: char, signed char, unsigned char, char8_t, int8_t, and uint8_t are not allowed");

    using result_type = _Ty;

    struct param_type { 
        using distribution_type = negative_binomial_distribution;

        param_type() {
            _Init(1, 0.5);
        }

        explicit param_type(_Ty _Kx0, double _Px0 = 0.5) {
            _Init(_Kx0, _Px0);
        }

        [[nodiscard]] friend bool operator==(const param_type& _Left, const param_type& _Right) {
            return _Left._Kx == _Right._Kx && _Left._Px == _Right._Px;
        }


#line 4214 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

        [[nodiscard]] _Ty k() const {
            return _Kx;
        }

        [[nodiscard]] double p() const {
            return _Px;
        }

        void _Init(_Ty _Kx0, double _Px0) { 
            ;
#line 4226 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"
            ;
#line 4228 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"
            _Kx = _Kx0;
            _Px = _Px0;
        }

        _Ty _Kx;
        double _Px;
    };

    negative_binomial_distribution() : _Par(1, 0.5) {}

    explicit negative_binomial_distribution(_Ty _Kx0, double _Px0 = 0.5) : _Par(_Kx0, _Px0) {}

    explicit negative_binomial_distribution(const param_type& _Par0) : _Par(_Par0) {}

    [[nodiscard]] _Ty k() const {
        return _Par.k();
    }

    [[nodiscard]] double p() const {
        return _Par.p();
    }

    [[nodiscard]] param_type param() const {
        return _Par;
    }

    void param(const param_type& _Par0) { 
        _Par = _Par0;
    }

    [[nodiscard]] result_type(min)() const { 
        return 0;
    }

    [[nodiscard]] result_type(max)() const { 
        return (numeric_limits<result_type>::max)();
    }

    void reset() {} 

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng) const {
        return _Eval(_Eng, _Par);
    }

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng, const param_type& _Par0) const {
        return _Eval(_Eng, _Par0);
    }

    [[nodiscard]] friend bool operator==(
        const negative_binomial_distribution& _Left, const negative_binomial_distribution& _Right) {
        return _Left.param() == _Right.param();
    }


#line 4289 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

    template <class _Elem, class _Traits>
    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
        negative_binomial_distribution& _Dist) { 
        negative_binomial_distribution::result_type _Kx0;
        double _Px0;
        _In(_Istr, _Px0);
        _In(_Istr, _Kx0);
        _Dist._Par._Init(_Kx0, _Px0);
        return _Istr;
    }

    template <class _Elem, class _Traits>
    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
        const negative_binomial_distribution& _Dist) { 
        _Out(_Ostr, _Dist._Par._Px);
        _Out(_Ostr, _Dist._Par._Kx);
        return _Ostr;
    }

private:
    template <class _Engine>
    result_type _Eval(_Engine& _Eng, const param_type& _Par0) const {
        double _Vx1;
        gamma_distribution<double> _Dist1(
            static_cast<double>(_Par0._Kx), static_cast<double>((_Ty{1} - _Par0._Px) / _Par0._Px));
        _Vx1 = _Dist1(_Eng);
        poisson_distribution<_Ty> _Dist2(_Vx1);

        return _Dist2(_Eng);
    }

    param_type _Par;
};

template <class _Ty = int>
class discrete_distribution { 
public:
    static_assert(_Is_any_of_v<_Ty, short, int, long, long long, unsigned short, unsigned int, unsigned long, unsigned long long>, "invalid template argument for " "discrete_distribution" ": N4659 29.6.1.1 [rand.req.genl]/1e requires one of " "short, int, long, long long, unsigned short, unsigned int, unsigned long, or unsigned long long"); static_assert(!_Is_character<_Ty>::value, "note: char, signed char, unsigned char, char8_t, int8_t, and uint8_t are not allowed");

    using _Myvec      = vector<double>;
    using result_type = _Ty;

    struct param_type { 
        using distribution_type = discrete_distribution;

        param_type(_Uninitialized) {} 

        param_type() {
            _Init();
        }

        template <class _InIt>
        param_type(_InIt _First, _InIt _Last) : _Pvec(_First, _Last) {
            _Init();
        }

        param_type(initializer_list<double> _Ilist) : _Pvec(_Ilist) {
            _Init();
        }

        template <class _Fn>
        param_type(size_t _Count, double _Low, double _High, _Fn _Func) {
            double _Range = _High - _Low;
            ;
            if (_Count <= 0) {
                _Count = 1;
            }

            _Range /= static_cast<double>(_Count);
            _Low += 0.5 * _Range; 
            for (size_t _Idx = 0; _Idx < _Count; ++_Idx) {
                _Pvec.push_back(_Func(_Low + _Idx * _Range));
            }

            _Init();
        }

        [[nodiscard]] friend bool operator==(const param_type& _Left, const param_type& _Right) {
            return _Left._Pvec == _Right._Pvec;
        }


#line 4376 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

        [[nodiscard]] _Myvec probabilities() const {
            return _Pvec;
        }

        void _Init(bool _Renorm = true) { 
            size_t _Size = _Pvec.size();
            size_t _Idx;

            if (_Renorm) {
                if (_Pvec.empty()) {
                    _Pvec.push_back(1.0); 
                } else { 
                    double _Sum = 0;

                    for (_Idx = 0; _Idx < _Size; ++_Idx) { 
                        ;
                        _Sum += _Pvec[_Idx];
                    }

                    ;
                    if (_Sum != 1.0) {
                        for (_Idx = 0; _Idx < _Size; ++_Idx) {
                            _Pvec[_Idx] /= _Sum;
                        }
                    }
                }
            }

            _Pcdf.assign(1, _Pvec[0]);
            for (_Idx = 1; _Idx < _Size; ++_Idx) {
                _Pcdf.push_back(_Pvec[_Idx] + _Pcdf[_Idx - 1]);
            }
        }

        template <class _Elem, class _Traits>
        basic_istream<_Elem, _Traits>& _Read(basic_istream<_Elem, _Traits>& _Istr) { 
            size_t _Nvals;
            _Istr >> _Nvals;
            _Pvec.clear();
            for (; 0 < _Nvals; --_Nvals) { 
                double _Val;
                _In(_Istr, _Val);
                _Pvec.push_back(_Val);
            }
            _Init(false); 
            return _Istr;
        }

        template <class _Elem, class _Traits>
        basic_ostream<_Elem, _Traits>& _Write(basic_ostream<_Elem, _Traits>& _Ostr) const { 
            const size_t _Nvals = _Pvec.size();
            _Ostr << ' ' << _Nvals;

            for (size_t _Idx = 0; _Idx < _Nvals; ++_Idx) {
                _Out(_Ostr, _Pvec[_Idx]);
            }

            return _Ostr;
        }

        _Myvec _Pvec;
        _Myvec _Pcdf;
    };

    discrete_distribution() {}

    template <class _InIt>
    discrete_distribution(_InIt _First, _InIt _Last) : _Par(_First, _Last) {}

    discrete_distribution(initializer_list<double> _Ilist) : _Par(_Ilist) {}

    template <class _Fn>
    discrete_distribution(size_t _Count, double _Low, double _High, _Fn _Func) : _Par(_Count, _Low, _High, _Func) {}

    explicit discrete_distribution(const param_type& _Par0) : _Par(_Par0) {}

    [[nodiscard]] _Myvec probabilities() const {
        return _Par.probabilities();
    }

    [[nodiscard]] param_type param() const {
        return _Par;
    }

    void param(const param_type& _Par0) { 
        _Par = _Par0;
    }

    [[nodiscard]] result_type(min)() const {
        return 0;
    }

    [[nodiscard]] result_type(max)() const {
        return static_cast<result_type>(_Par._Pvec.size() - 1);
    }

    void reset() {} 

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng) const {
        return _Eval(_Eng, _Par);
    }

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng, const param_type& _Par0) const {
        return _Eval(_Eng, _Par0);
    }

    [[nodiscard]] friend bool operator==(const discrete_distribution& _Left, const discrete_distribution& _Right) {
        return _Left.param() == _Right.param();
    }


#line 4494 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

    template <class _Elem, class _Traits>
    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
        discrete_distribution& _Dist) { 
        return _Dist._Par._Read(_Istr);
    }

    template <class _Elem, class _Traits>
    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
        const discrete_distribution& _Dist) { 
        return _Dist._Par._Write(_Ostr);
    }

private:
    template <class _Engine>
    result_type _Eval(_Engine& _Eng, const param_type& _Par0) const {
        double _Px           = (_Nrand_impl<double>(_Eng));
        const auto _First    = _Par0._Pcdf.begin();
        const auto _Position = ::std:: lower_bound(_First, _Prev_iter(_Par0._Pcdf.end()), _Px);
        return static_cast<result_type>(_Position - _First);
    }

public:
    param_type _Par;
};

template <class _Ty = double>
class piecewise_constant_distribution
    : public discrete_distribution<size_t> { 
    
public:
    static_assert(_Is_any_of_v<_Ty, float, double, long double>, "invalid template argument for " "piecewise_constant_distribution" ": N4659 29.6.1.1 [rand.req.genl]/1d requires one of " "float, double, or long double");

    using _Mybase     = discrete_distribution<size_t>;
    using _Mypbase    = typename _Mybase::param_type;
    using result_type = _Ty;

    struct param_type : _Mypbase { 
        using distribution_type = piecewise_constant_distribution;

        param_type() : _Bvec{0, 1} {}

        template <class _InIt1, class _InIt2>
        param_type(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2) : _Mypbase(_Noinit), _Bvec(_First1, _Last1) {
            if (2 <= _Bvec.size()) {
                for (size_t _Idx = 0; _Idx < _Bvec.size() - 1; ++_Idx) {
                    this->_Pvec.push_back(static_cast<double>(*_First2++));
                }
            } else { 
                _Bvec = {0, 1};
            }

            _Init();
        }

        template <class _Fn>
        param_type(initializer_list<_Ty> _Ilist, _Fn _Func) : _Mypbase(_Noinit) {
            if (2 <= _Ilist.size()) {
                _Bvec.assign(_Ilist);

                for (size_t _Idx = 0; _Idx < _Bvec.size() - 1; ++_Idx) {
                    this->_Pvec.push_back(_Func(_Ty{0.5} * (_Bvec[_Idx] + _Bvec[_Idx + 1])));
                }
            } else { 
                _Bvec = {0, 1};
            }

            _Init();
        }

        template <class _Fn>
        param_type(size_t _Count, _Ty _Low, _Ty _High, _Fn _Func) : _Mypbase(_Count, _Low, _High, _Func) {
            _Ty _Range = _High - _Low;
            if (_Count <= 0) {
                _Count = 1;
            }

            _Range /= static_cast<_Ty>(_Count);
            for (size_t _Idx = 0; _Idx <= _Count; ++_Idx) {
                _Bvec.push_back(_Low + _Idx * _Range);
            }
        }

        [[nodiscard]] friend bool operator==(const param_type& _Left, const param_type& _Right) {
            return static_cast<const _Mypbase&>(_Left) == static_cast<const _Mypbase&>(_Right)
                && _Left._Bvec == _Right._Bvec;
        }


#line 4587 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

        [[nodiscard]] vector<_Ty> intervals() const {
            return _Bvec;
        }

        [[nodiscard]] vector<_Ty> densities() const {
            vector<_Ty> _Ans(this->_Pvec.begin(), this->_Pvec.end());

            for (size_t _Idx = 0; _Idx < _Ans.size(); ++_Idx) {
                _Ans[_Idx] /= _Bvec[_Idx + 1] - _Bvec[_Idx];
            }

            return _Ans;
        }

        void _Init() { 
            _Mypbase::_Init();
        }

        vector<_Ty> _Bvec;
    };

    piecewise_constant_distribution() {}

    template <class _InIt1, class _InIt2>
    piecewise_constant_distribution(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2) : _Par(_First1, _Last1, _First2) {}

    template <class _Fn>
    piecewise_constant_distribution(initializer_list<_Ty> _Ilist, _Fn _Func) : _Par(_Ilist, _Func) {}

    template <class _Fn>
    piecewise_constant_distribution(size_t _Count, _Ty _Low, _Ty _High, _Fn _Func) : _Par(_Count, _Low, _High, _Func) {}

    explicit piecewise_constant_distribution(const param_type& _Par0) : _Par(_Par0) {}

    [[nodiscard]] vector<_Ty> intervals() const {
        return _Par.intervals();
    }

    [[nodiscard]] vector<_Ty> densities() const {
        return _Par.densities();
    }

    [[nodiscard]] param_type param() const {
        return _Par;
    }

    void param(const param_type& _Par0) { 
        _Par = _Par0;
    }

    [[nodiscard]] result_type(min)() const {
        return _Par._Bvec.front();
    }

    [[nodiscard]] result_type(max)() const {
        return _Par._Bvec.back();
    }

    void reset() {} 

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng) const {
        return _Eval(_Eng, _Par);
    }

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng, const param_type& _Par0) const {
        return _Eval(_Eng, _Par0);
    }

    [[nodiscard]] friend bool operator==(
        const piecewise_constant_distribution& _Left, const piecewise_constant_distribution& _Right) {
        return _Left.param() == _Right.param();
    }


#line 4669 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

    template <class _Elem, class _Traits>
    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
        piecewise_constant_distribution& _Dist) { 
        static_cast<piecewise_constant_distribution::_Mypbase&>(_Dist._Par)._Read(_Istr);

        _Dist._Par._Bvec.clear();
        for (size_t _Idx = _Dist._Par._Pvec.size() + 1; 0 < _Idx; --_Idx) { 
            double _Val;
            _In(_Istr, _Val);
            _Dist._Par._Bvec.push_back(_Val);
        }
        return _Istr;
    }

    template <class _Elem, class _Traits>
    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
        const piecewise_constant_distribution& _Dist) { 
        static_cast<const piecewise_constant_distribution::_Mypbase&>(_Dist._Par)._Write(_Ostr);

        for (size_t _Idx = 0; _Idx < _Dist._Par._Bvec.size(); ++_Idx) {
            _Out(_Ostr, _Dist._Par._Bvec[_Idx]);
        }

        return _Ostr;
    }

    template <class _Engine>
    result_type _Eval(_Engine& _Eng, const param_type& _Par0) const {
        size_t _Px = _Mybase::operator()(_Eng, _Par0);
        uniform_real<_Ty> _Dist(_Par0._Bvec[_Px], _Par0._Bvec[_Px + 1]);
        return _Dist(_Eng);
    }

    param_type _Par;
};

template <class _Ty = double>
class piecewise_linear_distribution
    : public discrete_distribution<size_t> { 
    
public:
    static_assert(_Is_any_of_v<_Ty, float, double, long double>, "invalid template argument for " "piecewise_linear_distribution" ": N4659 29.6.1.1 [rand.req.genl]/1d requires one of " "float, double, or long double");

    using _Mybase     = discrete_distribution<size_t>;
    using _Mypbase    = typename _Mybase::param_type;
    using result_type = _Ty;

    struct param_type : _Mypbase { 
        
        
        using distribution_type = piecewise_linear_distribution;

        param_type() : _Bvec{0, 1} {
            this->_Pvec.push_back(1.0);
        }

        template <class _InIt1, class _InIt2>
        param_type(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2) : _Mypbase(_Noinit), _Bvec(_First1, _Last1) {
            if (2 <= _Bvec.size()) {
                for (size_t _Idx = 0; _Idx < _Bvec.size(); ++_Idx) {
                    this->_Pvec.push_back(static_cast<double>(*_First2++));
                }
            } else { 
                _Bvec = {0, 1};
            }

            _Init();
        }

        template <class _Fn>
        param_type(initializer_list<_Ty> _Ilist, _Fn _Func) : _Mypbase(_Noinit) {
            if (2 <= _Ilist.size()) {
                _Bvec.assign(_Ilist);

                for (const auto& _Bval : _Bvec) {
                    this->_Pvec.push_back(_Func(_Bval));
                }
            } else { 
                _Bvec = {0, 1};
            }

            _Init();
        }

        template <class _Fn>
        param_type(size_t _Count, _Ty _Low, _Ty _High, _Fn _Func) : _Mypbase(_Noinit) {
            _Ty _Range = _High - _Low;
            ;
            if (_Count < 1) {
                _Count = 1;
            }

            _Range /= static_cast<double>(_Count);
            for (size_t _Idx = 0; _Idx <= _Count; ++_Idx) { 
                _Ty _Bval = _Low + _Idx * _Range;
                _Bvec.push_back(_Bval);
                this->_Pvec.push_back(_Func(_Bval));
            }
            _Init();
        }

        [[nodiscard]] friend bool operator==(const param_type& _Left, const param_type& _Right) {
            return static_cast<const _Mypbase&>(_Left) == static_cast<const _Mypbase&>(_Right)
                && _Left._Bvec == _Right._Bvec;
        }


#line 4781 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

        [[nodiscard]] vector<_Ty> intervals() const {
            return _Bvec;
        }

        [[nodiscard]] vector<_Ty> densities() const {
            vector<_Ty> _Ans(this->_Pvec.begin(), this->_Pvec.end());
            return _Ans;
        }

        [[nodiscard]] double _Piece_probability(const size_t _Idx) const {
            return 0.5 * (this->_Pvec[_Idx] + this->_Pvec[_Idx + 1])
                 * static_cast<double>(_Bvec[_Idx + 1] - _Bvec[_Idx]);
        }

        void _Init(bool _Renorm = true) { 
            size_t _Size = this->_Pvec.size();
            size_t _Idx;

            if (_Renorm) {
                if (this->_Pvec.empty()) { 
                    this->_Pvec = {1.0, 1.0};
                } else { 
                    double _Sum = 0;

                    ;
#line 4808 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"
                    for (_Idx = 1; _Idx < _Size; ++_Idx) { 
                        ;
#line 4811 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"
                        _Sum += _Piece_probability(_Idx - 1);
                    }

                    ;
#line 4816 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"
                    if (_Sum != 1.0) {
                        for (_Idx = 0; _Idx < _Size; ++_Idx) {
                            this->_Pvec[_Idx] /= _Sum;
                        }
                    }
                }
            }

            this->_Pcdf.assign(1, _Piece_probability(0));
            for (_Idx = 2; _Idx < _Size; ++_Idx) {
                this->_Pcdf.push_back(_Piece_probability(_Idx - 1) + this->_Pcdf[_Idx - 2]);
            }
        }

        vector<_Ty> _Bvec;
    };

    piecewise_linear_distribution() {}

    template <class _InIt1, class _InIt2>
    piecewise_linear_distribution(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2) : _Par(_First1, _Last1, _First2) {}

    template <class _Fn>
    piecewise_linear_distribution(initializer_list<_Ty> _Ilist, _Fn _Func) : _Par(_Ilist, _Func) {}

    template <class _Fn>
    piecewise_linear_distribution(size_t _Count, _Ty _Low, _Ty _High, _Fn _Func) : _Par(_Count, _Low, _High, _Func) {}

    explicit piecewise_linear_distribution(const param_type& _Par0) : _Par(_Par0) {}

    [[nodiscard]] vector<_Ty> intervals() const {
        return _Par.intervals();
    }

    [[nodiscard]] vector<_Ty> densities() const {
        return _Par.densities();
    }

    [[nodiscard]] param_type param() const {
        return _Par;
    }

    void param(const param_type& _Par0) { 
        _Par = _Par0;
    }

    [[nodiscard]] result_type(min)() const {
        return _Par._Bvec.front();
    }

    [[nodiscard]] result_type(max)() const {
        return _Par._Bvec.back();
    }

    void reset() {} 

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng) const {
        return _Eval(_Eng, _Par);
    }

    template <class _Engine>
    [[nodiscard]] result_type operator()(_Engine& _Eng, const param_type& _Par0) const {
        return _Eval(_Eng, _Par0);
    }

    [[nodiscard]] friend bool operator==(
        const piecewise_linear_distribution& _Left, const piecewise_linear_distribution& _Right) {
        return _Left.param() == _Right.param();
    }


#line 4893 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

    template <class _Elem, class _Traits>
    friend basic_istream<_Elem, _Traits>& operator>>(basic_istream<_Elem, _Traits>& _Istr,
        piecewise_linear_distribution& _Dist) { 
        static_cast<piecewise_linear_distribution::_Mypbase&>(_Dist._Par)._Read(_Istr);


        _Dist._Par._Bvec.clear();
        for (size_t _Idx = _Dist._Par._Pvec.size(); 0 < _Idx; --_Idx) { 
            double _Val;
            _In(_Istr, _Val);
            _Dist._Par._Bvec.push_back(_Val);
        }
        _Dist._Par._Init(false); 
        return _Istr;
    }

    template <class _Elem, class _Traits>
    friend basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr,
        const piecewise_linear_distribution& _Dist) { 
        static_cast<const piecewise_linear_distribution::_Mypbase&>(_Dist._Par)._Write(_Ostr);

        for (size_t _Idx = 0; _Idx < _Dist._Par._Bvec.size(); ++_Idx) {
            _Out(_Ostr, _Dist._Par._Bvec[_Idx]);
        }

        return _Ostr;
    }

    template <class _Engine>
    result_type _Eval(_Engine& _Eng, const param_type& _Par0) const {
        size_t _Px  = _Mybase::operator()(_Eng, _Par0);
        double _Px0 = _Par0._Pvec[_Px];
        double _Px1 = _Par0._Pvec[_Px + 1];
        uniform_real<_Ty> _Dist;
        result_type _Xx0 = _Dist(_Eng);

        if (_Px0 != _Px1) {
            _Xx0 = static_cast<result_type>(
                (::std:: sqrt(_Px0 * _Px0 * (1.0 - _Xx0) + _Px1 * _Px1 * _Xx0) - _Px0) / (_Px1 - _Px0));
        }

        return _Par0._Bvec[_Px] + _Xx0 * (_Par0._Bvec[_Px + 1] - _Par0._Bvec[_Px]);
    }

    param_type _Par;
};

using minstd_rand0 = linear_congruential_engine<unsigned int, 16807, 0, 2147483647>;
using minstd_rand  = linear_congruential_engine<unsigned int, 48271, 0, 2147483647>;

using mt19937 = mersenne_twister_engine<unsigned int, 32, 624, 397, 31, 0x9908b0df, 11, 0xffffffff, 7, 0x9d2c5680, 15,
    0xefc60000, 18, 1812433253>;


#line 4959 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"

using mt19937_64 = mersenne_twister_engine<unsigned long long, 64, 312, 156, 31, 0xb5026f5aa96619e9ULL, 29,
    0x5555555555555555ULL, 17, 0x71d67fffeda60000ULL, 37, 0xfff7eee000000000ULL, 43, 6364136223846793005ULL>;

using ranlux24_base = subtract_with_carry_engine<unsigned int, 24, 10, 24>;
using ranlux48_base = subtract_with_carry_engine<unsigned long long, 48, 5, 12>;
using ranlux24      = discard_block_engine<ranlux24_base, 223, 23>;
using ranlux48      = discard_block_engine<ranlux48_base, 389, 11>;
using knuth_b       = shuffle_order_engine<minstd_rand0, 256>;

using default_random_engine = mt19937;


 unsigned int __cdecl _Random_device();

class random_device { 
public:
    using result_type = unsigned int;

    random_device() {}

    explicit random_device(const string&) {}

    [[nodiscard]] static constexpr result_type(min)() {
        return 0;
    }

    [[nodiscard]] static constexpr result_type(max)() {
        return static_cast<result_type>(-1);
    }

    [[nodiscard]] double entropy() const noexcept {
        return 32.0;
    }

    [[nodiscard]] result_type operator()() {
        return _Random_device();
    }

    random_device(const random_device&) = delete;
    random_device& operator=(const random_device&) = delete;
};


#line 5060 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"
}


#pragma warning(pop)
#pragma pack(pop)
#line 5069 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"
#line 5070 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\random"
#line 79 "all-std.cxx"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\valarray"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
class gslice;
class slice;

template <class _Ty>
class gslice_array;
template <class _Ty>
class indirect_array;
template <class _Ty>
class mask_array;
template <class _Ty>
class slice_array;
template <class _Ty>
class valarray;

template <class _Ty>
_Ty* _Allocate_for_op_delete(size_t _Count) {
    
    if (_Count == 0) {
        return nullptr;
    }

    const size_t _Bytes = _Get_size_of_n<sizeof(_Ty)>(_Count);

    constexpr bool _Extended_alignment = alignof(_Ty) > 8u;
    if constexpr (_Extended_alignment) {
        return static_cast<_Ty*>(::operator new (_Bytes, align_val_t{alignof(_Ty)}));
    } else
#line 50 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\valarray"
    {
        return static_cast<_Ty*>(::operator new(_Bytes));
    }
}

using _Boolarray = valarray<bool>;
using _Sizarray  = valarray<size_t>;

template <class _Ty>
class valarray { 
public:
    friend _Tidy_deallocate_guard<valarray>;

    template <class _Ty2>
    friend _Ty2* begin(valarray<_Ty2>& _Array);

    template <class _Ty2>
    friend const _Ty2* begin(const valarray<_Ty2>& _Array);

    template <class _Ty2>
    friend _Ty2* end(valarray<_Ty2>& _Array);

    template <class _Ty2>
    friend const _Ty2* end(const valarray<_Ty2>& _Array);

    using value_type = _Ty;

    valarray() { 
        _Tidy_init();
    }

    explicit valarray(size_t _Count) { 
        _Tidy_init();
        _Grow(_Count);
    }

    valarray(const _Ty& _Val, size_t _Count) { 
        _Tidy_init();
        _Grow(_Count, &_Val);
    }

    valarray(const _Ty* _Ptr, size_t _Count) { 
        _Tidy_init();
        _Grow(_Count, _Ptr, 1);
    }

    valarray(const valarray& _Right) {
        _Tidy_init();
        _Grow(_Right.size(), _Right._Myptr, 1);
    }

    valarray(const slice_array<_Ty>& _Slicearr) {
        _Tidy_init();
        *this = _Slicearr;
    }

    valarray(const gslice_array<_Ty>& _Gslicearr) {
        _Tidy_init();
        *this = _Gslicearr;
    }

    valarray(const mask_array<_Ty>& _Maskarr) {
        _Tidy_init();
        *this = _Maskarr;
    }

    valarray(const indirect_array<_Ty>& _Indarr) {
        _Tidy_init();
        *this = _Indarr;
    }

    valarray(valarray&& _Right) noexcept {
        _Tidy_init();
        _Assign_rv(::std:: move(_Right));
    }

    valarray& operator=(valarray&& _Right) noexcept {
        _Assign_rv(::std:: move(_Right));
        return *this;
    }

    void _Assign_rv(valarray&& _Right) {
        if (this != ::std:: addressof(_Right)) { 
            _Tidy_deallocate();
            _Myptr  = _Right._Myptr;
            _Mysize = _Right._Mysize;
            _Right._Tidy_init();
        }
    }

    valarray(initializer_list<_Ty> _Ilist) {
        _Tidy_init();
        _Grow(_Ilist.size(), _Ilist.begin(), 1);
    }

    valarray& operator=(initializer_list<_Ty> _Ilist) {
        _Assign(_Ilist.size(), _Ilist.begin());
        return *this;
    }

    void swap(valarray& _Right) noexcept {
        if (this != ::std:: addressof(_Right)) {
            ::std:: swap(_Myptr, _Right._Myptr);
            ::std:: swap(_Mysize, _Right._Mysize);
        }
    }

    ~valarray() noexcept {
        _Tidy_deallocate();
    }

    valarray& operator=(const valarray& _Right) {
        if (this != ::std:: addressof(_Right)) {
            _Assign(_Right.size(), _Right._Myptr);
        }

        return *this;
    }

    valarray& operator=(const _Ty& _Val) {
        const size_t _Size = size();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Idx] = _Val;
        }
        return *this;
    }

    void resize(size_t _Newsize) { 
        _Tidy_deallocate();
        _Grow(_Newsize);
    }

    void resize(size_t _Newsize, _Ty _Val) { 
        _Tidy_deallocate();
        _Grow(_Newsize, &_Val, 0);
    }

    valarray& operator=(const slice_array<_Ty>& _Slicearr); 

    valarray& operator=(const gslice_array<_Ty>& _Gslicearr); 

    valarray& operator=(const mask_array<_Ty>& _Maskarr); 

    valarray& operator=(const indirect_array<_Ty>& _Indarr); 

    [[nodiscard]] valarray operator+() const {
        const size_t _Size = size();
        valarray<_Ty> _Ans(_Size);
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Ans[_Idx] = +_Myptr[_Idx];
        }
        return _Ans;
    }

    [[nodiscard]] valarray operator-() const {
        const size_t _Size = size();
        valarray<_Ty> _Ans(_Size);
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Ans[_Idx] = -_Myptr[_Idx];
        }
        return _Ans;
    }

    [[nodiscard]] valarray operator~() const {
        const size_t _Size = size();
        valarray<_Ty> _Ans(_Size);
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Ans[_Idx] = ~_Myptr[_Idx];
        }
        return _Ans;
    }

    [[nodiscard]] _Boolarray operator!() const {
        const size_t _Size = size();
        valarray<bool> _Ans(_Size);
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Ans[_Idx] = !_Myptr[_Idx];
        }
        return _Ans;
    }

    valarray& operator*=(const _Ty& _Right) {
        const size_t _Size = size();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Idx] *= _Right;
        }
        return *this;
    }

    valarray& operator/=(const _Ty& _Right) {
        const size_t _Size = size();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Idx] /= _Right;
        }
        return *this;
    }

    valarray& operator%=(const _Ty& _Right) {
        const size_t _Size = size();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Idx] %= _Right;
        }
        return *this;
    }

    valarray& operator+=(const _Ty& _Right) {
        const size_t _Size = size();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Idx] += _Right;
        }
        return *this;
    }

    valarray& operator-=(const _Ty& _Right) {
        const size_t _Size = size();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Idx] -= _Right;
        }
        return *this;
    }

    valarray& operator^=(const _Ty& _Right) {
        const size_t _Size = size();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Idx] ^= _Right;
        }
        return *this;
    }

    valarray& operator&=(const _Ty& _Right) {
        const size_t _Size = size();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Idx] &= _Right;
        }
        return *this;
    }

    valarray& operator|=(const _Ty& _Right) {
        const size_t _Size = size();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Idx] |= _Right;
        }
        return *this;
    }

    valarray& operator<<=(const _Ty& _Right) {
        const size_t _Size = size();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Idx] <<= _Right;
        }
        return *this;
    }

    valarray& operator>>=(const _Ty& _Right) {
        const size_t _Size = size();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Idx] >>= _Right;
        }
        return *this;
    }

    valarray& operator*=(const valarray& _Right) {
        const size_t _Size = size();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Idx] *= _Right[_Idx];
        }
        return *this;
    }

    valarray& operator/=(const valarray& _Right) {
        const size_t _Size = size();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Idx] /= _Right[_Idx];
        }
        return *this;
    }

    valarray& operator%=(const valarray& _Right) {
        const size_t _Size = size();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Idx] %= _Right[_Idx];
        }
        return *this;
    }

    valarray& operator+=(const valarray& _Right) {
        const size_t _Size = size();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Idx] += _Right[_Idx];
        }
        return *this;
    }

    valarray& operator-=(const valarray& _Right) {
        const size_t _Size = size();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Idx] -= _Right[_Idx];
        }
        return *this;
    }

    valarray& operator^=(const valarray& _Right) {
        const size_t _Size = size();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Idx] ^= _Right[_Idx];
        }
        return *this;
    }

    valarray& operator|=(const valarray& _Right) {
        const size_t _Size = size();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Idx] |= _Right[_Idx];
        }
        return *this;
    }

    valarray& operator&=(const valarray& _Right) {
        const size_t _Size = size();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Idx] &= _Right[_Idx];
        }
        return *this;
    }

    valarray& operator<<=(const valarray& _Right) {
        const size_t _Size = size();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Idx] <<= _Right[_Idx];
        }
        return *this;
    }

    valarray& operator>>=(const valarray& _Right) {
        const size_t _Size = size();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Idx] >>= _Right[_Idx];
        }
        return *this;
    }

    [[nodiscard]] size_t size() const noexcept  {
        return _Mysize;
    }

    [[nodiscard]] const _Ty& operator[](size_t _Off) const noexcept  {


#line 399 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\valarray"

        return _Myptr[_Off];
    }

    [[nodiscard]] _Ty& operator[](size_t _Off) noexcept  {


#line 407 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\valarray"

        return _Myptr[_Off];
    }

    [[nodiscard]] valarray operator[](slice _Slicearr) const; 

    [[nodiscard]] slice_array<_Ty> operator[](slice _Slicearr); 

    [[nodiscard]] valarray operator[](const gslice& _Gslicearr) const; 

    [[nodiscard]] gslice_array<_Ty> operator[](const gslice& _Gslicearr); 

    [[nodiscard]] valarray operator[](const _Boolarray& _Boolarr) const; 

    [[nodiscard]] mask_array<_Ty> operator[](const _Boolarray& _Boolarr); 

    [[nodiscard]] valarray operator[](const _Sizarray& _Indarr) const; 

    [[nodiscard]] indirect_array<_Ty> operator[](const _Sizarray& _Indarr); 

    [[nodiscard]] _Ty sum() const {
        const size_t _Size = size();
        _Ty _Sum           = _Myptr[0];
        for (size_t _Idx = 1; _Idx < _Size; ++_Idx) {
            _Sum += _Myptr[_Idx];
        }

        return _Sum;
    }

    [[nodiscard]] _Ty(min)() const {
        const size_t _Size = size();
        _Ty _Min           = _Myptr[0];
        for (size_t _Idx = 1; _Idx < _Size; ++_Idx) {
            if (_Myptr[_Idx] < _Min) {
                _Min = _Myptr[_Idx];
            }
        }

        return _Min;
    }

    [[nodiscard]] _Ty(max)() const {
        const size_t _Size = size();
        _Ty _Max           = _Myptr[0];
        for (size_t _Idx = 1; _Idx < _Size; ++_Idx) {
            if (_Max < _Myptr[_Idx]) {
                _Max = _Myptr[_Idx];
            }
        }

        return _Max;
    }

    [[nodiscard]] valarray shift(int _Count) const {
        const size_t _Size = size();
        valarray<_Ty> _Ans(_Size);
        size_t _Min = 0;
        size_t _Max = _Size;
        if (_Count < 0) {
            const size_t _Skip = static_cast<size_t>(-_Count);
            _Min += _Skip;
        } else {
            const size_t _Skip = static_cast<size_t>(_Count);
            if (_Skip < _Size) {
                _Max -= _Skip;
            } else {
                _Max = 0;
            }
        }
        for (size_t _Idx = _Min; _Idx < _Max; ++_Idx) {
            _Ans[_Idx] = _Myptr[_Idx + _Count];
        }
        return _Ans;
    }

    [[nodiscard]] valarray cshift(int _Count) const {
        const size_t _Size = size();
        if (_Size != 0) {
            if (_Count < 0) { 
                if (_Size < size_t{0} - _Count) {
                    _Count = static_cast<int>(_Size - (size_t{0} - _Count - _Size) % _Size);
                } else {
                    _Count = static_cast<int>(_Size + _Count);
                }
            } else if (_Size <= static_cast<size_t>(_Count)) {
                _Count %= _Size;
            }
        }

        valarray<_Ty> _Ans(_Size);
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Ans[_Idx] =
                _Size - _Idx <= static_cast<size_t>(_Count) ? _Myptr[_Idx - _Size + _Count] : _Myptr[_Idx + _Count];
        }
        return _Ans;
    }

    [[nodiscard]] valarray apply(_Ty _Func(_Ty)) const {
        const size_t _Size = size();
        valarray<_Ty> _Ans(_Size);
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Ans[_Idx] = _Func(_Myptr[_Idx]);
        }
        return _Ans;
    }

    [[nodiscard]] valarray apply(_Ty _Func(const _Ty&)) const {
        
        const size_t _Size = size();
        valarray<_Ty> _Ans(_Size);
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Ans[_Idx] = _Func(_Myptr[_Idx]);
        }
        return _Ans;
    }

private:
    void _Grow(size_t _Newsize) { 
        if (0 < _Newsize) { 
            _Myptr = _Allocate_for_op_delete<_Ty>(_Newsize);
            _Tidy_deallocate_guard<valarray> _Guard{this};
            for (size_t _Idx = 0; _Idx < _Newsize; ++_Idx) {
                _Construct_in_place(_Myptr[_Idx]);
            }

            _Guard._Target = nullptr;
            _Mysize        = _Newsize;
        }
    }

    void _Grow(size_t _Newsize, const _Ty* _Ptr, size_t _Inc = 0) {
        
        if (0 < _Newsize) { 
            _Myptr = _Allocate_for_op_delete<_Ty>(_Newsize);
            _Tidy_deallocate_guard<valarray> _Guard{this};
            for (size_t _Idx = 0; _Idx < _Newsize; ++_Idx, _Ptr += _Inc) {
                _Construct_in_place(_Myptr[_Idx], *_Ptr);
            }

            _Guard._Target = nullptr;
            _Mysize        = _Newsize;
        }
    }

    void _Tidy_init() noexcept {
        _Mysize = 0;
        _Myptr  = nullptr;
    }

    void _Tidy_deallocate() noexcept {
        if (_Myptr) { 
            for (size_t _Idx = 0; _Idx < _Mysize; ++_Idx) {
                _Destroy_in_place(_Myptr[_Idx]);
            }


            constexpr bool _Extended_alignment = alignof(_Ty) > 8u;
            if constexpr (_Extended_alignment) {
                ::operator delete (static_cast<void*>(_Myptr), align_val_t{alignof(_Ty)});
            } else
#line 569 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\valarray"
            {
                ::operator delete(static_cast<void*>(_Myptr));
            }
        }

        _Tidy_init();
    }

    void _Assign(size_t _Newsize, const _Ty* _Ptr) {
        const size_t _Size = size();
        if (_Size == _Newsize) {
            for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
                _Myptr[_Idx] = _Ptr[_Idx];
            }
        } else { 
            _Tidy_deallocate();
            _Grow(_Newsize, _Ptr, 1);
        }
    }

    _Ty* _Myptr; 
    size_t _Mysize; 
};


template <class _Ty, size_t _Nx>
valarray(const _Ty (&)[_Nx], size_t) -> valarray<_Ty>;
#line 597 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\valarray"

template <class _Ty>
void swap(valarray<_Ty>& _Left, valarray<_Ty>& _Right) noexcept {
    _Left.swap(_Right);
}

template <class _Ty>
[[nodiscard]] _Ty* begin(valarray<_Ty>& _Array) {
    return _Array._Myptr;
}

template <class _Ty>
[[nodiscard]] const _Ty* begin(const valarray<_Ty>& _Array) {
    return _Array._Myptr;
}

template <class _Ty>
[[nodiscard]] _Ty* end(valarray<_Ty>& _Array) {
    return _Array._Myptr + _Array.size();
}

template <class _Ty>
[[nodiscard]] const _Ty* end(const valarray<_Ty>& _Array) {
    return _Array._Myptr + _Array.size();
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> operator*(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] * _Right;
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> operator*(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Right.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left * _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> operator/(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] / _Right;
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> operator/(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Right.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left / _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> operator%(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] % _Right;
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> operator%(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Right.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left % _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> operator+(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] + _Right;
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> operator+(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Right.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left + _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> operator-(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] - _Right;
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> operator-(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Right.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left - _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> operator^(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] ^ _Right;
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> operator^(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Right.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left ^ _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> operator&(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] & _Right;
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> operator&(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Right.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left & _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> operator|(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] | _Right;
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> operator|(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Right.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left | _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> operator<<(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] << _Right;
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> operator<<(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Right.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left << _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> operator>>(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] >> _Right;
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> operator>>(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Right.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left >> _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] _Boolarray operator&&(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
    const size_t _Size = _Left.size();
    valarray<bool> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] && _Right;
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] _Boolarray operator&&(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Right.size();
    valarray<bool> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left && _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] _Boolarray operator||(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
    const size_t _Size = _Left.size();
    valarray<bool> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] || _Right;
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] _Boolarray operator||(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Right.size();
    valarray<bool> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left || _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> operator*(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] * _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> operator/(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] / _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> operator%(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] % _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> operator+(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] + _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> operator-(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] - _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> operator^(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] ^ _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> operator&(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] & _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> operator|(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] | _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> operator<<(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] << _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> operator>>(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] >> _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] _Boolarray operator&&(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Left.size();
    valarray<bool> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] && _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] _Boolarray operator||(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Left.size();
    valarray<bool> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] || _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] _Boolarray operator==(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
    const size_t _Size = _Left.size();
    valarray<bool> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] == _Right;
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] _Boolarray operator==(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Right.size();
    valarray<bool> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left == _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] _Boolarray operator==(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Left.size();
    valarray<bool> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] == _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] _Boolarray operator!=(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
    const size_t _Size = _Left.size();
    valarray<bool> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] != _Right;
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] _Boolarray operator!=(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Right.size();
    valarray<bool> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left != _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] _Boolarray operator!=(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Left.size();
    valarray<bool> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] != _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] _Boolarray operator<(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
    const size_t _Size = _Left.size();
    valarray<bool> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] < _Right;
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] _Boolarray operator<(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Right.size();
    valarray<bool> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left < _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] _Boolarray operator<(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Left.size();
    valarray<bool> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] < _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] _Boolarray operator>(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
    const size_t _Size = _Left.size();
    valarray<bool> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] > _Right;
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] _Boolarray operator>(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Right.size();
    valarray<bool> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left > _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] _Boolarray operator>(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Left.size();
    valarray<bool> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] > _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] _Boolarray operator<=(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
    const size_t _Size = _Left.size();
    valarray<bool> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] <= _Right;
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] _Boolarray operator<=(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Right.size();
    valarray<bool> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left <= _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] _Boolarray operator<=(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Left.size();
    valarray<bool> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] <= _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] _Boolarray operator>=(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
    const size_t _Size = _Left.size();
    valarray<bool> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] >= _Right;
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] _Boolarray operator>=(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Right.size();
    valarray<bool> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left >= _Right[_Idx];
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] _Boolarray operator>=(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Left.size();
    valarray<bool> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = _Left[_Idx] >= _Right[_Idx];
    }
    return _Ans;
}


template <class _Ty>
[[nodiscard]] valarray<_Ty> abs(const valarray<_Ty>& _Left) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = abs(_Left[_Idx]); 
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> acos(const valarray<_Ty>& _Left) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = acos(_Left[_Idx]); 
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> asin(const valarray<_Ty>& _Left) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = asin(_Left[_Idx]); 
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> atan(const valarray<_Ty>& _Left) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = atan(_Left[_Idx]); 
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> atan2(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = atan2(_Left[_Idx], _Right[_Idx]); 
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> atan2(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = atan2(_Left[_Idx], _Right); 
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> atan2(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Right.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = atan2(_Left, _Right[_Idx]); 
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> cos(const valarray<_Ty>& _Left) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = cos(_Left[_Idx]); 
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> cosh(const valarray<_Ty>& _Left) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = cosh(_Left[_Idx]); 
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> exp(const valarray<_Ty>& _Left) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = exp(_Left[_Idx]); 
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> log(const valarray<_Ty>& _Left) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = log(_Left[_Idx]); 
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> log10(const valarray<_Ty>& _Left) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = log10(_Left[_Idx]); 
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> pow(const valarray<_Ty>& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = pow(_Left[_Idx], _Right[_Idx]); 
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> pow(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = pow(_Left[_Idx], _Right); 
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> pow(const typename valarray<_Ty>::value_type& _Left, const valarray<_Ty>& _Right) {
    const size_t _Size = _Right.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = pow(_Left, _Right[_Idx]); 
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> sin(const valarray<_Ty>& _Left) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = sin(_Left[_Idx]); 
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> sinh(const valarray<_Ty>& _Left) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = sinh(_Left[_Idx]); 
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> sqrt(const valarray<_Ty>& _Left) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = sqrt(_Left[_Idx]); 
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> tan(const valarray<_Ty>& _Left) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = tan(_Left[_Idx]); 
    }
    return _Ans;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> tanh(const valarray<_Ty>& _Left) {
    const size_t _Size = _Left.size();
    valarray<_Ty> _Ans(_Size);
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Ans[_Idx] = tanh(_Left[_Idx]); 
    }
    return _Ans;
}

class slice { 
public:
    slice() = default;

    slice(size_t _Off, size_t _Count, size_t _Inc) noexcept 
        : _Start(_Off), _Len(_Count), _Stride(_Inc) {}

    [[nodiscard]] size_t start() const noexcept  {
        return _Start;
    }

    [[nodiscard]] size_t size() const noexcept  {
        return _Len;
    }

    [[nodiscard]] size_t stride() const noexcept  {
        return _Stride;
    }


    [[nodiscard]] friend bool operator==(const slice& _Left, const slice& _Right) noexcept  {
        return _Left.start() == _Right.start() && _Left.size() == _Right.size() && _Left.stride() == _Right.stride();
    }
#line 1388 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\valarray"

protected:
    size_t _Start  = 0; 
    size_t _Len    = 0; 
    size_t _Stride = 0; 
};

template <class _Ty>
class slice_array : public slice { 
public:
    using value_type = _Ty;

    void operator=(const valarray<_Ty>& _Right) const {
        size_t _Off = _Start;
        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
            _Myptr[_Off] = _Right[_Idx];
        }
    }

    void operator=(const _Ty& _Right) const {
        size_t _Off = _Start;
        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
            _Myptr[_Off] = _Right;
        }
    }

    void operator*=(const valarray<_Ty>& _Right) const {
        size_t _Off = _Start;
        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
            _Myptr[_Off] *= _Right[_Idx];
        }
    }

    void operator/=(const valarray<_Ty>& _Right) const {
        size_t _Off = _Start;
        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
            _Myptr[_Off] /= _Right[_Idx];
        }
    }

    void operator%=(const valarray<_Ty>& _Right) const {
        size_t _Off = _Start;
        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
            _Myptr[_Off] %= _Right[_Idx];
        }
    }

    void operator+=(const valarray<_Ty>& _Right) const {
        size_t _Off = _Start;
        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
            _Myptr[_Off] += _Right[_Idx];
        }
    }

    void operator-=(const valarray<_Ty>& _Right) const {
        size_t _Off = _Start;
        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
            _Myptr[_Off] -= _Right[_Idx];
        }
    }

    void operator^=(const valarray<_Ty>& _Right) const {
        size_t _Off = _Start;
        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
            _Myptr[_Off] ^= _Right[_Idx];
        }
    }

    void operator&=(const valarray<_Ty>& _Right) const {
        size_t _Off = _Start;
        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
            _Myptr[_Off] &= _Right[_Idx];
        }
    }

    void operator|=(const valarray<_Ty>& _Right) const {
        size_t _Off = _Start;
        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
            _Myptr[_Off] |= _Right[_Idx];
        }
    }

    void operator<<=(const valarray<_Ty>& _Right) const {
        size_t _Off = _Start;
        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
            _Myptr[_Off] <<= _Right[_Idx];
        }
    }

    void operator>>=(const valarray<_Ty>& _Right) const {
        size_t _Off = _Start;
        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Off += _Stride) {
            _Myptr[_Off] >>= _Right[_Idx];
        }
    }

    _Ty& _Data(size_t _Idx) const {
        return _Myptr[_Idx];
    }

    slice_array() = delete;

    slice_array(const slice_array&) = default;

    const slice_array& operator=(const slice_array& _Right) const {
        size_t _Dst_off = _Start;
        size_t _Src_off = _Right._Start;
        for (size_t _Idx = 0; _Idx < _Len; ++_Idx, _Dst_off += _Stride, _Src_off += _Right._Stride) {
            _Myptr[_Dst_off] = _Right._Myptr[_Src_off];
        }
        return *this;
    }

private:
    friend valarray<_Ty>;

    slice_array(const slice& _Slice, _Ty* _Pdata) : slice(_Slice), _Myptr(_Pdata) {}

    _Ty* _Myptr; 
};

class gslice { 
public:
    gslice() : _Start(0) {} 

    gslice(size_t _Off, const _Sizarray& _Lenarr, const _Sizarray& _Incarr)
        : _Start(_Off), _Len(_Lenarr), _Stride(_Incarr) {}

    [[nodiscard]] size_t start() const {
        return _Start;
    }

    [[nodiscard]] _Sizarray size() const {
        return _Len;
    }

    [[nodiscard]] _Sizarray stride() const {
        return _Stride;
    }

    size_t _Nslice() const {
        return _Len.size();
    }

    size_t _Off(_Sizarray& _Indexarr) const {
        size_t _Idx;
        size_t _Ans        = _Start;
        const size_t _Size = _Indexarr.size();
        for (_Idx = 0; _Idx < _Size; ++_Idx) {
            _Ans += _Indexarr[_Idx] * _Stride[_Idx]; 
        }

        while (0 < _Idx--) {
            if (++_Indexarr[_Idx] < _Len[_Idx]) {
                break; 
            } else {
                _Indexarr[_Idx] = 0; 
            }
        }

        return _Ans;
    }

    [[nodiscard]] size_t _Totlen() const {
        const size_t _Size = _Len.size();
        if (_Size == 0) {
            return 0;
        }

        size_t _Count = _Len[0];
        for (size_t _Idx = 1; _Idx < _Size; ++_Idx) {
            _Count *= _Len[_Idx];
        }

        return _Count;
    }

private:
    size_t _Start; 
    _Sizarray _Len; 
    _Sizarray _Stride; 
};

template <class _Ty>
class gslice_array : public gslice { 
public:
    using value_type = _Ty;

    void operator=(const valarray<_Ty>& _Right) const {
        _Sizarray _Indexarray(size_t{0}, _Nslice());
        const size_t _Size = _Totlen();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Off(_Indexarray)] = _Right[_Idx];
        }
    }

    void operator=(const _Ty& _Right) const {
        _Sizarray _Indexarray(size_t{0}, _Nslice());
        const size_t _Size = _Totlen();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Off(_Indexarray)] = _Right;
        }
    }

    void operator*=(const valarray<_Ty>& _Right) const { 
        _Sizarray _Indexarray(size_t{0}, _Nslice());
        const size_t _Size = _Totlen();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Off(_Indexarray)] *= _Right[_Idx];
        }
    }

    void operator/=(const valarray<_Ty>& _Right) const { 
        _Sizarray _Indexarray(size_t{0}, _Nslice());
        const size_t _Size = _Totlen();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Off(_Indexarray)] /= _Right[_Idx];
        }
    }

    void operator%=(const valarray<_Ty>& _Right) const { 
        _Sizarray _Indexarray(size_t{0}, _Nslice());
        const size_t _Size = _Totlen();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Off(_Indexarray)] %= _Right[_Idx];
        }
    }

    void operator+=(const valarray<_Ty>& _Right) const { 
        _Sizarray _Indexarray(size_t{0}, _Nslice());
        const size_t _Size = _Totlen();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Off(_Indexarray)] += _Right[_Idx];
        }
    }

    void operator-=(const valarray<_Ty>& _Right) const { 
        _Sizarray _Indexarray(size_t{0}, _Nslice());
        const size_t _Size = _Totlen();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Off(_Indexarray)] -= _Right[_Idx];
        }
    }

    void operator^=(const valarray<_Ty>& _Right) const { 
        _Sizarray _Indexarray(size_t{0}, _Nslice());
        const size_t _Size = _Totlen();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Off(_Indexarray)] ^= _Right[_Idx];
        }
    }

    void operator&=(const valarray<_Ty>& _Right) const { 
        _Sizarray _Indexarray(size_t{0}, _Nslice());
        const size_t _Size = _Totlen();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Off(_Indexarray)] &= _Right[_Idx];
        }
    }

    void operator|=(const valarray<_Ty>& _Right) const { 
        _Sizarray _Indexarray(size_t{0}, _Nslice());
        const size_t _Size = _Totlen();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Off(_Indexarray)] |= _Right[_Idx];
        }
    }

    void operator<<=(const valarray<_Ty>& _Right) const { 
        _Sizarray _Indexarray(size_t{0}, _Nslice());
        const size_t _Size = _Totlen();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Off(_Indexarray)] <<= _Right[_Idx];
        }
    }

    void operator>>=(const valarray<_Ty>& _Right) const { 
        _Sizarray _Indexarray(size_t{0}, _Nslice());
        const size_t _Size = _Totlen();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Off(_Indexarray)] >>= _Right[_Idx];
        }
    }

    [[nodiscard]] _Ty& _Data(size_t _Idx) const {
        return _Myptr[_Idx];
    }

    gslice_array() = delete;

    gslice_array(const gslice_array&) = default;

    const gslice_array& operator=(const gslice_array& _Right) const {
        _Sizarray _Dst_indexarray(size_t{0}, _Nslice());
        _Sizarray _Src_indexarray(size_t{0}, _Right._Nslice());
        const size_t _Size = _Totlen();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Off(_Dst_indexarray)] = _Right._Myptr[_Right._Off(_Src_indexarray)];
        }
        return *this;
    }

private:
    friend valarray<_Ty>;

    gslice_array(const gslice& _Gslice, _Ty* _Ptr) : gslice(_Gslice), _Myptr(_Ptr) {}

    _Ty* _Myptr; 
};

template <class _Ty>
class mask_array { 
public:
    using value_type = _Ty;

    void operator=(const valarray<_Ty>& _Right) const {
        const size_t _Size = _Mybool.size();
        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
            _Myptr[_Off] = _Right[_Idx];
        }
    }

    void operator=(const _Ty& _Right) const {
        const size_t _Size = _Mybool.size();
        for (size_t _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off)) {
            _Myptr[_Off] = _Right;
        }
    }

    void operator*=(const valarray<_Ty>& _Right) const { 
        const size_t _Size = _Mybool.size();
        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
            _Myptr[_Off] *= _Right[_Idx];
        }
    }

    void operator/=(const valarray<_Ty>& _Right) const { 
        const size_t _Size = _Mybool.size();
        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
            _Myptr[_Off] /= _Right[_Idx];
        }
    }

    void operator%=(const valarray<_Ty>& _Right) const { 
        const size_t _Size = _Mybool.size();
        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
            _Myptr[_Off] %= _Right[_Idx];
        }
    }

    void operator+=(const valarray<_Ty>& _Right) const { 
        const size_t _Size = _Mybool.size();
        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
            _Myptr[_Off] += _Right[_Idx];
        }
    }

    void operator-=(const valarray<_Ty>& _Right) const { 
        const size_t _Size = _Mybool.size();
        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
            _Myptr[_Off] -= _Right[_Idx];
        }
    }

    void operator^=(const valarray<_Ty>& _Right) const { 
        const size_t _Size = _Mybool.size();
        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
            _Myptr[_Off] ^= _Right[_Idx];
        }
    }

    void operator&=(const valarray<_Ty>& _Right) const { 
        const size_t _Size = _Mybool.size();
        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
            _Myptr[_Off] &= _Right[_Idx];
        }
    }

    void operator|=(const valarray<_Ty>& _Right) const { 
        const size_t _Size = _Mybool.size();
        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
            _Myptr[_Off] |= _Right[_Idx];
        }
    }

    void operator<<=(const valarray<_Ty>& _Right) const { 
        const size_t _Size = _Mybool.size();
        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
            _Myptr[_Off] <<= _Right[_Idx];
        }
    }

    void operator>>=(const valarray<_Ty>& _Right) const { 
        const size_t _Size = _Mybool.size();
        for (size_t _Idx = 0, _Off = _Start_off(); _Off < _Size; _Off = _Next_off(_Off), ++_Idx) {
            _Myptr[_Off] >>= _Right[_Idx];
        }
    }

    [[nodiscard]] _Ty& _Data(size_t _Idx) const {
        return _Myptr[_Idx];
    }

    [[nodiscard]] bool _Mask(size_t _Idx) const {
        return _Mybool[_Idx];
    }

    [[nodiscard]] size_t _Start_off() const {
        size_t _Off        = 0;
        const size_t _Size = _Mybool.size();
        while (_Off < _Size && !_Mybool[_Off]) {
            ++_Off;
        }
        return _Off;
    }

    [[nodiscard]] size_t _Next_off(size_t _Off) const {
        const size_t _Size = _Mybool.size();
        do {
            ++_Off;
        } while (_Off < _Size && !_Mybool[_Off]);
        return _Off;
    }

    [[nodiscard]] size_t _Totlen() const {
        size_t _Count      = 0;
        const size_t _Size = _Mybool.size();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            if (_Mybool[_Idx]) {
                ++_Count;
            }
        }

        return _Count;
    }

    mask_array() = delete;

    mask_array(const mask_array&) = default;

    const mask_array& operator=(const mask_array& _Right) const {
        const size_t _Size = _Mybool.size();
        size_t _Dst_off    = _Start_off();
        size_t _Src_off    = _Right._Start_off();
        for (; _Dst_off < _Size; _Src_off = _Right._Next_off(_Src_off), _Dst_off = _Next_off(_Dst_off)) {
            _Myptr[_Dst_off] = _Right._Myptr[_Src_off];
        }
        return *this;
    }

private:
    friend valarray<_Ty>;

    mask_array(const _Boolarray& _Maskarr, _Ty* _Pdata) : _Mybool(_Maskarr), _Myptr(_Pdata) {}

    _Boolarray _Mybool; 
    _Ty* _Myptr; 
};

template <class _Ty>
class indirect_array { 
public:
    using value_type = _Ty;

    void operator=(const valarray<_Ty>& _Right) const {
        const size_t _Size = _Totlen();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Indir(_Idx)] = _Right[_Idx];
        }
    }

    void operator=(const _Ty& _Right) const {
        const size_t _Size = _Totlen();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Indir(_Idx)] = _Right;
        }
    }

    void operator*=(const valarray<_Ty>& _Right) const { 
        const size_t _Size = _Totlen();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Indir(_Idx)] *= _Right[_Idx];
        }
    }

    void operator/=(const valarray<_Ty>& _Right) const { 
        const size_t _Size = _Totlen();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Indir(_Idx)] /= _Right[_Idx];
        }
    }

    void operator%=(const valarray<_Ty>& _Right) const { 
        const size_t _Size = _Totlen();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Indir(_Idx)] %= _Right[_Idx];
        }
    }

    void operator+=(const valarray<_Ty>& _Right) const { 
        const size_t _Size = _Totlen();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Indir(_Idx)] += _Right[_Idx];
        }
    }

    void operator-=(const valarray<_Ty>& _Right) const { 
        const size_t _Size = _Totlen();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Indir(_Idx)] -= _Right[_Idx];
        }
    }

    void operator^=(const valarray<_Ty>& _Right) const { 
        const size_t _Size = _Totlen();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Indir(_Idx)] ^= _Right[_Idx];
        }
    }

    void operator&=(const valarray<_Ty>& _Right) const { 
        const size_t _Size = _Totlen();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Indir(_Idx)] &= _Right[_Idx];
        }
    }

    void operator|=(const valarray<_Ty>& _Right) const { 
        const size_t _Size = _Totlen();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Indir(_Idx)] |= _Right[_Idx];
        }
    }

    void operator<<=(const valarray<_Ty>& _Right) const { 
        const size_t _Size = _Totlen();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Indir(_Idx)] <<= _Right[_Idx];
        }
    }

    void operator>>=(const valarray<_Ty>& _Right) const { 
        const size_t _Size = _Totlen();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Indir(_Idx)] >>= _Right[_Idx];
        }
    }

    [[nodiscard]] _Ty& _Data(size_t _Idx) const {
        return _Myptr[_Idx];
    }

    [[nodiscard]] size_t _Indir(size_t _Idx) const {
        return _Myindarr[_Idx];
    }

    [[nodiscard]] size_t _Totlen() const {
        return _Myindarr.size();
    }

    indirect_array() = delete;

    indirect_array(const indirect_array&) = default;

    const indirect_array& operator=(const indirect_array& _Right) const {
        const size_t _Size = _Totlen();
        for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
            _Myptr[_Indir(_Idx)] = _Right._Myptr[_Right._Indir(_Idx)];
        }
        return *this;
    }

private:
    friend valarray<_Ty>;

    indirect_array(const _Sizarray& _Indarr, _Ty* _Ptr) : _Myindarr(_Indarr), _Myptr(_Ptr) {}

    _Sizarray _Myindarr; 
    _Ty* _Myptr; 
};

template <class _Ty>
valarray<_Ty>& valarray<_Ty>::operator=(const slice_array<_Ty>& _Slicearr) {
    _Tidy_deallocate();
    _Grow(_Slicearr.size(), &_Slicearr._Data(_Slicearr.start()), _Slicearr.stride());
    return *this;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> valarray<_Ty>::operator[](slice _Slice) const {
    return valarray<_Ty>(slice_array<_Ty>(_Slice, _Myptr));
}

template <class _Ty>
[[nodiscard]] slice_array<_Ty> valarray<_Ty>::operator[](slice _Slice) {
    return slice_array<_Ty>(_Slice, _Myptr);
}

template <class _Ty>
valarray<_Ty>& valarray<_Ty>::operator=(const gslice_array<_Ty>& _Gslicearr) {
    _Tidy_deallocate();
    _Grow(_Gslicearr._Totlen());
    _Sizarray _Indexarray(size_t{0}, _Gslicearr._Nslice());
    const size_t _Size = size();
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Myptr[_Idx] = _Gslicearr._Data(_Gslicearr._Off(_Indexarray));
    }
    return *this;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> valarray<_Ty>::operator[](const gslice& _Gslice) const {
    return valarray<_Ty>(gslice_array<_Ty>(_Gslice, _Myptr));
}

template <class _Ty>
[[nodiscard]] gslice_array<_Ty> valarray<_Ty>::operator[](const gslice& _Gslicearr) {
    return gslice_array<_Ty>(_Gslicearr, _Myptr);
}

template <class _Ty>
valarray<_Ty>& valarray<_Ty>::operator=(const mask_array<_Ty>& _Maskarr) {
    _Tidy_deallocate();
    _Grow(_Maskarr._Totlen());
    size_t _Count = 0;

    const size_t _Size = size();
    for (size_t _Idx = 0; _Idx < _Size; ++_Count) {
        if (_Maskarr._Mask(_Count)) {
            _Myptr[_Idx++] = _Maskarr._Data(_Count);
        }
    }

    return *this;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> valarray<_Ty>::operator[](const _Boolarray& _Boolarr) const {
    return valarray<_Ty>(mask_array<_Ty>(_Boolarr, _Myptr));
}

template <class _Ty>
[[nodiscard]] mask_array<_Ty> valarray<_Ty>::operator[](const _Boolarray& _Boolarr) {
    return mask_array<_Ty>(_Boolarr, _Myptr);
}

template <class _Ty>
valarray<_Ty>& valarray<_Ty>::operator=(const indirect_array<_Ty>& _Indarr) {
    _Tidy_deallocate();
    _Grow(_Indarr._Totlen());
    const size_t _Size = size();
    for (size_t _Idx = 0; _Idx < _Size; ++_Idx) {
        _Myptr[_Idx] = _Indarr._Data(_Indarr._Indir(_Idx));
    }
    return *this;
}

template <class _Ty>
[[nodiscard]] valarray<_Ty> valarray<_Ty>::operator[](const _Sizarray& _Indarr) const {
    return valarray<_Ty>(indirect_array<_Ty>(_Indarr, _Myptr));
}

template <class _Ty>
[[nodiscard]] indirect_array<_Ty> valarray<_Ty>::operator[](const _Sizarray& _Indarr) {
    return indirect_array<_Ty>(_Indarr, _Myptr);
}
}


#pragma warning(pop)
#pragma pack(pop)
#line 2061 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\valarray"
#line 2062 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\valarray"
#line 81 "all-std.cxx"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\codecvt"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


#pragma warning(disable : 4127) 

namespace std {
inline constexpr int _Little_first = 1;
inline constexpr int _Big_first    = 2;

enum [[deprecated( "warning STL4017: " "std::wbuffer_convert, std::wstring_convert, and the <codecvt> header (containing std::codecvt_mode, " "std::codecvt_utf8, std::codecvt_utf16, and std::codecvt_utf8_utf16) are deprecated in C++17. " "(The std::codecvt class template is NOT deprecated.) " "The C++ Standard doesn't provide equivalent non-deprecated functionality; " "consider using MultiByteToWideChar() and WideCharToMultiByte() from <Windows.h> instead. " "You can define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] codecvt_mode { consume_header = 4, generate_header = 2, little_endian = 1 };

using _Statype = :: mbstate_t;

__pragma(warning(push)) __pragma(warning(disable : 4996))
template <class _Elem, unsigned long _Mymax = 0x10ffff, codecvt_mode _Mymode = codecvt_mode{}>
class [[deprecated( "warning STL4017: " "std::wbuffer_convert, std::wstring_convert, and the <codecvt> header (containing std::codecvt_mode, " "std::codecvt_utf8, std::codecvt_utf16, and std::codecvt_utf8_utf16) are deprecated in C++17. " "(The std::codecvt class template is NOT deprecated.) " "The C++ Standard doesn't provide equivalent non-deprecated functionality; " "consider using MultiByteToWideChar() and WideCharToMultiByte() from <Windows.h> instead. " "You can define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] codecvt_utf8 : public codecvt<_Elem, char, _Statype> {
    
public:
    using _Mybase     = codecvt<_Elem, char, _Statype>;
    using result      = typename _Mybase::result;
    using _Byte       = char;
    using intern_type = _Elem;
    using extern_type = _Byte;
    using state_type  = _Statype;

    explicit codecvt_utf8(size_t _Refs = 0) : _Mybase(_Refs) {}

     ~codecvt_utf8() noexcept override {}

protected:
    result  do_in(_Statype& _State, const _Byte* _First1, const _Byte* _Last1, const _Byte*& _Mid1,
        _Elem* _First2, _Elem* _Last2, _Elem*& _Mid2) const override {
        
        char* _Pstate = reinterpret_cast<char*>(&_State);
        _Mid1         = _First1;
        _Mid2         = _First2;

        while (_Mid1 != _Last1 && _Mid2 != _Last2) { 
            unsigned long _By = static_cast<unsigned char>(*_Mid1);
            unsigned long _Ch;
            int _Nextra;

            if (_By < 0x80u) {
                _Ch     = _By;
                _Nextra = 0;
            } else if (_By < 0xc0u) { 
                ++_Mid1;
                return _Mybase::error;
            } else if (_By < 0xe0u) {
                _Ch     = _By & 0x1f;
                _Nextra = 1;
            } else if (_By < 0xf0u) {
                _Ch     = _By & 0x0f;
                _Nextra = 2;
            } else if (_By < 0xf8u) {
                _Ch     = _By & 0x07;
                _Nextra = 3;
            } else {
                _Ch     = _By & 0x03;
                _Nextra = _By < 0xfc ? 4 : 5;
            }

            if (_Nextra == 0) {
                ++_Mid1;
            } else if (_Last1 - _Mid1 < _Nextra + 1) {
                break; 
            } else {
                for (++_Mid1; 0 < _Nextra; --_Nextra, ++_Mid1) {
                    if ((_By = static_cast<unsigned char>(*_Mid1)) < 0x80u || 0xc0u <= _By) {
                        return _Mybase::error; 
                    } else {
                        _Ch = _Ch << 6 | (_By & 0x3f);
                    }
                }
            }

            if (*_Pstate == 0) { 
                *_Pstate = 1;

                constexpr bool _Consuming = (_Mymode & consume_header) != 0;
                if constexpr (_Consuming) {
                    if (_Ch == 0xfeff) { 
                        const result _Ans = do_in(_State, _Mid1, _Last1, _Mid1, _First2, _Last2, _Mid2);

                        if (_Ans == _Mybase::partial) { 
                            *_Pstate = 0;
                            _Mid1    = _First1;
                        }

                        return _Ans;
                    }
                }
            }

            if (_Mymax < _Ch) {
                return _Mybase::error; 
            }

            *_Mid2++ = static_cast<_Elem>(_Ch);
        }

        return _First1 == _Mid1 ? _Mybase::partial : _Mybase::ok;
    }

    result  do_out(_Statype& _State, const _Elem* _First1, const _Elem* _Last1, const _Elem*& _Mid1,
        _Byte* _First2, _Byte* _Last2, _Byte*& _Mid2) const override {
        
        char* _Pstate = reinterpret_cast<char*>(&_State);
        _Mid1         = _First1;
        _Mid2         = _First2;

        while (_Mid1 != _Last1 && _Mid2 != _Last2) { 
            _Byte _By;
            int _Nextra;
            unsigned long _Ch = static_cast<unsigned long>(*_Mid1);

            if (_Mymax < _Ch) {
                return _Mybase::error;
            }

            if (_Ch < 0x0080u) {
                _By     = static_cast<_Byte>(_Ch);
                _Nextra = 0;
            } else if (_Ch < 0x0800u) {
                _By     = static_cast<_Byte>(0xc0 | _Ch >> 6);
                _Nextra = 1;
            } else if (_Ch < 0x00010000u) {
                _By     = static_cast<_Byte>(0xe0 | _Ch >> 12);
                _Nextra = 2;
            } else if (_Ch < 0x00200000u) {
                _By     = static_cast<_Byte>(0xf0 | _Ch >> 18);
                _Nextra = 3;
            } else if (_Ch < 0x04000000u) {
                _By     = static_cast<_Byte>(0xf8 | _Ch >> 24);
                _Nextra = 4;
            } else {
                _By     = static_cast<_Byte>(0xfc | (_Ch >> 30 & 0x03));
                _Nextra = 5;
            }

            if (*_Pstate == 0) { 
                *_Pstate                   = 1;
                constexpr bool _Generating = (_Mymode & generate_header) != 0;
                if constexpr (_Generating) {
                    if (_Last2 - _Mid2 < 3 + 1 + _Nextra) {
                        return _Mybase::partial; 
                    }

                    
                    *_Mid2++ = '\xef';
                    *_Mid2++ = '\xbb';
                    *_Mid2++ = '\xbf';
                }
            }

            if (_Last2 - _Mid2 < 1 + _Nextra) {
                break; 
            }

            ++_Mid1;
            for (*_Mid2++ = _By; 0 < _Nextra;) {
                *_Mid2++ = static_cast<_Byte>((_Ch >> 6 * --_Nextra & 0x3f) | 0x80);
            }
        }

        return _First1 == _Mid1 ? _Mybase::partial : _Mybase::ok;
    }

    result  do_unshift(_Statype&, _Byte* _First2, _Byte*, _Byte*& _Mid2) const override {
        
        _Mid2 = _First2;
        return _Mybase::noconv;
    }

    friend int _Codecvt_do_length<>(const codecvt_utf8&, _Statype&, const _Byte*, const _Byte*, size_t);

    int  do_length(
        _Statype& _State, const _Byte* _First1, const _Byte* _Last1, size_t _Count) const noexcept override {
        return _Codecvt_do_length(*this, _State, _First1, _Last1, _Count);
    }

    bool  do_always_noconv() const noexcept override {
        
        return false;
    }

    int  do_max_length() const noexcept override {
        
        return (_Mymode & (consume_header | generate_header)) != 0 ? 9 : 6;
    }

    int  do_encoding() const noexcept override {
        
        return (_Mymode & (consume_header | generate_header)) != 0 ? -1
                                                                   : 0; 
    }
};

template <class _Elem, unsigned long _Mymax = 0x10ffff, codecvt_mode _Mymode = codecvt_mode{}>
class [[deprecated( "warning STL4017: " "std::wbuffer_convert, std::wstring_convert, and the <codecvt> header (containing std::codecvt_mode, " "std::codecvt_utf8, std::codecvt_utf16, and std::codecvt_utf8_utf16) are deprecated in C++17. " "(The std::codecvt class template is NOT deprecated.) " "The C++ Standard doesn't provide equivalent non-deprecated functionality; " "consider using MultiByteToWideChar() and WideCharToMultiByte() from <Windows.h> instead. " "You can define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] codecvt_utf16 : public codecvt<_Elem, char, _Statype> {
    
    enum { _Bytes_per_word = 2 };

public:
    using _Mybase     = codecvt<_Elem, char, _Statype>;
    using result      = typename _Mybase::result;
    using _Byte       = char;
    using intern_type = _Elem;
    using extern_type = _Byte;
    using state_type  = _Statype;

    explicit codecvt_utf16(size_t _Refs = 0) : _Mybase(_Refs) {}

     ~codecvt_utf16() noexcept override {}

protected:
    result  do_in(_Statype& _State, const _Byte* _First1, const _Byte* _Last1, const _Byte*& _Mid1,
        _Elem* _First2, _Elem* _Last2, _Elem*& _Mid2) const override {
        
        char* _Pstate = reinterpret_cast<char*>(&_State);
        _Mid1         = _First1;
        _Mid2         = _First2;

        while (_Bytes_per_word <= _Last1 - _Mid1 && _Mid2 != _Last2) { 
            const auto _Ptr = reinterpret_cast<const unsigned char*>(_Mid1);
            unsigned long _Ch;
            unsigned short _Ch0;
            unsigned short _Ch1;

            if (*_Pstate == _Little_first) {
                _Ch0 = static_cast<unsigned short>(_Ptr[1] << 8 | _Ptr[0]);
            } else if (*_Pstate == _Big_first) {
                _Ch0 = static_cast<unsigned short>(_Ptr[0] << 8 | _Ptr[1]);
            } else { 
                constexpr bool _Prefer_LE      = (_Mymode & little_endian) != 0;
                constexpr char _Default_endian = _Prefer_LE ? _Little_first : _Big_first;

                if constexpr (_Prefer_LE) {
                    _Ch0 = static_cast<unsigned short>(_Ptr[1] << 8 | _Ptr[0]);
                } else {
                    _Ch0 = static_cast<unsigned short>(_Ptr[0] << 8 | _Ptr[1]);
                }

                *_Pstate                  = _Default_endian;
                constexpr bool _Consuming = (_Mymode & consume_header) != 0;
                if constexpr (_Consuming) {
                    if (_Ch0 == 0xfffeu) {
                        *_Pstate = 3 - _Default_endian;
                    }

                    if (_Ch0 == 0xfffeu || _Ch0 == 0xfeffu) { 
                        _Mid1 += _Bytes_per_word;
                        result _Ans = do_in(_State, _Mid1, _Last1, _Mid1, _First2, _Last2, _Mid2);

                        if (_Ans == _Mybase::partial) { 
                            *_Pstate = 0;
                            _Mid1    = _First1;
                        }

                        return _Ans;
                    }
                }
            }

            if (_Ch0 < 0xd800u || 0xdc00u <= _Ch0) { 
                _Mid1 += _Bytes_per_word;
                _Ch = _Ch0;
            } else if (_Last1 - _Mid1 < 2 * _Bytes_per_word) {
                break;
            } else { 
                if (*_Pstate == _Little_first) {
                    _Ch1 = static_cast<unsigned short>(_Ptr[3] << 8 | _Ptr[2]);
                } else {
                    _Ch1 = static_cast<unsigned short>(_Ptr[2] << 8 | _Ptr[3]);
                }

                if (_Ch1 < 0xdc00u || 0xe000u <= _Ch1) {
                    return _Mybase::error;
                }

                _Mid1 += 2 * _Bytes_per_word;
                _Ch = static_cast<unsigned long>(_Ch0 - 0xd800 + 0x0040) << 10 | (_Ch1 - 0xdc00);
            }

            if (_Mymax < _Ch) {
                return _Mybase::error; 
            }

            *_Mid2++ = static_cast<_Elem>(_Ch);
        }

        return _First1 == _Mid1 ? _Mybase::partial : _Mybase::ok;
    }

    result  do_out(_Statype& _State, const _Elem* _First1, const _Elem* _Last1, const _Elem*& _Mid1,
        _Byte* _First2, _Byte* _Last2, _Byte*& _Mid2) const override {
        
        char* _Pstate = reinterpret_cast<char*>(&_State);
        _Mid1         = _First1;
        _Mid2         = _First2;

        if (*_Pstate == 0) { 
            *_Pstate                   = (_Mymode & little_endian) != 0 ? _Little_first : _Big_first;
            constexpr bool _Generating = (_Mymode & generate_header) != 0;
            if constexpr (_Generating) {
                if (_Last2 - _Mid2 < 3 * _Bytes_per_word) {
                    return _Mybase::partial; 
                }

                if (*_Pstate == _Little_first) { 
                    *_Mid2++ = '\xff';
                    *_Mid2++ = '\xfe';
                } else { 
                    *_Mid2++ = '\xfe';
                    *_Mid2++ = '\xff';
                }
            }
        }

        while (_Mid1 != _Last1 && _Bytes_per_word <= _Last2 - _Mid2) { 
            bool _Extra       = false;
            unsigned long _Ch = static_cast<unsigned long>(*_Mid1++);

            if ((_Mymax < 0x10ffffu ? _Mymax : 0x10ffffu) < _Ch) {
                return _Mybase::error; 
            }

            if (_Ch <= 0xffffu) { 
                if (0xd800u <= _Ch && _Ch < 0xdc00u) {
                    return _Mybase::error;
                }
            } else if (_Last2 - _Mid2 < 2 * _Bytes_per_word) { 
                --_Mid1;
                return _Mybase::partial;
            } else {
                _Extra = true;
            }

            if (*_Pstate == _Little_first) {
                if (_Extra) { 
                    unsigned short _Ch0 =
                        static_cast<unsigned short>(0xd800 | static_cast<unsigned short>(_Ch >> 10) - 0x0040);
                    *_Mid2++ = static_cast<_Byte>(_Ch0);
                    *_Mid2++ = static_cast<_Byte>(_Ch0 >> 8);

                    _Ch0     = static_cast<unsigned short>(0xdc00 | (static_cast<unsigned short>(_Ch) & 0x03ff));
                    *_Mid2++ = static_cast<_Byte>(_Ch0);
                    *_Mid2++ = static_cast<_Byte>(_Ch0 >> 8);
                } else { 
                    *_Mid2++ = static_cast<_Byte>(_Ch);
                    *_Mid2++ = static_cast<_Byte>(_Ch >> 8);
                }
            } else {
                if (_Extra) { 
                    unsigned short _Ch0 =
                        static_cast<unsigned short>(0xd800 | static_cast<unsigned short>(_Ch >> 10) - 0x0040);
                    *_Mid2++ = static_cast<_Byte>(_Ch0 >> 8);
                    *_Mid2++ = static_cast<_Byte>(_Ch0);

                    _Ch0     = static_cast<unsigned short>(0xdc00 | (static_cast<unsigned short>(_Ch) & 0x03ff));
                    *_Mid2++ = static_cast<_Byte>(_Ch0 >> 8);
                    *_Mid2++ = static_cast<_Byte>(_Ch0);
                } else { 
                    *_Mid2++ = static_cast<_Byte>(_Ch >> 8);
                    *_Mid2++ = static_cast<_Byte>(_Ch);
                }
            }
        }

        return _First1 == _Mid1 ? _Mybase::partial : _Mybase::ok;
    }

    result  do_unshift(_Statype&, _Byte* _First2, _Byte*, _Byte*& _Mid2) const override {
        
        _Mid2 = _First2;
        return _Mybase::noconv;
    }

    friend int _Codecvt_do_length<>(const codecvt_utf16&, _Statype&, const _Byte*, const _Byte*, size_t);

    int  do_length(
        _Statype& _State, const _Byte* _First1, const _Byte* _Last1, size_t _Count) const noexcept override {
        return _Codecvt_do_length(*this, _State, _First1, _Last1, _Count);
    }

    bool  do_always_noconv() const noexcept override {
        
        return false;
    }

    int  do_max_length() const noexcept override {
        
        return (_Mymode & (consume_header | generate_header)) != 0 ? 3 * _Bytes_per_word : 6 * _Bytes_per_word;
    }

    int  do_encoding() const noexcept override {
        
        if ((_Mymode & (consume_header | generate_header)) != 0) {
            return -1; 
        } else {
            return 0; 
        }
    }
};

template <class _Elem, unsigned long _Mymax = 0x10ffff, codecvt_mode _Mymode = codecvt_mode{}>
class [[deprecated( "warning STL4017: " "std::wbuffer_convert, std::wstring_convert, and the <codecvt> header (containing std::codecvt_mode, " "std::codecvt_utf8, std::codecvt_utf16, and std::codecvt_utf8_utf16) are deprecated in C++17. " "(The std::codecvt class template is NOT deprecated.) " "The C++ Standard doesn't provide equivalent non-deprecated functionality; " "consider using MultiByteToWideChar() and WideCharToMultiByte() from <Windows.h> instead. " "You can define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] codecvt_utf8_utf16
    : public codecvt<_Elem, char, _Statype> { 
public:
    using _Mybase     = codecvt<_Elem, char, _Statype>;
    using result      = typename _Mybase::result;
    using _Byte       = char;
    using intern_type = _Elem;
    using extern_type = _Byte;
    using state_type  = _Statype;

    static_assert(sizeof(unsigned short) <= sizeof(state_type), "state_type too small");

    explicit codecvt_utf8_utf16(size_t _Refs = 0) : _Mybase(_Refs) {}

     ~codecvt_utf8_utf16() noexcept override {}

protected:
    result  do_in(_Statype& _State, const _Byte* _First1, const _Byte* _Last1, const _Byte*& _Mid1,
        _Elem* _First2, _Elem* _Last2, _Elem*& _Mid2) const override {
        
        unsigned short* _Pstate = reinterpret_cast<unsigned short*>(&_State);
        _Mid1                   = _First1;
        _Mid2                   = _First2;

        while (_Mid1 != _Last1 && _Mid2 != _Last2) { 
            unsigned long _By = static_cast<unsigned char>(*_Mid1);
            unsigned long _Ch;
            int _Nextra;
            int _Nskip;

            if (*_Pstate > 1u) {
                if (_By < 0x80u || 0xc0u <= _By) {
                    return _Mybase::error; 
                }

                
                ++_Mid1;
                *_Mid2++ = static_cast<_Elem>(*_Pstate | (_By & 0x3f));
                *_Pstate = 1;
                continue;
            }

            if (_By < 0x80u) {
                _Ch     = _By;
                _Nextra = 0;
            } else if (_By < 0xc0u) { 
                ++_Mid1;
                return _Mybase::error;
            } else if (_By < 0xe0u) {
                _Ch     = _By & 0x1f;
                _Nextra = 1;
            } else if (_By < 0xf0u) {
                _Ch     = _By & 0x0f;
                _Nextra = 2;
            } else if (_By < 0xf8u) {
                _Ch     = _By & 0x07;
                _Nextra = 3;
            } else {
                _Ch     = _By & 0x03;
                _Nextra = _By < 0xfc ? 4 : 5;
            }

            _Nskip  = _Nextra < 3 ? 0 : 1; 
            _First1 = _Mid1; 

            if (_Nextra == 0) {
                ++_Mid1;
            } else if (_Last1 - _Mid1 < _Nextra + 1 - _Nskip) {
                break; 
            } else {
                for (++_Mid1; _Nskip < _Nextra; --_Nextra, ++_Mid1) {
                    if ((_By = static_cast<unsigned char>(*_Mid1)) < 0x80u || 0xc0u <= _By) {
                        return _Mybase::error; 
                    }

                    _Ch = _Ch << 6 | (_By & 0x3f);
                }
            }

            if (0 < _Nskip) {
                _Ch <<= 6; 
            }

            if ((_Mymax < 0x10ffffu ? _Mymax : 0x10ffffu) < _Ch) {
                return _Mybase::error; 
            }

            if (0xffffu < _Ch) { 
                unsigned short _Ch0 = static_cast<unsigned short>(0xd800 | (_Ch >> 10) - 0x0040);

                *_Mid2++ = static_cast<_Elem>(_Ch0);
                *_Pstate = static_cast<unsigned short>(0xdc00 | (_Ch & 0x03ff));
                continue;
            }

            if (_Nskip != 0) {
                if (_Mid1 == _Last1) { 
                    _Mid1 = _First1;
                    break;
                }

                if ((_By = static_cast<unsigned char>(*_Mid1++)) < 0x80u || 0xc0u <= _By) {
                    return _Mybase::error; 
                }

                _Ch |= _By & 0x3f; 
            }

            if (*_Pstate == 0u) { 
                *_Pstate = 1;

                constexpr bool _Consuming = (_Mymode & consume_header) != 0;
                if constexpr (_Consuming) {
                    if (_Ch == 0xfeffu) { 
                        result _Ans = do_in(_State, _Mid1, _Last1, _Mid1, _First2, _Last2, _Mid2);

                        if (_Ans == _Mybase::partial) { 
                            *_Pstate = 0;
                            _Mid1    = _First1;
                        }

                        return _Ans;
                    }
                }
            }

            *_Mid2++ = static_cast<_Elem>(_Ch);
        }

        return _First1 == _Mid1 ? _Mybase::partial : _Mybase::ok;
    }

    result  do_out(_Statype& _State, const _Elem* _First1, const _Elem* _Last1, const _Elem*& _Mid1,
        _Byte* _First2, _Byte* _Last2, _Byte*& _Mid2) const override {
        
        unsigned short* _Pstate = reinterpret_cast<unsigned short*>(&_State);
        _Mid1                   = _First1;
        _Mid2                   = _First2;

        while (_Mid1 != _Last1 && _Mid2 != _Last2) { 
            unsigned long _Ch;
            unsigned short _Ch1 = static_cast<unsigned short>(*_Mid1);
            bool _Save          = false;

            if (1u < *_Pstate) { 
                if (_Ch1 < 0xdc00u || 0xe000u <= _Ch1) {
                    return _Mybase::error; 
                }

                _Ch = static_cast<unsigned long>((*_Pstate << 10) | (_Ch1 - 0xdc00));
            } else if (0xd800u <= _Ch1 && _Ch1 < 0xdc00u) { 
                _Ch   = static_cast<unsigned long>((_Ch1 - 0xd800 + 0x0040) << 10);
                _Save = true; 
            } else {
                _Ch = _Ch1; 
            }

            _Byte _By;
            int _Nextra;

            if (_Ch < 0x0080u) {
                _By     = static_cast<_Byte>(_Ch);
                _Nextra = 0;
            } else if (_Ch < 0x0800u) {
                _By     = static_cast<_Byte>(0xc0 | _Ch >> 6);
                _Nextra = 1;
            } else if (_Ch < 0x10000u) {
                _By     = static_cast<_Byte>(0xe0 | _Ch >> 12);
                _Nextra = 2;
            } else {
                _By     = static_cast<_Byte>(0xf0 | _Ch >> 18);
                _Nextra = 3;
            }

            int _Nput = _Nextra < 3 ? _Nextra + 1 : _Save ? 1 : 3;

            if (_Last2 - _Mid2 < _Nput) {
                break; 
            }

            if (*_Pstate == 0u && (_Mymode & generate_header) != 0) { 
                if (_Last2 - _Mid2 < 3 + _Nput) {
                    break; 
                }

                
                *_Mid2++ = '\xef';
                *_Mid2++ = '\xbb';
                *_Mid2++ = '\xbf';
            }

            ++_Mid1;
            if (_Save || _Nextra < 3) { 
                *_Mid2++ = _By;
                --_Nput;
            }

            for (; 0 < _Nput; --_Nput) {
                *_Mid2++ = static_cast<_Byte>((_Ch >> 6 * --_Nextra & 0x3f) | 0x80);
            }

            *_Pstate = static_cast<unsigned short>(_Save ? _Ch >> 10 : 1);
        }

        return _First1 == _Mid1 ? _Mybase::partial : _Mybase::ok;
    }

    result  do_unshift(_Statype&, _Byte* _First2, _Byte*, _Byte*& _Mid2) const override {
        
        _Mid2 = _First2;
        return _Mybase::noconv;
    }

    friend int _Codecvt_do_length<>(const codecvt_utf8_utf16&, _Statype&, const _Byte*, const _Byte*, size_t);

    int  do_length(
        _Statype& _State, const _Byte* _First1, const _Byte* _Last1, size_t _Count) const noexcept override {
        return _Codecvt_do_length(*this, _State, _First1, _Last1, _Count);
    }

    bool  do_always_noconv() const noexcept override {
        
        return false;
    }

    int  do_max_length() const noexcept override {
        
        if ((_Mymode & consume_header) != 0) {
            return 9; 
        }

        if ((_Mymode & generate_header) != 0) {
            return 7; 
        }

        return 6; 
    }

    int  do_encoding() const noexcept override {
        
        return 0; 
    }
};
__pragma(warning(pop))
}


#pragma warning(pop)
#pragma pack(pop)
#line 674 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\codecvt"
#line 675 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\codecvt"
#line 83 "all-std.cxx"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {

namespace filesystem {
    class path;
}
#line 32 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"


#line 39 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"
#line 40 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"


namespace experimental {
    namespace filesystem {
        inline namespace v1 {
            class path;
        }
    } 
} 
#line 50 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"


template <class _Ty>
inline constexpr bool _Is_any_path = _Is_any_of_v<_Ty

    , experimental::filesystem::path
#line 57 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"

    , filesystem::path
#line 60 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"
    >;


extern  FILE* __cdecl _Fiopen(const char*, ios_base::openmode, int);
extern  FILE* __cdecl _Fiopen(const wchar_t*, ios_base::openmode, int);


extern  FILE* __cdecl _Fiopen(const unsigned short*, ios_base::openmode, int);
#line 69 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"

template <class _Elem>
bool _Fgetc(_Elem& _Ch, FILE* _File) { 
    return :: fread(&_Ch, sizeof(_Elem), 1, _File) == 1;
}

template <>
inline bool _Fgetc(char& _Byte, FILE* _File) { 
    int _Meta;
    if ((_Meta = :: fgetc(_File)) == (-1)) {
        return false;
    } else { 
        _Byte = static_cast<char>(_Meta);
        return true;
    }
}

template <>
inline bool _Fgetc(wchar_t& _Wchar, FILE* _File) { 
    wint_t _Meta;
    if ((_Meta = :: fgetwc(_File)) == ((wint_t)(0xFFFF))) {
        return false;
    } else { 
        _Wchar = static_cast<wchar_t>(_Meta);
        return true;
    }
}


template <>
inline bool _Fgetc(unsigned short& _Wchar, FILE* _File) { 
    wint_t _Meta;
    if ((_Meta = :: fgetwc(_File)) == ((wint_t)(0xFFFF))) {
        return false;
    } else { 
        _Wchar = static_cast<unsigned short>(_Meta);
        return true;
    }
}
#line 109 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"

template <class _Elem>
bool _Fputc(_Elem _Ch, FILE* _File) { 
    return :: fwrite(&_Ch, 1, sizeof(_Elem), _File) == sizeof(_Elem);
}

template <>
inline bool _Fputc(char _Byte, FILE* _File) { 
    return :: fputc(_Byte, _File) != (-1);
}

template <>
inline bool _Fputc(wchar_t _Wchar, FILE* _File) { 
    return :: fputwc(_Wchar, _File) != ((wint_t)(0xFFFF));
}


template <>
inline bool _Fputc(unsigned short _Wchar, FILE* _File) { 
    return :: fputwc(_Wchar, _File) != ((wint_t)(0xFFFF));
}
#line 131 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"

template <class _Elem>
bool _Ungetc(const _Elem&, FILE*) { 
    return false;
}

template <>
inline bool _Ungetc(const char& _Byte, FILE* _File) { 
    return :: ungetc(static_cast<unsigned char>(_Byte), _File) != (-1);
}

template <>
inline bool _Ungetc(const signed char& _Byte, FILE* _File) { 
    return :: ungetc(static_cast<unsigned char>(_Byte), _File) != (-1);
}

template <>
inline bool _Ungetc(const unsigned char& _Byte, FILE* _File) { 
    return :: ungetc(_Byte, _File) != (-1);
}

template <>
inline bool _Ungetc(const wchar_t& _Wchar, FILE* _File) { 
    return :: ungetwc(_Wchar, _File) != ((wint_t)(0xFFFF));
}


template <>
inline bool _Ungetc(const unsigned short& _Wchar, FILE* _File) { 
    return :: ungetwc(_Wchar, _File) != ((wint_t)(0xFFFF));
}
#line 163 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"

template <class _Elem, class _Traits>
class basic_filebuf : public basic_streambuf<_Elem, _Traits> { 
public:
    using _Mysb = basic_streambuf<_Elem, _Traits>;
    using _Cvt  = codecvt<_Elem, char, typename _Traits::state_type>;

    basic_filebuf() : _Mysb() {
        _Init(nullptr, _Newfl);
    }

    explicit basic_filebuf(FILE* const _File) : _Mysb() { 
        _Init(_File, _Newfl);
    }

     ~basic_filebuf() noexcept override {
        if (_Myfile) {
            _Reset_back(); 
        }

        if (_Closef) {
            close();
        }
    }

    using int_type = typename _Traits::int_type;
    using pos_type = typename _Traits::pos_type;
    using off_type = typename _Traits::off_type;

    basic_filebuf(_Uninitialized) : _Mysb(_Noinit) {}

    basic_filebuf(basic_filebuf&& _Right) {
        _Init(_Right._Myfile, _Newfl); 
        _Init(static_cast<FILE*>(nullptr), _Closefl); 
        _Assign_rv(::std:: move(_Right));
    }

    basic_filebuf& operator=(basic_filebuf&& _Right) {
        _Assign_rv(::std:: move(_Right));
        return *this;
    }

    void _Assign_rv(basic_filebuf&& _Right) {
        if (this != ::std:: addressof(_Right)) {
            close();
            this->swap(_Right);
        }
    }

    void swap(basic_filebuf& _Right) {
        if (this != ::std:: addressof(_Right)) {
            FILE* _Myfile_sav                       = _Myfile;
            const _Cvt* _Pcvt_sav                   = _Pcvt;
            typename _Traits::state_type _State_sav = _State;
            bool _Wrotesome_sav                     = _Wrotesome;
            bool _Closef_sav                        = _Closef;
            bool _Set_eback_sav                     = _Mysb::eback() == &_Mychar;
            bool _Set_eback_live                    = _Mysb::gptr() == &_Mychar;

            _Elem* _Pfirst0 = _Mysb::pbase();
            _Elem* _Pnext0  = _Mysb::pptr();
            _Elem* _Pend    = _Mysb::epptr();
            _Elem* _Gfirst0 = _Mysb::eback();
            _Elem* _Gnext0  = _Mysb::gptr();
            _Elem* _Gend    = _Mysb::egptr();

            
            _Init(_Right._Myfile, _Right._Myfile ? _Openfl : _Newfl);
            _Mysb::setp(_Right.pbase(), _Right.pptr(), _Right.epptr());
            if (_Right.eback() != &_Right._Mychar) {
                _Mysb::setg(_Right.eback(), _Right.gptr(), _Right.egptr());
            } else if (_Right.gptr() != &_Right._Mychar) {
                _Mysb::setg(&_Mychar, &_Mychar + 1, &_Mychar + 1);
            } else {
                _Mysb::setg(&_Mychar, &_Mychar, &_Mychar + 1);
            }

            _Pcvt      = _Right._Pcvt;
            _State     = _Right._State;
            _Wrotesome = _Right._Wrotesome;
            _Closef    = _Right._Closef;

            
            _Right._Init(_Myfile_sav, _Myfile_sav ? _Openfl : _Newfl);
            _Right.setp(_Pfirst0, _Pnext0, _Pend);
            if (!_Set_eback_sav) {
                _Right.setg(_Gfirst0, _Gnext0, _Gend);
            } else if (!_Set_eback_live) {
                _Right.setg(&_Right._Mychar, &_Right._Mychar + 1, &_Right._Mychar + 1);
            } else {
                _Right.setg(&_Right._Mychar, &_Right._Mychar, &_Right._Mychar + 1);
            }

            _Right._Pcvt      = _Pcvt_sav;
            _Right._State     = _State_sav;
            _Right._Wrotesome = _Wrotesome_sav;
            _Right._Closef    = _Closef_sav;

            
            ::std:: swap(_Set_eback, _Right._Set_eback);
            ::std:: swap(_Set_egptr, _Right._Set_egptr);

            ::std:: swap(_Mychar, _Right._Mychar);
            ::std:: swap(_Mysb::_Plocale, _Right._Plocale);
        }
    }

    basic_filebuf(const basic_filebuf&) = delete;
    basic_filebuf& operator=(const basic_filebuf&) = delete;

    enum _Initfl { 
        _Newfl,
        _Openfl,
        _Closefl
    };

    [[nodiscard]] bool is_open() const {
        return static_cast<bool>(_Myfile);
    }

    basic_filebuf* open(const char* _Filename, ios_base::openmode _Mode, int _Prot = ios_base::_Default_open_prot) {
        
        if (_Myfile) {
            return nullptr;
        }

        const auto _File = _Fiopen(_Filename, _Mode, _Prot);
        if (!_File) {
            return nullptr; 
        }

        _Init(_File, _Openfl);
        _Initcvt(::std:: use_facet<_Cvt>(_Mysb::getloc()));
        return this; 
    }

    basic_filebuf* open(const string& _Str, ios_base::openmode _Mode, int _Prot = ios_base::_Default_open_prot) {
        
        return open(_Str.c_str(), _Mode, _Prot);
    }


#line 309 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"

    basic_filebuf* open(const wchar_t* _Filename, ios_base::openmode _Mode, int _Prot = ios_base::_Default_open_prot) {
        
        if (_Myfile) {
            return nullptr;
        }

        const auto _File = _Fiopen(_Filename, _Mode, _Prot);
        if (!_File) {
            return nullptr; 
        }

        _Init(_File, _Openfl);
        _Initcvt(::std:: use_facet<_Cvt>(_Mysb::getloc()));
        return this; 
    }

    basic_filebuf* open(const wstring& _Str, ios_base::openmode _Mode, int _Prot = ios_base::_Default_open_prot) {
        
        return open(_Str.c_str(), _Mode, _Prot);
    }


    template <class _Path_ish = experimental::filesystem::path>
    basic_filebuf* open(
        const _Identity_t<_Path_ish>& _Path, ios_base::openmode _Mode, int _Prot = ios_base::_Default_open_prot) {
        
        return open(_Path.c_str(), _Mode, _Prot);
    }
#line 339 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"


    template <int = 0, class _Path_ish = filesystem::path>
    basic_filebuf* open(
        const _Identity_t<_Path_ish>& _Path, ios_base::openmode _Mode, int _Prot = ios_base::_Default_open_prot) {
        
        return open(_Path.c_str(), _Mode, _Prot);
    }
#line 348 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"


#line 355 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"


    basic_filebuf* open(
        const unsigned short* _Filename, ios_base::openmode _Mode, int _Prot = ios_base::_Default_open_prot) {
        
        if (_Myfile) {
            return nullptr;
        }

        const auto _File = _Fiopen(_Filename, _Mode, _Prot);
        if (!_File) {
            return nullptr; 
        }

        _Init(_File, _Openfl);
        _Initcvt(::std:: use_facet<_Cvt>(_Mysb::getloc()));
        return this; 
    }


#line 380 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"
#line 381 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"

    basic_filebuf* close() {
        basic_filebuf* _Ans;
        if (_Myfile) { 
            _Reset_back(); 

            _Ans = this;
            if (!_Endwrite()) {
                _Ans = nullptr;
            }

            if (:: fclose(_Myfile) != 0) {
                _Ans = nullptr;
            }
        } else {
            _Ans = nullptr;
        }

        _Init(nullptr, _Closefl);
        return _Ans;
    }

    void  _Lock() override { 
        if (_Myfile) {
            :: _lock_file(_Myfile);
        }
    }

    void  _Unlock() override { 
        if (_Myfile) {
            :: _unlock_file(_Myfile);
        }
    }

protected:
    int_type  overflow(int_type _Meta = _Traits::eof()) override { 
        if (_Traits::eq_int_type(_Traits::eof(), _Meta)) {
            return _Traits::not_eof(_Meta); 
        }

        if (_Mysb::pptr() && _Mysb::pptr() < _Mysb::epptr()) { 
            *_Mysb::_Pninc() = _Traits::to_char_type(_Meta);
            return _Meta;
        }

        if (!_Myfile) {
            return _Traits::eof(); 
        }

        _Reset_back(); 
        if (!_Pcvt) { 
            return _Fputc(_Traits::to_char_type(_Meta), _Myfile) ? _Meta : _Traits::eof();
        }

        
        constexpr size_t _Codecvt_temp_buf = 32;
        char _Str[_Codecvt_temp_buf];
        const _Elem _Ch = _Traits::to_char_type(_Meta);
        const _Elem* _Src;
        char* _Dest;

        
        switch (_Pcvt->out(_State, &_Ch, &_Ch + 1, _Src, _Str, _Str + _Codecvt_temp_buf, _Dest)) {
        case codecvt_base::partial:
        case codecvt_base::ok:
            { 
                const auto _Count = static_cast<size_t>(_Dest - _Str);
                if (0 < _Count && _Count != static_cast<size_t>(:: fwrite(_Str, 1, _Count, _Myfile))) {
                    return _Traits::eof(); 
                }

                _Wrotesome = true; 
                if (_Src != &_Ch) {
                    return _Meta; 
                }

                return _Traits::eof(); 
            }

        case codecvt_base::noconv:
            
            return _Fputc(_Ch, _Myfile) ? _Meta : _Traits::eof();

        default:
            return _Traits::eof(); 
        }
    }

    int_type  pbackfail(int_type _Meta = _Traits::eof()) override {
        
        if (_Mysb::gptr() && _Mysb::eback() < _Mysb::gptr()
            && (_Traits::eq_int_type(_Traits::eof(), _Meta)
                || _Traits::eq_int_type(_Traits::to_int_type(_Mysb::gptr()[-1]),
                    _Meta))) { 
            _Mysb::_Gndec();
            return _Traits::not_eof(_Meta);
        } else if (!_Myfile || _Traits::eq_int_type(_Traits::eof(), _Meta)) {
            return _Traits::eof(); 
        } else if (!_Pcvt && _Ungetc(_Traits::to_char_type(_Meta), _Myfile)) {
            return _Meta; 
        } else if (_Mysb::gptr() != &_Mychar) { 
            _Mychar = _Traits::to_char_type(_Meta);
            _Set_back(); 
            return _Meta;
        } else {
            return _Traits::eof(); 
        }
    }

    int_type  underflow() override { 
        int_type _Meta;
        if (_Mysb::gptr() && _Mysb::gptr() < _Mysb::egptr()) {
            return _Traits::to_int_type(*_Mysb::gptr()); 
        } else if (_Traits::eq_int_type(_Traits::eof(), _Meta = uflow())) {
            return _Meta; 
        } else { 
            pbackfail(_Meta);
            return _Meta;
        }
    }

    int_type  uflow() override { 
        if (_Mysb::gptr() && _Mysb::gptr() < _Mysb::egptr()) {
            return _Traits::to_int_type(*_Mysb::_Gninc()); 
        }

        if (!_Myfile) {
            return _Traits::eof(); 
        }

        _Reset_back(); 
        if (!_Pcvt) { 
            _Elem _Ch;
            return _Fgetc(_Ch, _Myfile) ? _Traits::to_int_type(_Ch) : _Traits::eof();
        }

        
        string _Str;

        for (;;) { 
            const char* _Src;
            int _Meta = :: fgetc(_Myfile);

            if (_Meta == (-1)) {
                return _Traits::eof(); 
            }

            _Str.push_back(static_cast<char>(_Meta)); 

            _Elem _Ch;
            _Elem* _Dest;

            
            switch (_Pcvt->in(_State, _Str.data(), _Str.data() + _Str.size(), _Src, &_Ch, &_Ch + 1, _Dest)) {
            case codecvt_base::partial:
            case codecvt_base::ok:
                if (_Dest != &_Ch) { 
                    auto _Nleft = _Str.data() + _Str.size() - _Src;
                    while (0 < _Nleft) {
                        :: ungetc(_Src[--_Nleft], _Myfile);
                    }

                    return _Traits::to_int_type(_Ch);
                }

                _Str.erase(0, static_cast<size_t>(_Src - _Str.data())); 
                break;

            case codecvt_base::noconv:
                
                return static_cast<int_type>(_Str.front());

            default:
                return _Traits::eof(); 
            }
        }
    }

#pragma warning(push)
#pragma warning(disable : 4127) 
    streamsize  xsgetn(_Elem* _Ptr, streamsize _Count) override {
        
        if constexpr (sizeof(_Elem) == 1) {
            if (_Count <= 0) {
                return 0;
            }

            if (_Pcvt) { 
                return _Mysb::xsgetn(_Ptr, _Count);
            }

            
            auto _Count_s           = static_cast<size_t>(_Count);
            const auto _Start_count = _Count;
            const auto _Available   = static_cast<size_t>(_Mysb::_Gnavail());
            if (0 < _Available) { 
                const auto _Read_size = (::std:: min)(_Count_s, _Available);
                _Traits::copy(_Ptr, _Mysb::gptr(), _Read_size);
                _Ptr += _Read_size;
                _Count_s -= _Read_size;
                _Mysb::gbump(static_cast<int>(_Read_size));
            }

            if (_Myfile) { 
                _Reset_back(); 
                
                
                constexpr size_t _Read_size = 4095; 
                while (_Read_size < _Count_s) {
                    const auto _Actual_read = :: fread(_Ptr, sizeof(_Elem), _Read_size, _Myfile);
                    _Ptr += _Actual_read;
                    _Count_s -= _Actual_read;
                    if (_Actual_read != _Read_size) {
                        return static_cast<streamsize>(_Start_count - _Count_s);
                    }
                }

                if (0 < _Count_s) {
                    _Count_s -= :: fread(_Ptr, sizeof(_Elem), _Count_s, _Myfile);
                }
            }

            return static_cast<streamsize>(_Start_count - _Count_s);
        } else { 
            return _Mysb::xsgetn(_Ptr, _Count);
        }
    }

    streamsize  xsputn(const _Elem* _Ptr, streamsize _Count) override {
        
        if constexpr (sizeof(_Elem) == 1) {
            if (_Pcvt) { 
                return _Mysb::xsputn(_Ptr, _Count);
            }

            const streamsize _Start_count = _Count;
            streamsize _Size              = _Mysb::_Pnavail();
            if (0 < _Count && 0 < _Size) { 
                if (_Count < _Size) {
                    _Size = _Count;
                }

                _Traits::copy(_Mysb::pptr(), _Ptr, static_cast<size_t>(_Size));
                _Ptr += _Size;
                _Count -= _Size;
                _Mysb::pbump(static_cast<int>(_Size));
            }

            if (0 < _Count && _Myfile) { 
                _Count -= :: fwrite(_Ptr, sizeof(_Elem), static_cast<size_t>(_Count), _Myfile);
            }

            return _Start_count - _Count;
        } else { 
            return _Mysb::xsputn(_Ptr, _Count);
        }
    }
#pragma warning(pop)

    pos_type  seekoff(off_type _Off, ios_base::seekdir _Way,
        ios_base::openmode = ios_base::in | ios_base::out) override { 
        fpos_t _Fileposition;

        if (_Mysb::gptr() == &_Mychar 
            && _Way == ios_base::cur 
            && !_Pcvt) { 
            _Off -= static_cast<off_type>(sizeof(_Elem)); 
        }

        if (!_Myfile || !_Endwrite()
            || ((_Off != 0 || _Way != ios_base::cur) && :: _fseeki64(_Myfile, _Off, _Way) != 0)
            || :: fgetpos(_Myfile, &_Fileposition) != 0) {
            return pos_type(-1); 
        }

        _Reset_back(); 
        return pos_type(_State, _Fileposition); 
    }

    pos_type  seekpos(pos_type _Pos, ios_base::openmode = ios_base::in | ios_base::out) override {
        
        off_type _Off = static_cast<off_type>(_Pos);

        if (!_Myfile || !_Endwrite() || :: fsetpos(_Myfile, &_Off) != 0) {
            return pos_type(-1); 
        }

        _State = _Pos.state();
        _Reset_back(); 
        return pos_type(_State, _Off); 
    }

    _Mysb*  setbuf(_Elem* _Buffer, streamsize _Count) override { 
        int _Mode;
        if (!_Buffer && _Count == 0) {
            _Mode = 0x0004;
        } else {
            _Mode = 0x0000;
        }

        const size_t _Size = static_cast<size_t>(_Count) * sizeof(_Elem);

        if (!_Myfile || :: setvbuf(_Myfile, reinterpret_cast<char*>(_Buffer), _Mode, _Size) != 0) {
            return nullptr; 
        }

        
        _Init(_Myfile, _Openfl);
        return this;
    }

    int  sync() override { 
        if (!_Myfile || _Traits::eq_int_type(_Traits::eof(), overflow()) || 0 <= :: fflush(_Myfile)) {
            return 0;
        }

        return -1;
    }

    void  imbue(const locale& _Loc) override {
        
        _Initcvt(::std:: use_facet<_Cvt>(_Loc));
    }

    void _Init(FILE* _File, _Initfl _Which) { 
        using _State_type = typename _Traits::state_type;

         static _State_type _Stinit; 

        _Closef    = _Which == _Openfl;
        _Wrotesome = false;

        _Mysb::_Init(); 

        if (_File && sizeof(_Elem) == 1) { 
            _Elem** _Pb = nullptr;
            _Elem** _Pn = nullptr;
            int* _Nr    = nullptr;

            ::_get_stream_buffer_pointers(
                _File, reinterpret_cast<char***>(&_Pb), reinterpret_cast<char***>(&_Pn), &_Nr);
            int* _Nw = _Nr;

            _Mysb::_Init(_Pb, _Pn, _Nr, _Pb, _Pn, _Nw);
        }

        _Myfile = _File;
        _State  = _Stinit;
        _Pcvt   = nullptr; 
    }

    bool _Endwrite() { 
        if (!_Pcvt || !_Wrotesome) {
            return true;
        }

        
        if (_Traits::eq_int_type(_Traits::eof(), overflow())) {
            return false;
        }

        constexpr size_t _Codecvt_temp_buf = 32;
        char _Str[_Codecvt_temp_buf];
        char* _Dest;
        switch (_Pcvt->unshift(_State, _Str, _Str + _Codecvt_temp_buf, _Dest)) { 
        case codecvt_base::ok:
            _Wrotesome = false; 

        case codecvt_base::partial: 
            { 
                const auto _Count = static_cast<size_t>(_Dest - _Str);
                if (0 < _Count && _Count != static_cast<size_t>(:: fwrite(_Str, 1, _Count, _Myfile))) {
                    return false; 
                }

                return !_Wrotesome;
            }

        case codecvt_base::noconv:
            _Wrotesome = false; 
            return true; 

        default:
            return false; 
        }
    }

    void _Initcvt(const _Cvt& _Newcvt) { 
        if (_Newcvt.always_noconv()) {
            _Pcvt = nullptr; 
        } else { 
            _Pcvt = ::std:: addressof(_Newcvt);
            _Mysb::_Init(); 
        }
    }

private:
    const _Cvt* _Pcvt; 
    _Elem _Mychar; 
    bool _Wrotesome; 
    typename _Traits::state_type _State; 
    bool _Closef; 
    FILE* _Myfile; 

    void _Reset_back() { 
        if (_Mysb::eback() == &_Mychar) {
            _Mysb::setg(_Set_eback, _Set_eback, _Set_egptr);
        }
    }

    void _Set_back() { 
        if (_Mysb::eback() != &_Mychar) { 
            _Set_eback = _Mysb::eback();
            _Set_egptr = _Mysb::egptr();
        }
        _Mysb::setg(&_Mychar, &_Mychar, &_Mychar + 1);
    }

    _Elem* _Set_eback; 
    _Elem* _Set_egptr; 
};

template <class _Elem, class _Traits>
void swap(basic_filebuf<_Elem, _Traits>& _Left, basic_filebuf<_Elem, _Traits>& _Right) {
    _Left.swap(_Right);
}

template <class _Elem, class _Traits>
class basic_ifstream : public basic_istream<_Elem, _Traits> { 
public:
    using _Mybase = basic_istream<_Elem, _Traits>;
    using _Myfb   = basic_filebuf<_Elem, _Traits>;
    using _Myios  = basic_ios<_Elem, _Traits>;

    basic_ifstream() : _Mybase(::std:: addressof(_Filebuffer)) {}

    explicit basic_ifstream(
        const char* _Filename, ios_base::openmode _Mode = ios_base::in, int _Prot = ios_base::_Default_open_prot)
        : _Mybase(::std:: addressof(_Filebuffer)) {
        
        if (!_Filebuffer.open(_Filename, _Mode | ios_base::in, _Prot)) {
            _Myios::setstate(ios_base::failbit);
        }
    }

    explicit basic_ifstream(
        const string& _Str, ios_base::openmode _Mode = ios_base::in, int _Prot = ios_base::_Default_open_prot)
        : basic_ifstream(_Str.c_str(), _Mode, _Prot) {} 

    explicit basic_ifstream(
        const wchar_t* _Filename, ios_base::openmode _Mode = ios_base::in, int _Prot = ios_base::_Default_open_prot)
        : _Mybase(::std:: addressof(_Filebuffer)) {
        
        if (!_Filebuffer.open(_Filename, _Mode | ios_base::in, _Prot)) {
            _Myios::setstate(ios_base::failbit);
        }
    }

    explicit basic_ifstream(
        const wstring& _Str, ios_base::openmode _Mode = ios_base::in, int _Prot = ios_base::_Default_open_prot)
        : basic_ifstream(_Str.c_str(), _Mode, _Prot) {} 

    template <class _Ty, enable_if_t<_Is_any_path<_Ty>, int> = 0>
    explicit basic_ifstream(
        const _Ty& _Path, ios_base::openmode _Mode = ios_base::in, int _Prot = ios_base::_Default_open_prot)
        : basic_ifstream(_Path.c_str(), _Mode, _Prot) {} 


    explicit basic_ifstream(const unsigned short* _Filename, ios_base::openmode _Mode = ios_base::in,
        int _Prot = ios_base::_Default_open_prot)
        : _Mybase(::std:: addressof(_Filebuffer)) {
        
        if (_Filebuffer.open(_Filename, _Mode | ios_base::in, _Prot) == 0) {
            _Myios::setstate(ios_base::failbit);
        }
    }
#line 858 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"

    explicit basic_ifstream(FILE* _File) : _Mybase(::std:: addressof(_Filebuffer)), _Filebuffer(_File) {} 

    basic_ifstream(basic_ifstream&& _Right) : _Mybase(::std:: addressof(_Filebuffer)) {
        _Assign_rv(::std:: move(_Right));
    }

    basic_ifstream& operator=(basic_ifstream&& _Right) {
        _Assign_rv(::std:: move(_Right));
        return *this;
    }

    void _Assign_rv(basic_ifstream&& _Right) {
        if (this != ::std:: addressof(_Right)) {
            _Filebuffer.close();
            this->swap(_Right);
        }
    }

    void swap(basic_ifstream& _Right) {
        if (this != ::std:: addressof(_Right)) {
            _Mybase::swap(_Right);
            _Filebuffer.swap(_Right._Filebuffer);
        }
    }

    basic_ifstream(const basic_ifstream&) = delete;
    basic_ifstream& operator=(const basic_ifstream&) = delete;

    void open(
        const wchar_t* _Filename, ios_base::openmode _Mode = ios_base::in, int _Prot = ios_base::_Default_open_prot) {
        
        if (_Filebuffer.open(_Filename, _Mode | ios_base::in, _Prot)) {
            _Myios::clear();
        } else {
            _Myios::setstate(ios_base::failbit);
        }
    }

    void open(const wstring& _Str, ios_base::openmode _Mode = ios_base::in, int _Prot = ios_base::_Default_open_prot) {
        
        open(_Str.c_str(), _Mode, _Prot);
    }


    template <class _Path_ish = experimental::filesystem::path>
    void open(const _Identity_t<_Path_ish>& _Path, ios_base::openmode _Mode = ios_base::in,
        int _Prot = ios_base::_Default_open_prot) {
        
        open(_Path.c_str(), _Mode, _Prot);
    }
#line 910 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"


    template <int = 0, class _Path_ish = filesystem::path>
    void open(const _Identity_t<_Path_ish>& _Path, ios_base::openmode _Mode = ios_base::in,
        int _Prot = ios_base::_Default_open_prot) {
        
        open(_Path.c_str(), _Mode, _Prot);
    }
#line 919 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"


#line 926 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"


    void open(const unsigned short* _Filename, ios_base::openmode _Mode = ios_base::in,
        int _Prot = ios_base::_Default_open_prot) {
        
        if (_Filebuffer.open(_Filename, _Mode | ios_base::in, _Prot) == 0) {
            _Myios::setstate(ios_base::failbit);
        } else {
            _Myios::clear();
        }
    }


#line 944 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"
#line 945 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"

     ~basic_ifstream() noexcept override {}

    [[nodiscard]] _Myfb* rdbuf() const {
        return const_cast<_Myfb*>(::std:: addressof(_Filebuffer));
    }

    [[nodiscard]] bool is_open() const {
        return _Filebuffer.is_open();
    }

    void open(
        const char* _Filename, ios_base::openmode _Mode = ios_base::in, int _Prot = ios_base::_Default_open_prot) {
        
        if (_Filebuffer.open(_Filename, _Mode | ios_base::in, _Prot)) {
            _Myios::clear();
        } else {
            _Myios::setstate(ios_base::failbit);
        }
    }

    void open(const string& _Str, ios_base::openmode _Mode = ios_base::in, int _Prot = ios_base::_Default_open_prot) {
        
        open(_Str.c_str(), _Mode, _Prot);
    }


#line 976 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"

    void close() {
        if (!_Filebuffer.close()) {
            _Myios::setstate(ios_base::failbit);
        }
    }

private:
    _Myfb _Filebuffer;
};

template <class _Elem, class _Traits>
void swap(basic_ifstream<_Elem, _Traits>& _Left, basic_ifstream<_Elem, _Traits>& _Right) {
    _Left.swap(_Right);
}

template <class _Elem, class _Traits>
class basic_ofstream : public basic_ostream<_Elem, _Traits> { 
public:
    using _Mybase = basic_ostream<_Elem, _Traits>;
    using _Myfb   = basic_filebuf<_Elem, _Traits>;
    using _Myios  = basic_ios<_Elem, _Traits>;

    basic_ofstream() : _Mybase(::std:: addressof(_Filebuffer)) {}

    explicit basic_ofstream(const char* _Filename, ios_base::openmode _Mode = ios_base::out,
        int _Prot = ios_base::_Default_open_prot)
        : _Mybase(::std:: addressof(_Filebuffer)) { 
        if (!_Filebuffer.open(_Filename, _Mode | ios_base::out, _Prot)) {
            _Myios::setstate(ios_base::failbit);
        }
    }

    explicit basic_ofstream(
        const string& _Str, ios_base::openmode _Mode = ios_base::out, int _Prot = ios_base::_Default_open_prot)
        : basic_ofstream(_Str.c_str(), _Mode, _Prot) {} 

    explicit basic_ofstream(
        const wchar_t* _Filename, ios_base::openmode _Mode = ios_base::out, int _Prot = ios_base::_Default_open_prot)
        : _Mybase(::std:: addressof(_Filebuffer)) {
        
        if (!_Filebuffer.open(_Filename, _Mode | ios_base::out, _Prot)) {
            _Myios::setstate(ios_base::failbit);
        }
    }

    explicit basic_ofstream(
        const wstring& _Str, ios_base::openmode _Mode = ios_base::out, int _Prot = ios_base::_Default_open_prot)
        : basic_ofstream(_Str.c_str(), _Mode, _Prot) {} 

    template <class _Ty, enable_if_t<_Is_any_path<_Ty>, int> = 0>
    explicit basic_ofstream(
        const _Ty& _Path, ios_base::openmode _Mode = ios_base::out, int _Prot = ios_base::_Default_open_prot)
        : basic_ofstream(_Path.c_str(), _Mode, _Prot) {} 


    explicit basic_ofstream(const unsigned short* _Filename, ios_base::openmode _Mode = ios_base::out,
        int _Prot = ios_base::_Default_open_prot)
        : _Mybase(::std:: addressof(_Filebuffer)) {
        
        if (_Filebuffer.open(_Filename, _Mode | ios_base::out, _Prot) == 0) {
            _Myios::setstate(ios_base::failbit);
        }
    }
#line 1041 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"

    explicit basic_ofstream(FILE* _File) : _Mybase(::std:: addressof(_Filebuffer)), _Filebuffer(_File) {} 

    basic_ofstream(basic_ofstream&& _Right) : _Mybase(::std:: addressof(_Filebuffer)) {
        _Assign_rv(::std:: move(_Right));
    }

    basic_ofstream& operator=(basic_ofstream&& _Right) {
        _Assign_rv(::std:: move(_Right));
        return *this;
    }

    void _Assign_rv(basic_ofstream&& _Right) {
        if (this != ::std:: addressof(_Right)) {
            _Filebuffer.close();
            this->swap(_Right);
        }
    }

    void swap(basic_ofstream& _Right) {
        if (this != ::std:: addressof(_Right)) {
            _Mybase::swap(_Right);
            _Filebuffer.swap(_Right._Filebuffer);
        }
    }

    basic_ofstream(const basic_ofstream&) = delete;
    basic_ofstream& operator=(const basic_ofstream&) = delete;

    void open(
        const wchar_t* _Filename, ios_base::openmode _Mode = ios_base::out, int _Prot = ios_base::_Default_open_prot) {
        
        if (_Filebuffer.open(_Filename, _Mode | ios_base::out, _Prot)) {
            _Myios::clear();
        } else {
            _Myios::setstate(ios_base::failbit);
        }
    }

    void open(const wstring& _Str, ios_base::openmode _Mode = ios_base::out, int _Prot = ios_base::_Default_open_prot) {
        
        open(_Str.c_str(), _Mode, _Prot);
    }


    template <class _Path_ish = experimental::filesystem::path>
    void open(const _Identity_t<_Path_ish>& _Path, ios_base::openmode _Mode = ios_base::out,
        int _Prot = ios_base::_Default_open_prot) {
        
        open(_Path.c_str(), _Mode, _Prot);
    }
#line 1093 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"


    template <int = 0, class _Path_ish = filesystem::path>
    void open(const _Identity_t<_Path_ish>& _Path, ios_base::openmode _Mode = ios_base::out,
        int _Prot = ios_base::_Default_open_prot) {
        
        open(_Path.c_str(), _Mode, _Prot);
    }
#line 1102 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"


#line 1109 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"


    void open(const unsigned short* _Filename, ios_base::openmode _Mode = ios_base::out,
        int _Prot = ios_base::_Default_open_prot) {
        
        if (_Filebuffer.open(_Filename, _Mode | ios_base::out, _Prot) == 0) {
            _Myios::setstate(ios_base::failbit);
        } else {
            _Myios::clear();
        }
    }


#line 1127 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"
#line 1128 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"

     ~basic_ofstream() noexcept override {}

    [[nodiscard]] _Myfb* rdbuf() const {
        return const_cast<_Myfb*>(::std:: addressof(_Filebuffer));
    }

    [[nodiscard]] bool is_open() const {
        return _Filebuffer.is_open();
    }

    void open(
        const char* _Filename, ios_base::openmode _Mode = ios_base::out, int _Prot = ios_base::_Default_open_prot) {
        
        if (_Filebuffer.open(_Filename, _Mode | ios_base::out, _Prot)) {
            _Myios::clear();
        } else {
            _Myios::setstate(ios_base::failbit);
        }
    }

    void open(const string& _Str, ios_base::openmode _Mode = ios_base::out, int _Prot = ios_base::_Default_open_prot) {
        
        open(_Str.c_str(), _Mode, _Prot);
    }


#line 1159 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"

    void close() {
        if (!_Filebuffer.close()) {
            _Myios::setstate(ios_base::failbit);
        }
    }

private:
    _Myfb _Filebuffer;
};

template <class _Elem, class _Traits>
void swap(basic_ofstream<_Elem, _Traits>& _Left, basic_ofstream<_Elem, _Traits>& _Right) {
    _Left.swap(_Right);
}

template <class _Elem, class _Traits>
class basic_fstream : public basic_iostream<_Elem, _Traits> { 
public:
    using _Mybase     = basic_iostream<_Elem, _Traits>;
    using _Myfb       = basic_filebuf<_Elem, _Traits>;
    using _Myios      = basic_ios<_Elem, _Traits>;
    using char_type   = _Elem;
    using traits_type = _Traits;
    using int_type    = typename _Traits::int_type;
    using pos_type    = typename _Traits::pos_type;
    using off_type    = typename _Traits::off_type;

    basic_fstream() : _Mybase(::std:: addressof(_Filebuffer)) {}

    explicit basic_fstream(const char* _Filename, ios_base::openmode _Mode = ios_base::in | ios_base::out,
        int _Prot = ios_base::_Default_open_prot)
        : _Mybase(::std:: addressof(_Filebuffer)) { 
        if (!_Filebuffer.open(_Filename, _Mode, _Prot)) {
            _Myios::setstate(ios_base::failbit);
        }
    }

    explicit basic_fstream(const string& _Str, ios_base::openmode _Mode = ios_base::in | ios_base::out,
        int _Prot = ios_base::_Default_open_prot)
        : basic_fstream(_Str.c_str(), _Mode, _Prot) {} 

    explicit basic_fstream(const wchar_t* _Filename, ios_base::openmode _Mode = ios_base::in | ios_base::out,
        int _Prot = ios_base::_Default_open_prot)
        : _Mybase(::std:: addressof(_Filebuffer)) {
        
        if (!_Filebuffer.open(_Filename, _Mode, _Prot)) {
            _Myios::setstate(ios_base::failbit);
        }
    }

    explicit basic_fstream(const wstring& _Str, ios_base::openmode _Mode = ios_base::in | ios_base::out,
        int _Prot = ios_base::_Default_open_prot)
        : basic_fstream(_Str.c_str(), _Mode, _Prot) {} 

    template <class _Ty, enable_if_t<_Is_any_path<_Ty>, int> = 0>
    explicit basic_fstream(const _Ty& _Path, ios_base::openmode _Mode = ios_base::in | ios_base::out,
        int _Prot = ios_base::_Default_open_prot)
        : basic_fstream(_Path.c_str(), _Mode, _Prot) {} 


    explicit basic_fstream(const unsigned short* _Filename, ios_base::openmode _Mode = ios_base::in | ios_base::out,
        int _Prot = ios_base::_Default_open_prot)
        : _Mybase(::std:: addressof(_Filebuffer)) {
        
        if (_Filebuffer.open(_Filename, _Mode, _Prot) == 0) {
            _Myios::setstate(ios_base::failbit);
        }
    }
#line 1229 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"

    explicit basic_fstream(FILE* _File) : _Mybase(::std:: addressof(_Filebuffer)), _Filebuffer(_File) {} 

    basic_fstream(basic_fstream&& _Right) : _Mybase(::std:: addressof(_Filebuffer)) {
        _Assign_rv(::std:: move(_Right));
    }

    basic_fstream& operator=(basic_fstream&& _Right) {
        _Assign_rv(::std:: move(_Right));
        return *this;
    }

    void _Assign_rv(basic_fstream&& _Right) {
        if (this != ::std:: addressof(_Right)) {
            _Filebuffer.close();
            this->swap(_Right);
        }
    }

    void swap(basic_fstream& _Right) {
        if (this != ::std:: addressof(_Right)) {
            _Mybase::swap(_Right);
            _Filebuffer.swap(_Right._Filebuffer);
        }
    }

    basic_fstream(const basic_fstream&) = delete;
    basic_fstream& operator=(const basic_fstream&) = delete;

    void open(const wchar_t* _Filename, ios_base::openmode _Mode = ios_base::in | ios_base::out,
        int _Prot = ios_base::_Default_open_prot) {
        
        if (_Filebuffer.open(_Filename, _Mode, _Prot)) {
            _Myios::clear();
        } else {
            _Myios::setstate(ios_base::failbit);
        }
    }

    void open(const wstring& _Str, ios_base::openmode _Mode = ios_base::in | ios_base::out,
        int _Prot = ios_base::_Default_open_prot) {
        
        open(_Str.c_str(), _Mode, _Prot);
    }


    template <class _Path_ish = experimental::filesystem::path>
    void open(const _Identity_t<_Path_ish>& _Path, ios_base::openmode _Mode = ios_base::in | ios_base::out,
        int _Prot = ios_base::_Default_open_prot) {
        
        open(_Path.c_str(), _Mode, _Prot);
    }
#line 1282 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"


    template <int = 0, class _Path_ish = filesystem::path>
    void open(const _Identity_t<_Path_ish>& _Path, ios_base::openmode _Mode = ios_base::in | ios_base::out,
        int _Prot = ios_base::_Default_open_prot) {
        
        open(_Path.c_str(), _Mode, _Prot);
    }
#line 1291 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"


#line 1298 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"


    void open(const unsigned short* _Filename, ios_base::openmode _Mode = ios_base::in | ios_base::out,
        int _Prot = ios_base::_Default_open_prot) {
        
        if (_Filebuffer.open(_Filename, _Mode, _Prot) == 0) {
            _Myios::setstate(ios_base::failbit);
        } else {
            _Myios::clear();
        }
    }


#line 1316 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"
#line 1317 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"

     ~basic_fstream() noexcept override {}

    [[nodiscard]] _Myfb* rdbuf() const {
        return const_cast<_Myfb*>(::std:: addressof(_Filebuffer));
    }

    [[nodiscard]] bool is_open() const {
        return _Filebuffer.is_open();
    }

    void open(const char* _Filename, ios_base::openmode _Mode = ios_base::in | ios_base::out,
        int _Prot = ios_base::_Default_open_prot) {
        
        if (_Filebuffer.open(_Filename, _Mode, _Prot)) {
            _Myios::clear();
        } else {
            _Myios::setstate(ios_base::failbit);
        }
    }

    void open(const string& _Str, ios_base::openmode _Mode = ios_base::in | ios_base::out,
        int _Prot = ios_base::_Default_open_prot) {
        
        open(_Str.c_str(), _Mode, _Prot);
    }


#line 1349 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"

    void close() {
        if (!_Filebuffer.close()) {
            _Myios::setstate(ios_base::failbit);
        }
    }

private:
    _Myfb _Filebuffer;
};

template <class _Elem, class _Traits>
void swap(basic_fstream<_Elem, _Traits>& _Left, basic_fstream<_Elem, _Traits>& _Right) {
    _Left.swap(_Right);
}
}


#pragma warning(pop)
#pragma pack(pop)
#line 1371 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"
#line 1372 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\fstream"
#line 86 "all-std.cxx"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iostream"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {


 extern  istream cin;
 extern  ostream cout;
 extern  ostream cerr;
 extern  ostream clog;
 extern  istream* _Ptr_cin;
 extern  ostream* _Ptr_cout;
 extern  ostream* _Ptr_cerr;
 extern  ostream* _Ptr_clog;

 extern  wistream wcin;
 extern  wostream wcout;
 extern  wostream wcerr;
 extern  wostream wclog;
 extern  wistream* _Ptr_wcin;
 extern  wostream* _Ptr_wcout;
 extern  wostream* _Ptr_wcerr;
 extern  wostream* _Ptr_wclog;

class  _Winit {
public:
    __thiscall _Winit();
    __thiscall ~_Winit() noexcept;

private:
     static int _Init_cnt;
};
#line 66 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iostream"
}


#pragma warning(pop)
#pragma pack(pop)
#line 72 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iostream"
#line 73 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iostream"
#line 90 "all-std.cxx"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\spanstream"


#pragma once


#line 14 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\spanstream"


#line 17 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\spanstream"


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {


template <class _Elem, class _Traits>
class basic_spanbuf : public basic_streambuf<_Elem, _Traits> {
private:
    using _Mysb = basic_streambuf<_Elem, _Traits>;

public:
    using char_type   = _Elem;
    using int_type    = typename _Traits::int_type;
    using pos_type    = typename _Traits::pos_type;
    using off_type    = typename _Traits::off_type;
    using traits_type = _Traits;

    
    basic_spanbuf() = default;

    explicit basic_spanbuf(ios_base::openmode _Which) : _Mysb(), _Mode(_Which) {}

    explicit basic_spanbuf(::std:: span<_Elem> _Span, ios_base::openmode _Which = ios_base::in | ios_base::out)
        : _Mysb(), _Mode(_Which), _Buf() {
        this->span(_Span);
    }

    basic_spanbuf(const basic_spanbuf&) = delete;
    basic_spanbuf(basic_spanbuf&& _Right)
        : _Mysb(::std:: move(_Right)), _Mode(::std:: move(_Right._Mode)), _Buf(::std:: exchange(_Right._Buf, {})) {
        _Right.setp(nullptr, nullptr, nullptr);
        _Right.setg(nullptr, nullptr, nullptr);
    }

    
    basic_spanbuf& operator=(const basic_spanbuf&) = delete;

    basic_spanbuf& operator=(basic_spanbuf&& _Right) {
        basic_spanbuf _Tmp{::std:: move(_Right)};
        this->swap(_Tmp);
        return *this;
    }

    void swap(basic_spanbuf& _Right) {
        _Mysb::swap(_Right);
        ::std:: swap(_Mode, _Right._Mode);
        ::std:: swap(_Buf, _Right._Buf);
    }

    
    [[nodiscard]] ::std:: span<_Elem> span() const noexcept {
        if (_Mode & ios_base::out) {
            return ::std:: span<_Elem>{_Mysb::pbase(), _Mysb::pptr()};
        }

        return _Buf;
    }

    void span(::std:: span<_Elem> _Span) noexcept {
        _Buf              = _Span;
        const auto _First = _Buf.data();
        const auto _Last  = _First + _Buf.size();
        if (_Mode & ios_base::out) {
            if (_Mode & ios_base::ate) {
                _Mysb::setp(_First, _Last, _Last);
            } else {
                _Mysb::setp(_First, _First, _Last);
            }
        }

        if (_Mode & ios_base::in) {
            _Mysb::setg(_First, _First, _Last);
        }
    }

protected:
    
    pos_type seekoff(
        off_type _Off, ios_base::seekdir _Way, ios_base::openmode _Which = ios_base::in | ios_base::out) override {
        const bool _Sequence_in  = _Which & ios_base::in;
        const bool _Sequence_out = _Which & ios_base::out;
        switch (_Way) {
        case ios_base::beg:
            
            if (static_cast<size_t>(_Off) > _Buf.size()) { 
                return pos_type(off_type(-1)); 
            }

            break;
        case ios_base::end:
            {
                
                const auto _Baseoff = (_Mode & ios_base::out) && !(_Mode & ios_base::in)
                                        ? static_cast<off_type>(_Mysb::pptr() - _Mysb::pbase())
                                        : static_cast<off_type>(_Buf.size());
                if (_Off > (numeric_limits<off_type>::max)() - _Baseoff) { 
                    return pos_type(off_type(-1)); 
                }

                _Off += _Baseoff;
                if (static_cast<size_t>(_Off) > _Buf.size()) { 
                    return pos_type(off_type(-1)); 
                }

                break;
            }
        case ios_base::cur:
            if (_Sequence_in && _Sequence_out) {
                return pos_type(off_type(-1)); 
            } else if (_Sequence_in || _Sequence_out) {
                const off_type _Oldoff  = _Sequence_in ? static_cast<off_type>(_Mysb::gptr() - _Mysb::eback())
                                                       : static_cast<off_type>(_Mysb::pptr() - _Mysb::pbase());
                const off_type _Oldleft = static_cast<off_type>(_Buf.size() - _Oldoff);
                if (_Off < -_Oldoff || _Off > _Oldleft) { 
                    return pos_type(off_type(-1));
                }

                _Off += _Oldoff;
            } else {
                return pos_type(off_type(-1)); 
            }
            break;
        default:
            return pos_type(off_type(-1)); 
        }

        
        if (_Off != 0 && ((_Sequence_in && !_Mysb::gptr()) || (_Sequence_out && !_Mysb::pptr()))) {
            return pos_type(off_type(-1)); 
        }

        if (_Sequence_in) {
            _Mysb::gbump(static_cast<int>(_Off - (_Mysb::gptr() - _Mysb::eback())));
        }

        if (_Sequence_out) {
            _Mysb::pbump(static_cast<int>(_Off - (_Mysb::pptr() - _Mysb::pbase())));
        }

        return pos_type(_Off);
    }

    pos_type seekpos(pos_type _Pos, ios_base::openmode _Which = ios_base::in | ios_base::out) override {
        return seekoff(off_type{_Pos}, ios_base::beg, _Which);
    }

    _Mysb* setbuf(_Elem* _Buffer, streamsize _Count) override {
        this->span(::std:: span<_Elem>{_Buffer, static_cast<size_t>(_Count)});
        return this;
    }

private:
    ios_base::openmode _Mode{ios_base::in | ios_base::out};
    ::std:: span<_Elem> _Buf{};
};

template <class _Elem, class _Traits>
void swap(basic_spanbuf<_Elem, _Traits>& _Left, basic_spanbuf<_Elem, _Traits>& _Right) {
    _Left.swap(_Right);
}

template <class _Elem, class _Traits>
class basic_ispanstream : public basic_istream<_Elem, _Traits> {
private:
    using _Mybase = basic_istream<_Elem, _Traits>;
    using _Mysb   = basic_spanbuf<_Elem, _Traits>;

public:
    using char_type   = _Elem;
    using int_type    = typename _Traits::int_type;
    using pos_type    = typename _Traits::pos_type;
    using off_type    = typename _Traits::off_type;
    using traits_type = _Traits;

    
    explicit basic_ispanstream(::std:: span<_Elem> _Span, ios_base::openmode _Which = ios_base::in)
        : _Mybase(::std:: addressof(_Buf)), _Buf(_Span, _Which | ios_base::in) {}

    basic_ispanstream(const basic_ispanstream&) = delete;

    basic_ispanstream(basic_ispanstream&& _Right) : _Mybase(::std:: move(_Right)), _Buf(::std:: move(_Right._Buf)) {
        _Mybase::set_rdbuf(::std:: addressof(_Buf));
    }


    template <::std::ranges:: borrowed_range _ReadOnlyRange>
        requires (!convertible_to<_ReadOnlyRange, ::std:: span<_Elem>>
                && convertible_to<_ReadOnlyRange, ::std:: span<const _Elem>>)
    explicit basic_ispanstream(_ReadOnlyRange&& _Range)
        : basic_ispanstream(
            ::std:: span<_Elem>{const_cast<_Elem*>(::std::ranges:: data(_Range)), static_cast<size_t>(::std::ranges:: size(_Range))}) {}
    
#line 225 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\spanstream"

    
    basic_ispanstream& operator=(const basic_ispanstream&) = delete;

    basic_ispanstream& operator=(basic_ispanstream&& _Right) {
        _Mybase::swap(_Right);
        _Buf.swap(_Right._Buf);
        return *this;
    }

    void swap(basic_ispanstream& _Right) {
        _Mybase::swap(_Right);
        _Buf.swap(_Right._Buf);
    }

    
    [[nodiscard]] _Mysb* rdbuf() const noexcept {
        return const_cast<_Mysb*>(::std:: addressof(_Buf));
    }

    [[nodiscard]] ::std:: span<const _Elem> span() const noexcept {
        return rdbuf()->span();
    }

    void span(::std:: span<_Elem> _Span) noexcept {
        rdbuf()->span(_Span);
    }


    template <::std::ranges:: borrowed_range _ReadOnlyRange>
        requires (!convertible_to<_ReadOnlyRange, ::std:: span<_Elem>>
                && convertible_to<_ReadOnlyRange, ::std:: span<const _Elem>>)
    void span(_ReadOnlyRange&& _Range) noexcept {
        this->span(
            ::std:: span<_Elem>{const_cast<_Elem*>(::std::ranges:: data(_Range)), static_cast<size_t>(::std::ranges:: size(_Range))});
    }
    
#line 264 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\spanstream"

private:
    _Mysb _Buf;
};

template <class _Elem, class _Traits>
void swap(basic_ispanstream<_Elem, _Traits>& _Left, basic_ispanstream<_Elem, _Traits>& _Right) {
    _Left.swap(_Right);
}

template <class _Elem, class _Traits>
class basic_ospanstream : public basic_ostream<_Elem, _Traits> {
private:
    using _Mybase = basic_ostream<_Elem, _Traits>;
    using _Mysb   = basic_spanbuf<_Elem, _Traits>;

public:
    using char_type   = _Elem;
    using int_type    = typename _Traits::int_type;
    using pos_type    = typename _Traits::pos_type;
    using off_type    = typename _Traits::off_type;
    using traits_type = _Traits;

    
    explicit basic_ospanstream(::std:: span<_Elem> _Span, ios_base::openmode _Which = ios_base::out)
        : _Mybase(::std:: addressof(_Buf)), _Buf(_Span, _Which | ios_base::out) {}

    basic_ospanstream(const basic_ospanstream&) = delete;

    basic_ospanstream(basic_ospanstream&& _Right) : _Mybase(::std:: move(_Right)), _Buf(::std:: move(_Right._Buf)) {
        _Mybase::set_rdbuf(::std:: addressof(_Buf));
    }

    
    basic_ospanstream& operator=(const basic_ospanstream&) = delete;

    basic_ospanstream& operator=(basic_ospanstream&& _Right) {
        _Mybase::swap(_Right);
        _Buf.swap(_Right._Buf);
        return *this;
    }

    void swap(basic_ospanstream& _Right) {
        _Mybase::swap(_Right);
        _Buf.swap(_Right._Buf);
    }

    
    [[nodiscard]] _Mysb* rdbuf() const noexcept {
        return const_cast<_Mysb*>(::std:: addressof(_Buf));
    }

    [[nodiscard]] ::std:: span<_Elem> span() const noexcept {
        return rdbuf()->span();
    }

    void span(::std:: span<_Elem> _Span) noexcept {
        rdbuf()->span(_Span);
    }

private:
    _Mysb _Buf;
};

template <class _Elem, class _Traits>
void swap(basic_ospanstream<_Elem, _Traits>& _Left, basic_ospanstream<_Elem, _Traits>& _Right) {
    _Left.swap(_Right);
}

template <class _Elem, class _Traits>
class basic_spanstream : public basic_iostream<_Elem, _Traits> {
private:
    using _Mybase = basic_iostream<_Elem, _Traits>;
    using _Mysb   = basic_spanbuf<_Elem, _Traits>;

public:
    using char_type   = _Elem;
    using int_type    = typename _Traits::int_type;
    using pos_type    = typename _Traits::pos_type;
    using off_type    = typename _Traits::off_type;
    using traits_type = _Traits;

    
    explicit basic_spanstream(::std:: span<_Elem> _Span, ios_base::openmode _Which = ios_base::out | ios_base::in)
        : _Mybase(::std:: addressof(_Buf)), _Buf(_Span, _Which) {}

    basic_spanstream(const basic_spanstream&) = delete;

    basic_spanstream(basic_spanstream&& _Right) : _Mybase(::std:: move(_Right)), _Buf(::std:: move(_Right._Buf)) {
        _Mybase::set_rdbuf(::std:: addressof(_Buf));
    }

    
    basic_spanstream& operator=(const basic_spanstream&) = delete;

    basic_spanstream& operator=(basic_spanstream&& _Right) {
        _Mybase::swap(_Right);
        _Buf.swap(_Right._Buf);
        return *this;
    }

    void swap(basic_spanstream& _Right) {
        _Mybase::swap(_Right);
        _Buf.swap(_Right._Buf);
    }

    
    [[nodiscard]] _Mysb* rdbuf() const noexcept {
        return const_cast<_Mysb*>(::std:: addressof(_Buf));
    }

    [[nodiscard]] ::std:: span<_Elem> span() const noexcept {
        return rdbuf()->span();
    }

    void span(::std:: span<_Elem> _Span) noexcept {
        rdbuf()->span(_Span);
    }

private:
    _Mysb _Buf;
};

template <class _Elem, class _Traits>
void swap(basic_spanstream<_Elem, _Traits>& _Left, basic_spanstream<_Elem, _Traits>& _Right) {
    _Left.swap(_Right);
}

}


#pragma warning(pop)
#pragma pack(pop)
#line 399 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\spanstream"
#line 400 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\spanstream"
#line 401 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\spanstream"
#line 93 "all-std.cxx"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\syncstream"


#pragma once


#line 14 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\syncstream"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\shared_mutex"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\condition_variable"


#pragma once


#line 18 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\condition_variable"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
template <class _Lock>
struct [[nodiscard]] _Unlock_guard {
    explicit _Unlock_guard(_Lock& _Mtx_) : _Mtx(_Mtx_) {
        _Mtx.unlock();
    }

    ~_Unlock_guard() noexcept  {
        
        
        _Mtx.lock();
    }

    _Unlock_guard(const _Unlock_guard&) = delete;
    _Unlock_guard& operator=(const _Unlock_guard&) = delete;

private:
    _Lock& _Mtx;
};

class condition_variable_any { 
public:
    condition_variable_any() : _Myptr{::std:: make_shared<mutex>()} {
        _Cnd_init_in_situ(_Mycnd());
    }

    ~condition_variable_any() noexcept {
        _Cnd_destroy_in_situ(_Mycnd());
    }

    condition_variable_any(const condition_variable_any&) = delete;
    condition_variable_any& operator=(const condition_variable_any&) = delete;

    void notify_one() noexcept { 
        lock_guard<mutex> _Guard{*_Myptr};
        _Cnd_signal(_Mycnd());
    }

    void notify_all() noexcept { 
        lock_guard<mutex> _Guard{*_Myptr};
        _Cnd_broadcast(_Mycnd());
    }

    template <class _Lock>
    void wait(_Lock& _Lck) noexcept  { 
        const shared_ptr<mutex> _Ptr = _Myptr; 
        unique_lock<mutex> _Guard{*_Ptr};
        _Unlock_guard<_Lock> _Unlock_outer{_Lck};
        _Cnd_wait(_Mycnd(), _Ptr->_Mymtx());
        _Guard.unlock();
    } 

    template <class _Lock, class _Predicate>
    void wait(_Lock& _Lck, _Predicate _Pred) noexcept(noexcept(static_cast<bool>(_Pred())))  {
        
        while (!static_cast<bool>(_Pred())) {
            wait(_Lck);
        }
    }

    template <class _Lock, class _Clock, class _Duration>
    cv_status wait_until(_Lock& _Lck, const chrono::time_point<_Clock, _Duration>& _Abs_time) {
        

        static_assert(chrono::is_clock_v<_Clock>, "Clock type required");
#line 98 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\condition_variable"
        return wait_for(_Lck, _Abs_time - _Clock::now());
    }

    template <class _Lock, class _Clock, class _Duration, class _Predicate>
    bool wait_until(_Lock& _Lck, const chrono::time_point<_Clock, _Duration>& _Abs_time, _Predicate _Pred) {
        

        static_assert(chrono::is_clock_v<_Clock>, "Clock type required");
#line 107 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\condition_variable"
        while (!_Pred()) {
            if (wait_until(_Lck, _Abs_time) == cv_status::timeout) {
                return _Pred();
            }
        }

        return true;
    }

    template <class _Lock, class _Rep, class _Period>
    cv_status wait_for(_Lock& _Lck, const chrono::duration<_Rep, _Period>& _Rel_time) { 
        if (_Rel_time <= chrono::duration<_Rep, _Period>::zero()) {
            _Unlock_guard<_Lock> _Unlock_outer{_Lck};
            (void) _Unlock_outer;
            return cv_status::timeout;
        }

        
        :: xtime _Tgt;
        const bool _Clamped     = _To_xtime_10_day_clamped(_Tgt, _Rel_time);
        const cv_status _Result = _Wait_until(_Lck, &_Tgt);
        if (_Clamped) {
            return cv_status::no_timeout;
        }

        return _Result;
    }

    template <class _Lock, class _Rep, class _Period, class _Predicate>
    bool wait_for(_Lock& _Lck, const chrono::duration<_Rep, _Period>& _Rel_time, _Predicate _Pred) {
        
        return wait_until(_Lck, _To_absolute_time(_Rel_time), ::std:: move(_Pred));
    }

    template <class _Lock>
    cv_status wait_until(_Lock& _Lck, const xtime* const _Abs_time) { 
        return _Wait_until(_Lck, _Abs_time);
    }

    template <class _Lock, class _Predicate>
    bool wait_until(_Lock& _Lck, const xtime* const _Abs_time, _Predicate _Pred) {
        
        while (!_Pred()) {
            if (_Wait_until(_Lck, _Abs_time) == cv_status::timeout) {
                return _Pred();
            }
        }
        return true;
    }


private:
    struct _Cv_any_notify_all {
        condition_variable_any* _This;

        explicit _Cv_any_notify_all(condition_variable_any* _This_) : _This{_This_} {}

        _Cv_any_notify_all(const _Cv_any_notify_all&) = delete;
        _Cv_any_notify_all& operator=(const _Cv_any_notify_all&) = delete;

        void operator()() const noexcept {
            _This->notify_all();
        }
    };

public:
    template <class _Lock, class _Predicate>
    bool wait(_Lock& _Lck, stop_token _Stoken, _Predicate _Pred) noexcept(
        noexcept(static_cast<bool>(_Pred())))  {
        
        
        stop_callback<_Cv_any_notify_all> _Cb{_Stoken, this};
        for (;;) {
            if (_Pred()) {
                return true;
            }

            unique_lock<mutex> _Guard{*_Myptr};
            if (_Stoken.stop_requested()) {
                _Guard.unlock();
                return _Pred();
            }

            _Unlock_guard<_Lock> _Unlock_outer{_Lck};
            _Cnd_wait(_Mycnd(), _Myptr->_Mymtx());
            _Guard.unlock();
        } 
    }

    template <class _Lock, class _Clock, class _Duration, class _Predicate>
    bool wait_until(
        _Lock& _Lck, stop_token _Stoken, const chrono::time_point<_Clock, _Duration>& _Abs_time, _Predicate _Pred) {
        static_assert(chrono::is_clock_v<_Clock>, "Clock type required");
        stop_callback<_Cv_any_notify_all> _Cb{_Stoken, this};
        for (;;) {
            if (_Pred()) {
                return true;
            }

            unique_lock<mutex> _Guard{*_Myptr};
            if (_Stoken.stop_requested()) {
                break;
            }

            _Unlock_guard<_Lock> _Unlock_outer{_Lck};
            unique_lock<mutex> _Guard_unlocks_before_locking_outer{::std:: move(_Guard)};

            const auto _Now = _Clock::now();
            if (_Now >= _Abs_time) {
                break;
            }

            const auto _Rel_time = _Abs_time - _Now;
            
            
            :: xtime _Tgt;
            (void) _To_xtime_10_day_clamped(_Tgt, _Rel_time);
            const int _Res = _Cnd_timedwait(_Mycnd(), _Myptr->_Mymtx(), &_Tgt);
            _Guard_unlocks_before_locking_outer.unlock();

            switch (_Res) {
            case _Thrd_timedout:
            case _Thrd_success:
                break;
            default:
                _Throw_C_error(_Res);
            }
        } 

        return _Pred();
    }

    template <class _Lock, class _Rep, class _Period, class _Predicate>
    bool wait_for(_Lock& _Lck, stop_token _Stoken, const chrono::duration<_Rep, _Period>& _Rel_time, _Predicate _Pred) {
        return wait_until(_Lck, ::std:: move(_Stoken), _To_absolute_time(_Rel_time), ::std:: move(_Pred));
    }
#line 247 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\condition_variable"

private:
    shared_ptr<mutex> _Myptr;

    aligned_storage_t<_Cnd_internal_imp_size, _Cnd_internal_imp_alignment> _Cnd_storage;

    [[nodiscard]] _Cnd_t _Mycnd() noexcept { 
        return reinterpret_cast<_Cnd_t>(&_Cnd_storage);
    }

    template <class _Lock>
    cv_status _Wait_until(_Lock& _Lck, const xtime* const _Abs_time) { 
        const shared_ptr<mutex> _Ptr = _Myptr; 
        unique_lock<mutex> _Guard{*_Ptr};
        _Unlock_guard<_Lock> _Unlock_outer{_Lck};
        const int _Res = _Cnd_timedwait(_Mycnd(), _Ptr->_Mymtx(), _Abs_time);
        _Guard.unlock();

        switch (_Res) {
        case _Thrd_success:
            return cv_status::no_timeout;
        case _Thrd_timedout:
            return cv_status::timeout;
        default:
            _Throw_C_error(_Res);
        }
    }
};

inline void notify_all_at_thread_exit(condition_variable& _Cnd, unique_lock<mutex> _Lck) {
    
    _Cnd._Register(_Lck, nullptr);
}
}


#pragma warning(pop)
#pragma pack(pop)
#line 286 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\condition_variable"
#line 287 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\condition_variable"
#line 20 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\shared_mutex"
#line 21 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\shared_mutex"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
class shared_mutex { 
public:
    using native_handle_type = _Smtx_t*;

    shared_mutex() noexcept 
        : _Myhandle(nullptr) {}

    ~shared_mutex() noexcept {}

    void lock() noexcept  { 
        _Smtx_lock_exclusive(&_Myhandle);
    }

    [[nodiscard]] bool try_lock() noexcept  { 
        return _Smtx_try_lock_exclusive(&_Myhandle) != 0;
    }

    void unlock() noexcept  { 
        _Smtx_unlock_exclusive(&_Myhandle);
    }

    void lock_shared() noexcept  { 
        _Smtx_lock_shared(&_Myhandle);
    }

    [[nodiscard]] bool try_lock_shared() noexcept  { 
        return _Smtx_try_lock_shared(&_Myhandle) != 0;
    }

    void unlock_shared() noexcept  { 
        _Smtx_unlock_shared(&_Myhandle);
    }

    [[nodiscard]] native_handle_type native_handle() noexcept  { 
        return &_Myhandle;
    }

    shared_mutex(const shared_mutex&) = delete;
    shared_mutex& operator=(const shared_mutex&) = delete;

private:
    _Smtx_t _Myhandle;
};


class shared_timed_mutex { 
    using _Read_cnt_t = unsigned int;

    static constexpr _Read_cnt_t _Max_readers = static_cast<_Read_cnt_t>(-1);

public:
    shared_timed_mutex() noexcept 
        : _Mymtx(), _Read_queue(), _Write_queue(), _Readers(0), _Writing(false) {}

    ~shared_timed_mutex() noexcept {}

    void lock() { 
        unique_lock<mutex> _Lock(_Mymtx);
        while (_Writing) {
            _Write_queue.wait(_Lock);
        }

        _Writing = true;
        while (0 < _Readers) {
            _Read_queue.wait(_Lock); 
        }
    }

    [[nodiscard]] bool try_lock() { 
        lock_guard<mutex> _Lock(_Mymtx);
        if (_Writing || 0 < _Readers) {
            return false;
        } else { 
            _Writing = true;
            return true;
        }
    }

    template <class _Rep, class _Period>
    [[nodiscard]] bool try_lock_for(const chrono::duration<_Rep, _Period>& _Rel_time) { 
        return try_lock_until(_To_absolute_time(_Rel_time));
    }

    template <class _Clock, class _Duration>
    [[nodiscard]] bool try_lock_until(const chrono::time_point<_Clock, _Duration>& _Abs_time) {
        

        static_assert(chrono::is_clock_v<_Clock>, "Clock type required");
#line 120 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\shared_mutex"
        auto _Not_writing  = [this] { return !_Writing; };
        auto _Zero_readers = [this] { return _Readers == 0; };
        unique_lock<mutex> _Lock(_Mymtx);

        if (!_Write_queue.wait_until(_Lock, _Abs_time, _Not_writing)) {
            return false;
        }

        _Writing = true;

        if (!_Read_queue.wait_until(_Lock, _Abs_time, _Zero_readers)) { 
            _Writing = false;
            _Lock.unlock(); 
            _Write_queue.notify_all();
            return false;
        }

        return true;
    }

    void unlock() { 
        { 
            lock_guard<mutex> _Lock(_Mymtx);

            _Writing = false;
        }

        _Write_queue.notify_all();
    }

    void lock_shared() { 
        unique_lock<mutex> _Lock(_Mymtx);
        while (_Writing || _Readers == _Max_readers) {
            _Write_queue.wait(_Lock);
        }

        ++_Readers;
    }

    [[nodiscard]] bool try_lock_shared() { 
        lock_guard<mutex> _Lock(_Mymtx);
        if (_Writing || _Readers == _Max_readers) {
            return false;
        } else { 
            ++_Readers;
            return true;
        }
    }

    template <class _Rep, class _Period>
    [[nodiscard]] bool try_lock_shared_for(const chrono::duration<_Rep, _Period>& _Rel_time) {
        
        return try_lock_shared_until(_To_absolute_time(_Rel_time));
    }

    template <class _Time>
    bool _Try_lock_shared_until(_Time _Abs_time) { 
        const auto _Can_acquire = [this] { return !_Writing && _Readers < _Max_readers; };

        unique_lock<mutex> _Lock(_Mymtx);

        if (!_Write_queue.wait_until(_Lock, _Abs_time, _Can_acquire)) {
            return false;
        }

        ++_Readers;
        return true;
    }

    template <class _Clock, class _Duration>
    [[nodiscard]] bool try_lock_shared_until(const chrono::time_point<_Clock, _Duration>& _Abs_time) {
        

        static_assert(chrono::is_clock_v<_Clock>, "Clock type required");
#line 195 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\shared_mutex"
        return _Try_lock_shared_until(_Abs_time);
    }

    [[nodiscard]] bool try_lock_shared_until(const xtime* _Abs_time) { 
        return _Try_lock_shared_until(_Abs_time);
    }

    void unlock_shared() { 
        _Read_cnt_t _Local_readers;
        bool _Local_writing;

        { 
            lock_guard<mutex> _Lock(_Mymtx);
            --_Readers;
            _Local_readers = _Readers;
            _Local_writing = _Writing;
        }

        if (_Local_writing && _Local_readers == 0) {
            _Read_queue.notify_one();
        } else if (!_Local_writing && _Local_readers == _Max_readers - 1) {
            _Write_queue.notify_all();
        }
    }

    shared_timed_mutex(const shared_timed_mutex&) = delete;
    shared_timed_mutex& operator=(const shared_timed_mutex&) = delete;

private:
    mutex _Mymtx;
    condition_variable _Read_queue;
    condition_variable _Write_queue;
    _Read_cnt_t _Readers;
    bool _Writing;
};
#line 231 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\shared_mutex"

template <class _Mutex>
class shared_lock { 
public:
    using mutex_type = _Mutex;

    shared_lock() noexcept : _Pmtx(nullptr), _Owns(false) {}

    [[nodiscard]] explicit shared_lock(mutex_type& _Mtx)
        : _Pmtx(::std:: addressof(_Mtx)), _Owns(true) { 
        _Mtx.lock_shared();
    }

    shared_lock(mutex_type& _Mtx, defer_lock_t) noexcept
        : _Pmtx(::std:: addressof(_Mtx)), _Owns(false) {} 

    [[nodiscard]] shared_lock(mutex_type& _Mtx, try_to_lock_t)
        : _Pmtx(::std:: addressof(_Mtx)), _Owns(_Mtx.try_lock_shared()) {} 

    [[nodiscard]] shared_lock(mutex_type& _Mtx, adopt_lock_t)
        : _Pmtx(::std:: addressof(_Mtx)), _Owns(true) {} 

    template <class _Rep, class _Period>
    [[nodiscard]] shared_lock(mutex_type& _Mtx, const chrono::duration<_Rep, _Period>& _Rel_time)
        : _Pmtx(::std:: addressof(_Mtx)), _Owns(_Mtx.try_lock_shared_for(_Rel_time)) {
        
    }

    template <class _Clock, class _Duration>
    [[nodiscard]] shared_lock(mutex_type& _Mtx, const chrono::time_point<_Clock, _Duration>& _Abs_time)
        : _Pmtx(::std:: addressof(_Mtx)), _Owns(_Mtx.try_lock_shared_until(_Abs_time)) {
        

        static_assert(chrono::is_clock_v<_Clock>, "Clock type required");
#line 266 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\shared_mutex"
    }

    ~shared_lock() noexcept {
        if (_Owns) {
            _Pmtx->unlock_shared();
        }
    }

    [[nodiscard]] shared_lock(shared_lock&& _Other) noexcept : _Pmtx(_Other._Pmtx), _Owns(_Other._Owns) {
        _Other._Pmtx = nullptr;
        _Other._Owns = false;
    }

    shared_lock& operator=(shared_lock&& _Right) noexcept {
        if (_Owns) {
            _Pmtx->unlock_shared();
        }

        _Pmtx        = _Right._Pmtx;
        _Owns        = _Right._Owns;
        _Right._Pmtx = nullptr;
        _Right._Owns = false;
        return *this;
    }

    shared_lock(const shared_lock&) = delete;
    shared_lock& operator=(const shared_lock&) = delete;

    void lock() { 
        _Validate();
        _Pmtx->lock_shared();
        _Owns = true;
    }

    [[nodiscard]] bool try_lock() { 
        _Validate();
        _Owns = _Pmtx->try_lock_shared();
        return _Owns;
    }

    template <class _Rep, class _Period>
    [[nodiscard]] bool try_lock_for(const chrono::duration<_Rep, _Period>& _Rel_time) {
        
        _Validate();
        _Owns = _Pmtx->try_lock_shared_for(_Rel_time);
        return _Owns;
    }

    template <class _Clock, class _Duration>
    [[nodiscard]] bool try_lock_until(const chrono::time_point<_Clock, _Duration>& _Abs_time) {
        

        static_assert(chrono::is_clock_v<_Clock>, "Clock type required");
#line 320 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\shared_mutex"
        _Validate();
        _Owns = _Pmtx->try_lock_shared_until(_Abs_time);
        return _Owns;
    }

    void unlock() { 
        if (!_Pmtx || !_Owns) {
            _Throw_system_error(errc::operation_not_permitted);
        }

        _Pmtx->unlock_shared();
        _Owns = false;
    }

    void swap(shared_lock& _Right) noexcept {
        ::std:: swap(_Pmtx, _Right._Pmtx);
        ::std:: swap(_Owns, _Right._Owns);
    }

    mutex_type* release() noexcept {
        _Mutex* _Res = _Pmtx;
        _Pmtx        = nullptr;
        _Owns        = false;
        return _Res;
    }

    [[nodiscard]] bool owns_lock() const noexcept {
        return _Owns;
    }

    explicit operator bool() const noexcept {
        return _Owns;
    }

    [[nodiscard]] mutex_type* mutex() const noexcept {
        return _Pmtx;
    }

private:
    _Mutex* _Pmtx;
    bool _Owns;

    void _Validate() const { 
        if (!_Pmtx) {
            _Throw_system_error(errc::operation_not_permitted);
        }

        if (_Owns) {
            _Throw_system_error(errc::resource_deadlock_would_occur);
        }
    }
};

template <class _Mutex>
void swap(shared_lock<_Mutex>& _Left, shared_lock<_Mutex>& _Right) noexcept {
    _Left.swap(_Right);
}
}


#pragma warning(pop)
#pragma pack(pop)
#line 383 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\shared_mutex"
#line 384 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\shared_mutex"
#line 17 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\syncstream"


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


extern "C" {
[[nodiscard]] ::std:: shared_mutex* __stdcall __std_acquire_shared_mutex_for_instance(void* _Ptr) noexcept;
void __stdcall __std_release_shared_mutex_for_instance(void* _Ptr) noexcept;
}

namespace std {

template <class _Elem, class _Traits>
class _Basic_syncbuf_impl : public basic_streambuf<_Elem, _Traits> {
public:
    void set_emit_on_sync(const bool _Val) noexcept {
        _Emit_on_sync = _Val;
    }

    virtual bool _Do_emit() = 0;


protected:
    using _Mysb = basic_streambuf<_Elem, _Traits>;

    _Basic_syncbuf_impl() = default;

    _Basic_syncbuf_impl(_Basic_syncbuf_impl&& _Right) {
        _Swap(_Right);
    }

    void _Swap(_Basic_syncbuf_impl& _Right) {
        _Mysb::swap(_Right);
        ::std:: swap(_Emit_on_sync, _Right._Emit_on_sync);
        ::std:: swap(_Sync_recorded, _Right._Sync_recorded);
    }

    bool _Emit_on_sync{false};
    bool _Sync_recorded{false};
};

template <class _Elem, class _Traits, class _Alloc>
class basic_syncbuf : public _Basic_syncbuf_impl<_Elem, _Traits> {
public:
    using int_type       = typename _Traits::int_type;
    using pos_type       = typename _Traits::pos_type;
    using off_type       = typename _Traits::off_type;
    using allocator_type = _Alloc;
    using streambuf_type = basic_streambuf<_Elem, _Traits>;

    using _Mybase    = _Basic_syncbuf_impl<_Elem, _Traits>;
    using _Pointer   = typename allocator_traits<_Alloc>::pointer;
    using _Size_type = typename allocator_traits<_Alloc>::size_type;

    using _Mybase::set_emit_on_sync;

    basic_syncbuf() = default;

    explicit basic_syncbuf(streambuf_type* _Strbuf) : basic_syncbuf(_Strbuf, _Alloc{}) {}

    basic_syncbuf(streambuf_type* _Strbuf, const _Alloc& _Al_)
        : _Wrapped(_Strbuf), _Mypair{_One_then_variadic_args_t{}, _Al_, nullptr} {
        if (_Wrapped) {
            auto& _Mutex = _Get_mutex();
            _Mutex       = __std_acquire_shared_mutex_for_instance(_Wrapped);
            if (!_Mutex) {
                _Xbad_alloc();
            }
        }
        _Init();
    }

    basic_syncbuf(basic_syncbuf&& _Right) : _Mypair{_One_then_variadic_args_t{}, ::std:: move(_Right._Getal()), nullptr} {
        _Swap_except_al(_Right);
    }

    ~basic_syncbuf() {
        _Emit();
        _Tidy();
    }

    basic_syncbuf& operator=(basic_syncbuf&& _Right) {
        emit();

        if (this == ::std:: addressof(_Right)) {
            return *this;
        }

        auto& _Al                 = _Getal();
        auto& _Right_al           = _Right._Getal();
        constexpr auto _Pocma_val = _Choose_pocma_v<_Alloc>;
        if constexpr (_Pocma_val == _Pocma_values::_No_propagate_allocators) {
            if (_Al != _Right_al) {
                _Tidy();

                const _Size_type _Right_buf_size  = _Right._Get_buffer_size();
                const _Size_type _Right_data_size = _Right._Get_data_size();

                _Elem* const _New_ptr = _Unfancy(_Al.allocate(_Right_buf_size));
                _Traits::copy(_New_ptr, _Right.pbase(), _Right_data_size);

                streambuf_type::setp(_New_ptr, _New_ptr + _Right_data_size, _New_ptr + _Right_buf_size);
                ::std:: swap(streambuf_type::_Plocale, _Right._Plocale);

                ::std:: swap(_Mybase::_Emit_on_sync, _Right._Emit_on_sync);
                ::std:: swap(_Mybase::_Sync_recorded, _Right._Sync_recorded);
                ::std:: swap(_Wrapped, _Right._Wrapped);
                ::std:: swap(_Get_mutex(), _Right._Get_mutex());

                _Right._Tidy();
                return *this;
            }
        }

        _Tidy();
        _Pocma(_Al, _Right_al);
        _Swap_except_al(_Right);
        return *this;
    }

    void swap(basic_syncbuf& _Right) {
        if (this != ::std:: addressof(_Right)) {
            _Pocs(_Getal(), _Right._Getal());
            _Swap_except_al(_Right);
        }
    }

    bool emit() {
        if (!_Wrapped) {
            return false;
        }

        bool _Result                = true;
        const _Size_type _Data_size = _Get_data_size();
        _Elem* const _Begin_seq_ptr = streambuf_type::pbase();
        if (_Data_size > 0 || _Mybase::_Sync_recorded) {
            scoped_lock _Guard(*_Get_mutex());

            if (_Data_size > 0
                && _Data_size
                       != static_cast<_Size_type>(
                           _Wrapped->sputn(_Begin_seq_ptr, static_cast<streamsize>(_Data_size)))) {
                _Result = false;
            }

            if (_Mybase::_Sync_recorded) {
                if (_Wrapped->pubsync() == -1) {
                    _Result = false;
                }
            }
        }
        _Mybase::_Sync_recorded = false;
        streambuf_type::setp(_Begin_seq_ptr, streambuf_type::epptr()); 
        return _Result;
    }

    [[nodiscard]] streambuf_type* get_wrapped() const noexcept {
        return _Wrapped;
    }

    [[nodiscard]] allocator_type get_allocator() const noexcept {
        return _Mypair._Get_first();
    }

protected:
    int sync() override {
        _Mybase::_Sync_recorded = true;

        if (_Mybase::_Emit_on_sync) {
            if (!emit()) {
                return -1;
            }
        }
        return 0;
    }

    int_type overflow(int_type _Current_elem) override {
        if (!_Wrapped) {
            return _Traits::eof();
        }
        const bool _Chk_eof = _Traits::eq_int_type(_Current_elem, _Traits::eof());
        if (_Chk_eof) {
            return _Traits::not_eof(_Current_elem);
        }

        auto& _Al                        = _Getal();
        const _Size_type _Buf_size       = _Get_buffer_size();
        const _Size_type _Max_allocation = allocator_traits<_Alloc>::max_size(_Al);
        if (_Buf_size == _Max_allocation) {
            return _Traits::eof();
        }

        const _Size_type _New_capacity  = _Calculate_growth(_Buf_size, _Buf_size + 1, _Max_allocation);
        const _Elem* const _Old_ptr     = streambuf_type::pbase();
        const _Size_type _Old_data_size = _Get_data_size();

        _Elem* const _New_ptr = _Unfancy(_Al.allocate(_New_capacity));
        _Traits::copy(_New_ptr, _Old_ptr, _Old_data_size);

        streambuf_type::setp(_New_ptr, _New_ptr + _Old_data_size, _New_ptr + _New_capacity);
        streambuf_type::sputc(_Traits::to_char_type(_Current_elem));

        return _Current_elem;
    }

private:
    static constexpr _Size_type _Min_size = 32; 

    void _Init() {
        _Elem* const _New_ptr = _Unfancy(_Getal().allocate(_Min_size));
        streambuf_type::setp(_New_ptr, _New_ptr + _Min_size);
    }

    void _Tidy() noexcept {
        const _Size_type _Buf_size = _Get_buffer_size();
        if (0 < _Buf_size) {
            _Getal().deallocate(_Refancy<_Pointer>(streambuf_type::pbase()), _Buf_size);
        }

        streambuf_type::setp(nullptr, nullptr, nullptr);
        if (_Wrapped) {
            __std_release_shared_mutex_for_instance(_Wrapped);
            _Wrapped     = nullptr;
            _Get_mutex() = nullptr;
        }
    }

    void _Swap_except_al(basic_syncbuf& _Right) {
        _Mybase::_Swap(_Right);
        ::std:: swap(_Wrapped, _Right._Wrapped);
        ::std:: swap(_Get_mutex(), _Right._Get_mutex());
    }

    bool _Do_emit() override {
        return emit();
    }

    bool _Emit() noexcept {
        try {
        return emit();
        } catch (...) {
        return false;
        }
    }

    [[nodiscard]] static constexpr _Size_type _Calculate_growth(
        const _Size_type _Oldsize, const _Size_type _Newsize, const _Size_type _Maxsize) {
        if (_Oldsize > _Maxsize - _Oldsize / 2) {
            return _Maxsize; 
        }

        const _Size_type _Geometric = _Oldsize + _Oldsize / 2;

        if (_Geometric < _Newsize) {
            return _Newsize; 
        }

        return _Geometric; 
    }

    [[nodiscard]] _Size_type _Get_data_size() const noexcept {
        return static_cast<_Size_type>(streambuf_type::pptr() - streambuf_type::pbase());
    }

    [[nodiscard]] _Size_type _Get_buffer_size() const noexcept {
        return static_cast<_Size_type>(streambuf_type::epptr() - streambuf_type::pbase());
    }

    [[nodiscard]] _Alloc& _Getal() noexcept {
        return _Mypair._Get_first();
    }

    [[nodiscard]] shared_mutex*& _Get_mutex() noexcept {
        return _Mypair._Myval2;
    }

    streambuf_type* _Wrapped{nullptr};
    _Compressed_pair<_Alloc, shared_mutex*> _Mypair{_Zero_then_variadic_args_t{}, nullptr};
};

template <class _Elem, class _Traits, class _Alloc>
void swap(basic_syncbuf<_Elem, _Traits, _Alloc>& _Left, basic_syncbuf<_Elem, _Traits, _Alloc>& _Right) {
    _Left.swap(_Right);
}

template <class _Elem, class _Traits, class _Alloc>
class basic_osyncstream : public basic_ostream<_Elem, _Traits> {
public:
    using char_type      = _Elem;
    using int_type       = typename _Traits::int_type;
    using pos_type       = typename _Traits::pos_type;
    using off_type       = typename _Traits::off_type;
    using traits_type    = _Traits;
    using allocator_type = _Alloc;
    using streambuf_type = basic_streambuf<_Elem, _Traits>;
    using syncbuf_type   = basic_syncbuf<_Elem, _Traits, _Alloc>;

    using _Mybase = basic_ostream<_Elem, _Traits>;

    basic_osyncstream(streambuf_type* _Strbuf, const _Alloc& _Al)
        : _Mybase(::std:: addressof(_Sync_buf)), _Sync_buf(_Strbuf, _Al) {}

    explicit basic_osyncstream(streambuf_type* _Strbuf) : basic_osyncstream(_Strbuf, _Alloc{}) {}

    basic_osyncstream(basic_ostream<_Elem, _Traits>& _Ostr, const _Alloc& _Al)
        : basic_osyncstream(_Ostr.rdbuf(), _Al) {}

    explicit basic_osyncstream(basic_ostream<_Elem, _Traits>& _Ostr) : basic_osyncstream(_Ostr, _Alloc{}) {}

    basic_osyncstream(basic_osyncstream&& _Right) noexcept
        : _Mybase(::std:: move(_Right)), _Sync_buf(::std:: move(_Right._Sync_buf)) {
        _Mybase::set_rdbuf(::std:: addressof(_Sync_buf));
    }

    ~basic_osyncstream() = default;

    basic_osyncstream& operator=(basic_osyncstream&&) noexcept = default;

    void emit() {
        if (!_Sync_buf.emit()) {
            _Mybase::setstate(ios::badbit);
        }
    }
    [[nodiscard]] streambuf_type* get_wrapped() const noexcept {
        return _Sync_buf.get_wrapped();
    }
    [[nodiscard]] syncbuf_type* rdbuf() const noexcept {
        return const_cast<syncbuf_type*>(::std:: addressof(_Sync_buf));
    }

private:
    syncbuf_type _Sync_buf;
};

}


#pragma warning(pop)
#pragma pack(pop)
#line 370 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\syncstream"
#line 371 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\syncstream"
#line 372 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\syncstream"
#line 96 "all-std.cxx"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\filesystem"


#pragma once


#line 15 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\filesystem"


#line 32 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\filesystem"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
namespace filesystem {
    
    
    [[nodiscard]] inline error_code _Make_ec(__std_win_error _Errno) noexcept { 
        return {static_cast<int>(_Errno), ::std:: system_category()};
    }

    [[noreturn]] inline void _Throw_system_error_from_std_win_error(const __std_win_error _Errno) {
        throw system_error{_Make_ec(_Errno)};
    }

    [[nodiscard]] inline int _Check_convert_result(const __std_fs_convert_result _Result) {
        if (_Result._Err != __std_win_error::_Success) {
            _Throw_system_error_from_std_win_error(_Result._Err);
        }

        return _Result._Len;
    }

    [[nodiscard]] inline wstring _Convert_narrow_to_wide(const __std_code_page _Code_page, const string_view _Input) {
        wstring _Output;

        if (!_Input.empty()) {
            if (_Input.size() > static_cast<size_t>(2147483647)) {
                _Throw_system_error(errc::invalid_argument);
            }

            const int _Len = _Check_convert_result(__std_fs_convert_narrow_to_wide(
                _Code_page, _Input.data(), static_cast<int>(_Input.size()), nullptr, 0));

            _Output.resize(static_cast<size_t>(_Len));

            (void) _Check_convert_result(__std_fs_convert_narrow_to_wide(
                _Code_page, _Input.data(), static_cast<int>(_Input.size()), _Output.data(), _Len));
        }

        return _Output;
    }

    template <class _Traits, class _Alloc>
    [[nodiscard]] basic_string<typename _Traits::char_type, _Traits, _Alloc> _Convert_wide_to_narrow(
        const __std_code_page _Code_page, const wstring_view _Input, const _Alloc& _Al) {
        basic_string<typename _Traits::char_type, _Traits, _Alloc> _Output(_Al);

        if (!_Input.empty()) {
            if (_Input.size() > static_cast<size_t>(2147483647)) {
                _Throw_system_error(errc::invalid_argument);
            }

            const int _Len = _Check_convert_result(__std_fs_convert_wide_to_narrow(
                _Code_page, _Input.data(), static_cast<int>(_Input.size()), nullptr, 0));

            _Output.resize(static_cast<size_t>(_Len));

            const auto _Data_as_char = reinterpret_cast<char*>(_Output.data());

            (void) _Check_convert_result(__std_fs_convert_wide_to_narrow(
                _Code_page, _Input.data(), static_cast<int>(_Input.size()), _Data_as_char, _Len));
        }

        return _Output;
    }

    
    template <class _Traits, class _Alloc>
    [[nodiscard]] basic_string<typename _Traits::char_type, _Traits, _Alloc> _Convert_wide_to_narrow_replace_chars(
        const __std_code_page _Code_page, const wstring_view _Input, const _Alloc& _Al) {
        basic_string<typename _Traits::char_type, _Traits, _Alloc> _Output(_Al);

        if (!_Input.empty()) {
            if (_Input.size() > static_cast<size_t>(2147483647)) {
                _Throw_system_error(errc::invalid_argument);
            }

            const int _Len = _Check_convert_result(__std_fs_convert_wide_to_narrow_replace_chars(
                _Code_page, _Input.data(), static_cast<int>(_Input.size()), nullptr, 0));

            _Output.resize(static_cast<size_t>(_Len));

            const auto _Data_as_char = reinterpret_cast<char*>(_Output.data());

            (void) _Check_convert_result(__std_fs_convert_wide_to_narrow_replace_chars(
                _Code_page, _Input.data(), static_cast<int>(_Input.size()), _Data_as_char, _Len));
        }

        return _Output;
    }

    [[nodiscard]] inline wstring _Convert_utf32_to_wide(const u32string_view _Input) {
        wstring _Output;

        _Output.reserve(_Input.size()); 

        for (const auto& _Code_point : _Input) {
            if (_Code_point <= 0xD7FFU) {
                _Output.push_back(static_cast<wchar_t>(_Code_point));
            } else if (_Code_point <= 0xDFFFU) {
                _Throw_system_error(errc::invalid_argument);
            } else if (_Code_point <= 0xFFFFU) {
                _Output.push_back(static_cast<wchar_t>(_Code_point));
            } else if (_Code_point <= 0x10FFFFU) {
                _Output.push_back(static_cast<wchar_t>(0xD7C0U + (_Code_point >> 10)));
                _Output.push_back(static_cast<wchar_t>(0xDC00U + (_Code_point & 0x3FFU)));
            } else {
                _Throw_system_error(errc::invalid_argument);
            }
        }

        return _Output;
    }

    template <class _Traits, class _Alloc>
    [[nodiscard]] basic_string<char32_t, _Traits, _Alloc> _Convert_wide_to_utf32(
        const wstring_view _Input, const _Alloc& _Al) {
        basic_string<char32_t, _Traits, _Alloc> _Output(_Al);

        _Output.reserve(_Input.size()); 

        const wchar_t* _First      = _Input.data();
        const wchar_t* const _Last = _First + _Input.size();

        for (; _First != _Last; ++_First) {
            if (*_First <= 0xD7FFU) {
                _Output.push_back(*_First);
            } else if (*_First <= 0xDBFFU) { 
                const char32_t _Leading = *_First; 

                ++_First;

                if (_First == _Last) { 
                    _Throw_system_error(errc::invalid_argument);
                }

                const char32_t _Trailing = *_First; 

                if (0xDC00U <= _Trailing && _Trailing <= 0xDFFFU) { 
                    _Output.push_back(0xFCA02400U + (_Leading << 10) + _Trailing);
                } else { 
                    _Throw_system_error(errc::invalid_argument);
                }
            } else if (*_First <= 0xDFFFU) { 
                _Throw_system_error(errc::invalid_argument);
            } else {
                _Output.push_back(*_First);
            }
        }

        return _Output;
    }

    template <class _Traits, class _Alloc, class _EcharT = typename _Traits::char_type>
    [[nodiscard]] basic_string<_EcharT, _Traits, _Alloc> _Convert_wide_to(const wstring_view _Input, const _Alloc& _Al) {
        if constexpr (is_same_v<_EcharT, char>) {
            return _Convert_wide_to_narrow<_Traits>(__std_fs_code_page(), _Input, _Al);
        }

        else if constexpr (is_same_v<_EcharT, char8_t>) {
            return _Convert_wide_to_narrow<_Traits>(__std_code_page::_Utf8, _Input, _Al);
        }
#line 207 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\filesystem"
        else if constexpr (is_same_v<_EcharT, char32_t>) {
            return _Convert_wide_to_utf32<_Traits>(_Input, _Al);
        } else { 
            return basic_string<_EcharT, _Traits, _Alloc>(_Input.data(), _Input.data() + _Input.size(), _Al);
        }
    }

    template <class>
    inline constexpr bool _Is_EcharT = false;
    template <>
    inline constexpr bool _Is_EcharT<char> = true;
    template <>
    inline constexpr bool _Is_EcharT<wchar_t> = true;

    template <>
    inline constexpr bool _Is_EcharT<char8_t> = true;
#line 224 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\filesystem"
    template <>
    inline constexpr bool _Is_EcharT<char16_t> = true;
    template <>
    inline constexpr bool _Is_EcharT<char32_t> = true;

    template <class _Ty, class = void>
    inline constexpr bool _Is_Source_impl = false;

    template <class _Ty>
    inline constexpr bool _Is_Source_impl<_Ty, void_t<typename iterator_traits<_Ty>::value_type>> =
        _Is_EcharT<typename iterator_traits<_Ty>::value_type>;

    template <class _Ty>
    inline constexpr bool _Is_Source = _Is_Source_impl<decay_t<_Ty>>;

    class path;

    template <>
    inline constexpr bool _Is_Source<path> = false; 
                                                    

    template <class _Elem, class _Traits, class _Alloc>
    inline constexpr bool _Is_Source<basic_string<_Elem, _Traits, _Alloc>> = _Is_EcharT<_Elem>;

    template <class _Elem, class _Traits>
    inline constexpr bool _Is_Source<basic_string_view<_Elem, _Traits>> = _Is_EcharT<_Elem>;

    struct _Normal_conversion {};

    struct _Utf8_conversion {};

    
    template <class _Conversion>
    [[nodiscard]] wstring _Convert_stringoid_to_wide(const string_view _Input, _Conversion) {
        ;

        if constexpr (is_same_v<_Conversion, _Normal_conversion>) {
            return _Convert_narrow_to_wide(__std_fs_code_page(), _Input);
        } else {
            return _Convert_narrow_to_wide(__std_code_page::_Utf8, _Input);
        }
    }

    template <class _Conversion>
    [[nodiscard]] wstring _Convert_stringoid_to_wide(const wstring_view _Input, _Conversion) {
        static_assert(
            is_same_v<_Conversion, _Normal_conversion>, "invalid value_type, see N4810 D.17 [depr.fs.path.factory]/1");
        return wstring(_Input);
    }


    template <class _Conversion>
    [[nodiscard]] wstring _Convert_stringoid_to_wide(const basic_string_view<char8_t> _Input, _Conversion) {
        ;

        const string_view _Input_as_char{reinterpret_cast<const char*>(_Input.data()), _Input.size()};
        return _Convert_narrow_to_wide(__std_code_page::_Utf8, _Input_as_char);
    }
#line 284 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\filesystem"

    template <class _Conversion>
    [[nodiscard]] wstring _Convert_stringoid_to_wide(const u16string_view _Input, _Conversion) {
        static_assert(
            is_same_v<_Conversion, _Normal_conversion>, "invalid value_type, see N4810 D.17 [depr.fs.path.factory]/1");
        return wstring(_Input.data(), _Input.data() + _Input.size());
    }

    template <class _Conversion>
    [[nodiscard]] wstring _Convert_stringoid_to_wide(const u32string_view _Input, _Conversion) {
        static_assert(
            is_same_v<_Conversion, _Normal_conversion>, "invalid value_type, see N4810 D.17 [depr.fs.path.factory]/1");
        return _Convert_utf32_to_wide(_Input);
    }

    template <class _EcharT, class _Traits>
    [[nodiscard]] auto _Stringoid_from_Source(const basic_string_view<_EcharT, _Traits>& _Source) {
        return basic_string_view<_EcharT>(_Source.data(), _Source.size()); 
    }

    template <class _EcharT, class _Traits, class _Alloc>
    [[nodiscard]] auto _Stringoid_from_Source(const basic_string<_EcharT, _Traits, _Alloc>& _Source) {
        return basic_string_view<_EcharT>(_Source.data(), _Source.size()); 
    }

    template <class _Src>
    [[nodiscard]] auto _Stringoid_from_Source(const _Src& _Source) {
        using _EcharT = _Iter_value_t<decay_t<_Src>>;
        if constexpr (is_pointer_v<_Unwrapped_unverified_t<const _Src&>>) {
            return basic_string_view<_EcharT>(_Get_unwrapped_unverified(_Source));
        } else if constexpr (is_pointer_v<_Unwrapped_t<const _Src&>>) {
            const auto _Data = _Get_unwrapped(_Source);
            auto _Next       = _Source;
            while (*_Next != _EcharT{}) {
                ++_Next;
            }

            return basic_string_view<_EcharT>(_Data, static_cast<size_t>(_Get_unwrapped(_Next) - _Data));
        } else {
            basic_string<_EcharT> _Str;
            for (auto _Next = _Source; *_Next != _EcharT{}; ++_Next) {
                _Str.push_back(*_Next);
            }

            return _Str;
        }
    }


#line 343 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\filesystem"

    template <class _Src, class _Conversion = _Normal_conversion>
    [[nodiscard]] wstring _Convert_Source_to_wide(const _Src& _Source, _Conversion _Tag = {}) {
        return _Convert_stringoid_to_wide(_Stringoid_from_Source(_Source), _Tag);
    }

    template <class _InIt>
    [[nodiscard]] auto _Stringoid_from_range(_InIt _First, _InIt _Last) {
        _Adl_verify_range(_First, _Last);
        const auto _UFirst = _Get_unwrapped(_First);
        const auto _ULast  = _Get_unwrapped(_Last);

        if constexpr (is_pointer_v<decltype(_UFirst)>) {
            return basic_string_view<_Iter_value_t<_InIt>>(_UFirst, static_cast<size_t>(_ULast - _UFirst));
        } else {
            return basic_string<_Iter_value_t<_InIt>>(_UFirst, _ULast);
        }
    }

    template <class _InIt, class _Conversion = _Normal_conversion>
    [[nodiscard]] wstring _Convert_range_to_wide(_InIt _First, _InIt _Last, _Conversion _Tag = {}) {
        return _Convert_stringoid_to_wide(_Stringoid_from_range(_First, _Last), _Tag);
    }

    [[nodiscard]] inline wstring _Convert_stringoid_with_locale_to_wide(const string_view _Input, const locale& _Loc) {
        const auto& _Facet = ::std:: use_facet<codecvt<wchar_t, char, mbstate_t>>(_Loc);

        wstring _Output(_Input.size(), L'\0'); 

        for (;;) {
            mbstate_t _State{};
            const char* const _From_begin = _Input.data();
            const char* const _From_end   = _From_begin + _Input.size();
            const char* _From_next        = nullptr;
            wchar_t* const _To_begin      = _Output.data();
            wchar_t* const _To_end        = _To_begin + _Output.size();
            wchar_t* _To_next             = nullptr;

            const auto _Result = _Facet.in(_State, _From_begin, _From_end, _From_next, _To_begin, _To_end, _To_next);

            if (_From_next < _From_begin || _From_next > _From_end || _To_next < _To_begin || _To_next > _To_end) {
                _Throw_system_error(errc::invalid_argument);
            }

            switch (_Result) {
            case codecvt_base::ok:
                _Output.resize(static_cast<size_t>(_To_next - _To_begin));
                return _Output;

            case codecvt_base::partial:
                
                
                if ((_From_next == _From_end && _To_next != _To_end) || _Output.size() > _Output.max_size() / 2) {
                    _Throw_system_error(errc::invalid_argument);
                }

                _Output.resize(_Output.size() * 2);
                break; 

            case codecvt_base::error:
            case codecvt_base::noconv:
            default:
                _Throw_system_error(errc::invalid_argument);
            }
        }
    }

    template <class _Ty>
    [[nodiscard]] _Ty _Unaligned_load(const void* _Ptr) { 
        static_assert(is_trivial_v<_Ty>, "Unaligned loads require trivial types");
        _Ty _Tmp;
        :: memcpy(&_Tmp, _Ptr, sizeof(_Tmp));
        return _Tmp;
    }

    [[nodiscard]] inline bool _Is_drive_prefix(const wchar_t* const _First) {
        
        
        auto _Value = _Unaligned_load<unsigned int>(_First);
        _Value &= 0xFFFF'FFDFu; 
        _Value -= (static_cast<unsigned int>(L':') << (sizeof(wchar_t) * 8)) | L'A';
        return _Value < 26;
    }

    [[nodiscard]] inline bool _Has_drive_letter_prefix(const wchar_t* const _First, const wchar_t* const _Last) {
        
        return _Last - _First >= 2 && _Is_drive_prefix(_First);
    }

    [[nodiscard]] inline const wchar_t* _Find_root_name_end(const wchar_t* const _First, const wchar_t* const _Last) {
        

        if (_Last - _First < 2) {
            return _First;
        }

        if (_Has_drive_letter_prefix(_First, _Last)) { 
            return _First + 2;
        }

        if (!_Is_slash(_First[0])) { 
                                     
            return _First;
        }

        
        if (_Last - _First >= 4 && _Is_slash(_First[3]) && (_Last - _First == 4 || !_Is_slash(_First[4])) 
            && ((_Is_slash(_First[1]) && (_First[2] == L'?' || _First[2] == L'.')) 
                || (_First[1] == L'?' && _First[2] == L'?'))) { 
            return _First + 3;
        }

        if (_Last - _First >= 3 && _Is_slash(_First[1]) && !_Is_slash(_First[2])) { 
            return ::std:: find_if(_First + 3, _Last, _Is_slash);
        }

        
        return _First;
    }

    [[nodiscard]] inline wstring_view _Parse_root_name(const wstring_view _Str) {
        
        const auto _First = _Str.data();
        const auto _Last  = _First + _Str.size();
        return wstring_view(_First, static_cast<size_t>(_Find_root_name_end(_First, _Last) - _First));
    }

    [[nodiscard]] inline const wchar_t* _Find_relative_path(const wchar_t* const _First, const wchar_t* const _Last) {
        
        return ::std:: find_if_not(_Find_root_name_end(_First, _Last), _Last, _Is_slash);
    }

    [[nodiscard]] inline wstring_view _Parse_root_directory(const wstring_view _Str) {
        
        const auto _First         = _Str.data();
        const auto _Last          = _First + _Str.size();
        const auto _Root_name_end = _Find_root_name_end(_First, _Last);
        const auto _Relative_path = ::std:: find_if_not(_Root_name_end, _Last, _Is_slash);
        return wstring_view(_Root_name_end, static_cast<size_t>(_Relative_path - _Root_name_end));
    }

    [[nodiscard]] inline wstring_view _Parse_root_path(const wstring_view _Str) {
        
        const auto _First = _Str.data();
        const auto _Last  = _First + _Str.size();
        return wstring_view(_First, static_cast<size_t>(_Find_relative_path(_First, _Last) - _First));
    }

    [[nodiscard]] inline wstring_view _Parse_relative_path(const wstring_view _Str) {
        
        const auto _First         = _Str.data();
        const auto _Last          = _First + _Str.size();
        const auto _Relative_path = _Find_relative_path(_First, _Last);
        return wstring_view(_Relative_path, static_cast<size_t>(_Last - _Relative_path));
    }

    [[nodiscard]] inline wstring_view _Parse_parent_path(const wstring_view _Str) {
        
        const auto _First         = _Str.data();
        auto _Last                = _First + _Str.size();
        const auto _Relative_path = _Find_relative_path(_First, _Last);
        
        
        while (_Relative_path != _Last && !_Is_slash(_Last[-1])) {
            
            --_Last;
        }

        while (_Relative_path != _Last && _Is_slash(_Last[-1])) { 
            --_Last;
        }

        return wstring_view(_First, static_cast<size_t>(_Last - _First));
    }

    [[nodiscard]] inline const wchar_t* _Find_filename(const wchar_t* const _First, const wchar_t* _Last) {
        
        const auto _Relative_path = _Find_relative_path(_First, _Last);
        while (_Relative_path != _Last && !_Is_slash(_Last[-1])) {
            --_Last;
        }

        return _Last;
    }

    [[nodiscard]] inline wstring_view _Parse_filename(const wstring_view _Str) {
        
        const auto _First    = _Str.data();
        const auto _Last     = _First + _Str.size();
        const auto _Filename = _Find_filename(_First, _Last);
        return wstring_view(_Filename, static_cast<size_t>(_Last - _Filename));
    }

    [[nodiscard]] constexpr const wchar_t* _Find_extension(const wchar_t* const _Filename, const wchar_t* const _Ads) {
        
        auto _Extension = _Ads;
        if (_Filename == _Extension) { 
            return _Ads;
        }

        --_Extension;
        if (_Filename == _Extension) {
            
            return _Ads;
        }

        if (*_Extension == L'.') { 
            if (_Filename == _Extension - 1 && _Extension[-1] == L'.') { 
                return _Ads;
            } else { 
                return _Extension;
            }
        }

        while (_Filename != --_Extension) {
            if (*_Extension == L'.') { 
                return _Extension;
            }
        }

        
        return _Ads;
    }

    [[nodiscard]] inline wstring_view _Parse_stem(const wstring_view _Str) {
        
        const auto _First    = _Str.data();
        const auto _Last     = _First + _Str.size();
        const auto _Filename = _Find_filename(_First, _Last);
        const auto _Ads =
            ::std:: find(_Filename, _Last, L':'); 
        const auto _Extension = _Find_extension(_Filename, _Ads);
        return wstring_view(_Filename, static_cast<size_t>(_Extension - _Filename));
    }

    [[nodiscard]] inline wstring_view _Parse_extension(const wstring_view _Str) {
        
        const auto _First    = _Str.data();
        const auto _Last     = _First + _Str.size();
        const auto _Filename = _Find_filename(_First, _Last);
        const auto _Ads =
            ::std:: find(_Filename, _Last, L':'); 
        const auto _Extension = _Find_extension(_Filename, _Ads);
        return wstring_view(_Extension, static_cast<size_t>(_Ads - _Extension));
    }

    [[nodiscard]] inline int _Range_compare(const wchar_t* const _Lfirst, const wchar_t* const _Llast,
        const wchar_t* const _Rfirst, const wchar_t* const _Rlast) {
        
        return _Traits_compare<char_traits<wchar_t>>(
            _Lfirst, static_cast<size_t>(_Llast - _Lfirst), _Rfirst, static_cast<size_t>(_Rlast - _Rfirst));
    }

    [[nodiscard]] inline bool _Is_drive_prefix_with_slash_slash_question(const wstring_view _Text) {
        
        return _Text.size() >= 6 && _Text._Starts_with(LR"(\\?\)"sv) && _Is_drive_prefix(_Text.data() + 4);
    }

    [[nodiscard]] inline bool _Is_dot_or_dotdot(const __std_fs_find_data& _Data) {
        
        if (_Data._File_name[0] != L'.') {
            return false;
        }

        const auto _Second_char = _Data._File_name[1];
        if (_Second_char == 0) {
            return true;
        }

        if (_Second_char != L'.') {
            return false;
        }

        return _Data._File_name[2] == 0;
    }

    struct _Find_file_handle {
        __std_fs_dir_handle _Handle = __std_fs_dir_handle::_Invalid;

        _Find_file_handle() noexcept = default;
        _Find_file_handle(_Find_file_handle&& _Rhs) noexcept
            : _Handle(::std:: exchange(_Rhs._Handle, __std_fs_dir_handle::_Invalid)) {}

        _Find_file_handle& operator=(_Find_file_handle&& _Rhs) noexcept {
            auto _Tmp = ::std:: exchange(_Rhs._Handle, __std_fs_dir_handle::_Invalid);
            _Tmp      = ::std:: exchange(_Handle, _Tmp);
            __std_fs_directory_iterator_close(_Tmp);
            return *this;
        }

        [[nodiscard]] __std_win_error _Open(const wchar_t* _Path_spec, __std_fs_find_data* _Results) noexcept {
            return __std_fs_directory_iterator_open(_Path_spec, &_Handle, _Results);
        }

        ~_Find_file_handle() noexcept {
            __std_fs_directory_iterator_close(_Handle);
        }

        explicit operator bool() const noexcept {
            return _Handle != __std_fs_dir_handle::_Invalid;
        }
    };

    template <class _Base_iter>
    class _Path_iterator;

    class path {
        template <class _Base_iter>
        friend class _Path_iterator;
        friend inline __std_win_error _Absolute(path& _Result, const wstring& _Text);
        friend inline __std_win_error _Canonical(path& _Result, const wstring& _Text);
        friend inline path temp_directory_path(error_code& _Ec);
        friend inline __std_win_error _Current_path(path& _Result) noexcept;
        friend inline void current_path(const path& _To);
        friend inline void current_path(const path& _To, error_code& _Ec) noexcept;
        friend inline __std_win_error _Read_symlink(const path& _Symlink_path, path& _Result) noexcept;

    public:
        using value_type  = wchar_t;
        using string_type = ::std:: wstring;

        static constexpr wchar_t preferred_separator = L'\\';

        enum format { auto_format, native_format, generic_format };

        path()            = default;
        path(const path&) = default;
        path(path&&)      = default;
        ~path()           = default;
        path& operator=(const path&) = default;
        path& operator=(path&&) noexcept = default;

        path(string_type&& _Source) : _Text(::std:: move(_Source)) {}

        path(string_type&& _Source, format) : _Text(::std:: move(_Source)) {
            
        }

        template <class _Src, enable_if_t<_Is_Source<_Src>, int> = 0>
        path(const _Src& _Source, format = auto_format) : _Text(_Convert_Source_to_wide(_Source)) {
            
        }

        template <class _InIt>
        path(_InIt _First, _InIt _Last, format = auto_format) : _Text(_Convert_range_to_wide(_First, _Last)) {
            
            static_assert(_Is_EcharT<_Iter_value_t<_InIt>>, "invalid value_type, see N4810 29.11.4 [fs.req]/3");
        }

        template <class _Src, enable_if_t<_Is_Source<_Src>, int> = 0>
        path(const _Src& _Source, const locale& _Loc, format = auto_format)
            : _Text(_Convert_stringoid_with_locale_to_wide(_Stringoid_from_Source(_Source), _Loc)) {
            
            using _Stringoid = decltype(_Stringoid_from_Source(_Source));
            static_assert(is_same_v<typename _Stringoid::value_type, char>,
                "invalid value_type, see N4810 29.11.7.4.1 [fs.path.construct]/6");
        }

        template <class _InIt>
        path(_InIt _First, _InIt _Last, const locale& _Loc, format = auto_format)
            : _Text(_Convert_stringoid_with_locale_to_wide(_Stringoid_from_range(_First, _Last), _Loc)) {
            
            static_assert(is_same_v<_Iter_value_t<_InIt>, char>,
                "invalid value_type, see N4810 29.11.7.4.1 [fs.path.construct]/6");
        }

        path& operator=(string_type&& _Source) noexcept  {
            
            _Text = ::std:: move(_Source);
            return *this;
        }

        path& assign(string_type&& _Source) noexcept  {
            
            _Text = ::std:: move(_Source);
            return *this;
        }

        template <class _Src, enable_if_t<_Is_Source<_Src>, int> = 0>
        path& operator=(const _Src& _Source) { 
            _Text = _Convert_Source_to_wide(_Source);
            return *this;
        }

        template <class _Src, enable_if_t<_Is_Source<_Src>, int> = 0>
        path& assign(const _Src& _Source) { 
            _Text = _Convert_Source_to_wide(_Source);
            return *this;
        }

        template <class _InIt>
        path& assign(_InIt _First, _InIt _Last) { 
            static_assert(_Is_EcharT<_Iter_value_t<_InIt>>, "invalid value_type, see N4810 29.11.4 [fs.req]/3");
            _Text = _Convert_range_to_wide(_First, _Last);
            return *this;
        }

        path& operator/=(const path& _Other) {
            
            
            if (_Other.is_absolute()) { 
                return operator=(_Other);
            }

            const auto _My_first            = _Text.data();
            const auto _My_last             = _My_first + _Text.size();
            const auto _Other_first         = _Other._Text.data();
            const auto _Other_last          = _Other_first + _Other._Text.size();
            const auto _My_root_name_end    = _Find_root_name_end(_My_first, _My_last);
            const auto _Other_root_name_end = _Find_root_name_end(_Other_first, _Other_last);
            if (_Other_first != _Other_root_name_end
                && _Range_compare(_My_first, _My_root_name_end, _Other_first, _Other_root_name_end) != 0) {
                
                return operator=(_Other);
            }

            if (_Other_root_name_end != _Other_last && _Is_slash(*_Other_root_name_end)) {
                
                _Text.erase(static_cast<size_t>(_My_root_name_end - _My_first));
            } else {
                
                if (_My_root_name_end == _My_last) {
                    
                    
                    if (_My_root_name_end - _My_first >= 3) {
                        _Text.push_back(preferred_separator);
                    }
                } else {
                    
                    
                    if (!_Is_slash(_My_last[-1])) {
                        _Text.push_back(preferred_separator);
                    }
                }
            }

            
            _Text.append(_Other_root_name_end, static_cast<size_t>(_Other_last - _Other_root_name_end));
            return *this;
        }

        template <class _Src, enable_if_t<_Is_Source<_Src>, int> = 0>
        path& operator/=(const _Src& _Source) {
            return operator/=(path(_Source));
        }

        template <class _Src, enable_if_t<_Is_Source<_Src>, int> = 0>
        path& append(const _Src& _Source) {
            return operator/=(path(_Source));
        }

        template <class _InIt>
        path& append(_InIt _First, _InIt _Last) {
            static_assert(_Is_EcharT<_Iter_value_t<_InIt>>, "invalid value_type, see N4810 29.11.4 [fs.req]/3");
            return operator/=(path(_First, _Last));
        }

        path& operator+=(const path& _Added) { 
            _Text._Orphan_all();
            _Text += _Added._Text;
            return *this;
        }

        path& operator+=(const string_type& _Added) { 
            _Text._Orphan_all();
            _Text += _Added;
            return *this;
        }

        path& operator+=(const wstring_view _Added) { 
            _Text._Orphan_all();
            _Text += _Added;
            return *this;
        }

        path& operator+=(const value_type* const _Added) { 
            _Text._Orphan_all();
            _Text += _Added;
            return *this;
        }

        path& operator+=(const value_type _Added) { 
            _Text._Orphan_all();
            _Text += _Added;
            return *this;
        }

        template <class _Src, enable_if_t<_Is_Source<_Src>, int> = 0>
        path& operator+=(const _Src& _Added) { 
            return operator+=(path(_Added));
        }

        template <class _EcharT, enable_if_t<_Is_EcharT<_EcharT>, int> = 0>
        path& operator+=(const _EcharT _Added) { 
            return operator+=(path(&_Added, &_Added + 1));
        }

        template <class _Src, enable_if_t<_Is_Source<_Src>, int> = 0>
        path& concat(const _Src& _Added) { 
            return operator+=(path(_Added));
        }

        template <class _InIt>
        path& concat(_InIt _First, _InIt _Last) { 
            static_assert(_Is_EcharT<_Iter_value_t<_InIt>>, "invalid value_type, see N4810 29.11.4 [fs.req]/3");
            return operator+=(path(_First, _Last));
        }

        void clear() noexcept { 
            _Text._Orphan_all();
            _Text.clear();
        }

        path& make_preferred() noexcept  {
            
            _Text._Orphan_all();
            ::std:: replace(_Text.begin(), _Text.end(), L'/', L'\\');
            return *this;
        }

        path& remove_filename() noexcept  {
            
            const auto _First    = _Text.data();
            const auto _Last     = _First + _Text.size();
            const auto _Filename = _Find_filename(_First, _Last);
            _Text._Orphan_all();
            _Text.erase(static_cast<size_t>(_Filename - _First));
            return *this;
        }

        void _Remove_filename_and_separator() noexcept { 
            const auto _First         = _Text.data();
            const auto _Last          = _First + _Text.size();
            const auto _Root_name_end = _Find_root_name_end(_First, _Last);
            const auto _Root_dir_end =
                (_Root_name_end != _Last && _Is_slash(*_Root_name_end)) ? _Root_name_end + 1 : _Root_name_end;

            using _Reverse_iter = reverse_iterator<const wchar_t*>;

            const _Reverse_iter _Rbegin{_Last};
            const _Reverse_iter _Rend{_Root_dir_end};

            const auto _Rslash_first = ::std:: find_if(_Rbegin, _Rend, _Is_slash);
            const auto _Rslash_last  = ::std:: find_if_not(_Rslash_first, _Rend, _Is_slash);

            const _Reverse_iter _Rlast{_First};

            _Text._Orphan_all();
            _Text.erase(static_cast<size_t>(_Rlast - _Rslash_last));
        }

        path& replace_filename(const path& _Replacement) { 
            remove_filename();
            return operator/=(_Replacement);
        }

        path& replace_extension() noexcept  {
            
            const wchar_t* _First = _Text.data();
            const auto _Last      = _First + _Text.size();
            const auto _Filename  = _Find_filename(_First, _Last);
            const auto _Ads       = ::std:: find(_Filename, _Last, L':');
            const auto _Extension = _Find_extension(_Filename, _Ads);
            _Text._Orphan_all();
            _Text.erase(static_cast<size_t>(_Extension - _First));
            return *this;
        }

        path& replace_extension(const path& _Replacement) {
            
            
            replace_extension();
            if (!_Replacement.empty() && _Replacement._Text[0] != L'.') {
                _Text.push_back(L'.');
            }

            return operator+=(_Replacement);
        }

        void swap(path& _Rhs) noexcept {
            _Text.swap(_Rhs._Text);
        }

        [[nodiscard]] const string_type& native() const noexcept {
            
            return _Text;
        }

        [[nodiscard]] const value_type* c_str() const noexcept {
            
            return _Text.c_str();
        }

        operator string_type() const { 
            return _Text;
        }

        template <class _EcharT, class _Traits = char_traits<_EcharT>, class _Alloc = allocator<_EcharT>,
            enable_if_t<_Is_EcharT<_EcharT>, int> = 0>
        [[nodiscard]] basic_string<_EcharT, _Traits, _Alloc> string(const _Alloc& _Al = _Alloc()) const {
            
            return _Convert_wide_to<_Traits>(_Text, _Al);
        }

        [[nodiscard]] ::std:: string string() const { 
            return string<char>();
        }

        [[nodiscard]] ::std:: wstring wstring() const { 
            return _Text;
        }

        [[nodiscard]] auto u8string() const { 

            using _U8Ty = char8_t;


#line 1013 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\filesystem"
            return _Convert_wide_to_narrow<char_traits<_U8Ty>>(__std_code_page::_Utf8, _Text, allocator<_U8Ty>{});
        }

        [[nodiscard]] ::std:: u16string u16string() const { 
            return string<char16_t>();
        }

        [[nodiscard]] ::std:: u32string u32string() const { 
            return string<char32_t>();
        }

        template <class _EcharT, class _Traits = char_traits<_EcharT>, class _Alloc = allocator<_EcharT>,
            enable_if_t<_Is_EcharT<_EcharT>, int> = 0>
        [[nodiscard]] basic_string<_EcharT, _Traits, _Alloc> generic_string(const _Alloc& _Al = _Alloc()) const {
            
            using _Alwide = _Rebind_alloc_t<_Alloc, wchar_t>;
            _Alwide _Al_wchar(_Al);
            basic_string<wchar_t, char_traits<wchar_t>, _Alwide> _Generic_str(_Al_wchar);
            _Generic_str.resize(_Text.size());
            ::std:: replace_copy(_Text.begin(), _Text.end(), _Generic_str.begin(), L'\\', L'/');
            return _Convert_wide_to<_Traits>(_Generic_str, _Al);
        }

        [[nodiscard]] ::std:: string generic_string() const {
            
            return generic_string<char>();
        }

        [[nodiscard]] ::std:: wstring generic_wstring() const {
            
            
            ::std:: wstring _Result;
            _Result.resize(_Text.size());
            ::std:: replace_copy(_Text.begin(), _Text.end(), _Result.begin(), L'\\', L'/');
            return _Result;
        }

        [[nodiscard]] auto generic_u8string() const {
            
            auto _Result = u8string();
            using _U8Ty  = decltype(_Result)::value_type;
            ::std:: replace(_Result.begin(), _Result.end(), _U8Ty{u8'\\'}, _U8Ty{u8'/'});
            return _Result;
        }

        [[nodiscard]] ::std:: u16string generic_u16string() const {
            
            ::std:: u16string _Result = u16string();
            ::std:: replace(_Result.begin(), _Result.end(), u'\\', u'/');
            return _Result;
        }

        [[nodiscard]] ::std:: u32string generic_u32string() const {
            
            ::std:: u32string _Result = u32string();
            ::std:: replace(_Result.begin(), _Result.end(), U'\\', U'/');
            return _Result;
        }

        [[nodiscard]] int compare(const path& _Other) const noexcept { 
            return compare(static_cast<wstring_view>(_Other._Text));
        }

        [[nodiscard]] int compare(const string_type& _Other) const noexcept  {
            
            return compare(static_cast<wstring_view>(_Other));
        }

        [[nodiscard]] int compare(const basic_string_view<value_type> _Other) const noexcept  {
            
            
            const auto _My_first            = _Text.data();
            const auto _My_last             = _My_first + _Text.size();
            const auto _My_root_name_end    = _Find_root_name_end(_My_first, _My_last);
            const auto _Other_first         = _Other.data();
            const auto _Other_last          = _Other_first + _Other.size();
            const auto _Other_root_name_end = _Find_root_name_end(_Other_first, _Other_last);

            
            const int _Root_cmp = _Range_compare(_My_first, _My_root_name_end, _Other_first, _Other_root_name_end);
            if (_Root_cmp != 0) { 
                return _Root_cmp;
            }

            auto _My_relative               = ::std:: find_if_not(_My_root_name_end, _My_last, _Is_slash);
            auto _Other_relative            = ::std:: find_if_not(_Other_root_name_end, _Other_last, _Is_slash);
            const bool _My_has_root_name    = _My_root_name_end != _My_relative;
            const bool _Other_has_root_name = _Other_root_name_end != _Other_relative;
            
            
            const int _Root_name_cmp = _My_has_root_name - _Other_has_root_name;
            if (_Root_name_cmp != 0) {
                return _Root_name_cmp;
            }

            
            for (;;) {
                const bool _My_empty    = _My_relative == _My_last;
                const bool _Other_empty = _Other_relative == _Other_last;
                const int _Empty_cmp    = _Other_empty - _My_empty;
                if (_My_empty || _Empty_cmp != 0) {
                    return _Empty_cmp;
                }

                const bool _My_slash    = _Is_slash(*_My_relative);
                const bool _Other_slash = _Is_slash(*_Other_relative);
                const int _Slash_cmp    = _Other_slash - _My_slash;
                if (_Slash_cmp != 0) {
                    return _Slash_cmp;
                }

                if (_My_slash) { 
                    _My_relative    = ::std:: find_if_not(_My_relative + 1, _My_last, _Is_slash);
                    _Other_relative = ::std:: find_if_not(_Other_relative + 1, _Other_last, _Is_slash);
                    continue;
                }

                const int _Cmp = *_My_relative - *_Other_relative;
                if (_Cmp != 0) {
                    return _Cmp;
                }

                ++_My_relative;
                ++_Other_relative;
            }
        }

        [[nodiscard]] int compare(const value_type* const _Other) const noexcept  {
            
            return compare(static_cast<wstring_view>(_Other));
        }

        [[nodiscard]] path root_name() const {
            
            return _Parse_root_name(_Text);
        }

        [[nodiscard]] path root_directory() const {
            
            return _Parse_root_directory(_Text);
        }

        [[nodiscard]] path root_path() const {
            
            return _Parse_root_path(_Text);
        }

        [[nodiscard]] path relative_path() const {
            
            return _Parse_relative_path(_Text);
        }

        [[nodiscard]] path parent_path() const {
            
            return _Parse_parent_path(_Text);
        }

        [[nodiscard]] path filename() const {
            
            return _Parse_filename(_Text);
        }

        [[nodiscard]] path stem() const {
            
            return _Parse_stem(_Text);
        }

        [[nodiscard]] path extension() const {
            
            return _Parse_extension(_Text);
        }

        [[nodiscard]] bool empty() const noexcept {
            return _Text.empty();
        }

        [[nodiscard]] bool has_root_name() const noexcept  {
            
            return !_Parse_root_name(_Text).empty();
        }

        [[nodiscard]] bool has_root_directory() const noexcept  {
            
            return !_Parse_root_directory(_Text).empty();
        }

        [[nodiscard]] bool has_root_path() const noexcept  {
            
            return !_Parse_root_path(_Text).empty();
        }

        [[nodiscard]] bool has_relative_path() const noexcept  {
            
            return !_Parse_relative_path(_Text).empty();
        }

        [[nodiscard]] bool has_parent_path() const noexcept  {
            
            return !_Parse_parent_path(_Text).empty();
        }

        [[nodiscard]] bool has_filename() const noexcept  {
            
            return !_Parse_filename(_Text).empty();
        }

        [[nodiscard]] bool has_stem() const noexcept  {
            
            return !_Parse_stem(_Text).empty();
        }

        [[nodiscard]] bool has_extension() const noexcept  {
            
            return !_Parse_extension(_Text).empty();
        }

        [[nodiscard]] bool is_absolute() const noexcept  {
            
            
            const auto _First = _Text.data();
            const auto _Last  = _First + _Text.size();
            if (_Has_drive_letter_prefix(_First, _Last)) { 
                return _Last - _First >= 3 && _Is_slash(_First[2]);
            }

            
            return _First != _Find_root_name_end(_First, _Last);
        }

        [[nodiscard]] bool is_relative() const noexcept  {
            
            return !is_absolute();
        }

        [[nodiscard]] path lexically_normal() const {
            constexpr wstring_view _Dot     = L"."sv;
            constexpr wstring_view _Dot_dot = L".."sv;

            
            if (empty()) {
                return {};
            }

            
            const auto _First         = _Text.data();
            const auto _Last          = _First + _Text.size();
            const auto _Root_name_end = _Find_root_name_end(_First, _Last);
            string_type _Normalized(_First, _Root_name_end);
            ::std:: replace(_Normalized.begin(), _Normalized.end(), L'/', L'\\');

            
            list<wstring_view> _Lst; 
                                     
                                     
            for (auto _Next = _Root_name_end; _Next != _Last;) {
                if (_Is_slash(*_Next)) {
                    if (_Lst.empty() || !_Lst.back().empty()) {
                        
                        _Lst.emplace_back();
                    }

                    ++_Next;
                } else {
                    const auto _Filename_end = ::std:: find_if(_Next + 1, _Last, _Is_slash);
                    _Lst.emplace_back(_Next, static_cast<size_t>(_Filename_end - _Next));
                    _Next = _Filename_end;
                }
            }

            
            for (auto _Next = _Lst.begin(); _Next != _Lst.end();) {
                if (*_Next == _Dot) {
                    _Next = _Lst.erase(_Next); 

                    if (_Next != _Lst.end()) {
                        _Next = _Lst.erase(_Next); 
                    }
                } else {
                    ++_Next;
                }
            }

            
            for (auto _Next = _Lst.begin(); _Next != _Lst.end();) {
                auto _Prev = _Next;

                ++_Next; 
                         

                if (*_Prev == _Dot_dot && _Prev != _Lst.begin() && --_Prev != _Lst.begin() && *--_Prev != _Dot_dot) {
                    if (_Next != _Lst.end()) { 
                        ++_Next;
                    }

                    _Lst.erase(_Prev, _Next); 
                }
            }

            
            if (!_Lst.empty() && _Lst.front().empty()) { 
                for (auto _Next = _Lst.begin(); _Next != _Lst.end();) {
                    if (*_Next == _Dot_dot) {
                        _Next = _Lst.erase(_Next); 

                        if (_Next != _Lst.end()) {
                            _Next = _Lst.erase(_Next); 
                        }
                    } else {
                        ++_Next;
                    }
                }
            }

            
            if (_Lst.size() >= 2 && _Lst.back().empty() && *(::std:: prev(_Lst.end(), 2)) == _Dot_dot) {
                _Lst.pop_back();
            }

            
            for (const auto& _Elem : _Lst) {
                if (_Elem.empty()) {
                    _Normalized += preferred_separator;
                } else {
                    _Normalized += _Elem;
                }
            }

            
            if (_Normalized.empty()) {
                _Normalized = _Dot;
            }

            
            path _Result(::std:: move(_Normalized));

            return _Result;
        }

        [[nodiscard]] inline path lexically_relative(const path& _Base) const;

        [[nodiscard]] path lexically_proximate(const path& _Base) const {
            path _Result = lexically_relative(_Base);

            if (_Result.empty()) {
                _Result = *this;
            }

            return _Result;
        }

        using iterator       = _Path_iterator<string_type::const_iterator>;
        using const_iterator = iterator;

        [[nodiscard]] inline iterator begin() const;
        [[nodiscard]] inline iterator end() const noexcept; 

        template <class _Elem, class _Traits>
        friend ::std:: basic_ostream<_Elem, _Traits>& operator<<( 
            ::std:: basic_ostream<_Elem, _Traits>& _Ostr, const path& _Path) { 
            
            return _Ostr << ::std:: quoted(_Path.string<_Elem, _Traits>());
        }

        template <class _Elem, class _Traits>
        friend ::std:: basic_istream<_Elem, _Traits>& operator>>( 
            ::std:: basic_istream<_Elem, _Traits>& _Istr, path& _Path) { 
            
            basic_string<_Elem, _Traits> _Tmp;
            _Istr >> ::std:: quoted(_Tmp);
            _Path = ::std:: move(_Tmp); 
            return _Istr;
        }

        [[nodiscard]] friend bool operator==(const path& _Left, const path& _Right) noexcept {
            return _Left.compare(_Right) == 0;
        }


        [[nodiscard]] friend strong_ordering operator<=>(const path& _Left, const path& _Right) noexcept {
            return _Left.compare(_Right) <=> 0;
        }


#line 1429 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\filesystem"

        [[nodiscard]] friend path operator/(const path& _Left, const path& _Right) { 
            path _Tmp = _Left;
            _Tmp /= _Right;
            return _Tmp;
        }

    private:
        string_type _Text;
    };

    template <class _Src, enable_if_t<_Is_Source<_Src>, int> = 0>
    [[deprecated("warning STL4021: " "The std::filesystem::u8path() overloads are deprecated in C++20. " "The constructors of std::filesystem::path provide equivalent functionality via construction from " "u8string, u8string_view, or iterators with value_type char8_t. " "You can define _SILENCE_CXX20_U8PATH_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] [[nodiscard]] path u8path(const _Src& _Source) { 
        return path(_Convert_Source_to_wide(_Source, _Utf8_conversion{}));
    }

    template <class _InIt>
    [[deprecated("warning STL4021: " "The std::filesystem::u8path() overloads are deprecated in C++20. " "The constructors of std::filesystem::path provide equivalent functionality via construction from " "u8string, u8string_view, or iterators with value_type char8_t. " "You can define _SILENCE_CXX20_U8PATH_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] [[nodiscard]] path u8path(_InIt _First, _InIt _Last) {
        
        static_assert(_Is_EcharT<_Iter_value_t<_InIt>>, "invalid value_type, see N4810 29.11.4 [fs.req]/3");
        return path(_Convert_range_to_wide(_First, _Last, _Utf8_conversion{}));
    }

    template <class _Base_iter>
    class _Path_iterator { 
    public:
        
        
        using iterator_category = input_iterator_tag;
        using value_type        = path;
        using difference_type   = ptrdiff_t;
        using pointer           = const path*;
        using reference         = const path&;

        _Path_iterator() = default;

        _Path_iterator(const _Base_iter& _Position_, const path* _Mypath_) noexcept
            : _Position(_Position_), _Element(), _Mypath(_Mypath_) {}

        _Path_iterator(const _Base_iter& _Position_, wstring_view _Element_text, const path* _Mypath_)
            : _Position(_Position_), _Element(_Element_text), _Mypath(_Mypath_) {}

        _Path_iterator(const _Path_iterator&) = default;
        _Path_iterator(_Path_iterator&&)      = default;
        _Path_iterator& operator=(const _Path_iterator&) = default;
        _Path_iterator& operator=(_Path_iterator&&) = default;

        [[nodiscard]] reference operator*() const noexcept {
            return _Element;
        }

        [[nodiscard]] pointer operator->() const noexcept {
            return ::std:: addressof(_Element);
        }

        _Path_iterator& operator++() {
            const auto& _Text = _Mypath->native();
            const auto _Size  = _Element.native().size();
            _Adl_verify_range(_Text.begin(), _Position); 
            const auto _Begin = _Text.data();
            const auto _End   = _Begin + _Text.size();
            _Adl_verify_range(_Begin, _Position); 
            if (_Begin == _Get_unwrapped(_Position)) { 
                _Position += static_cast<ptrdiff_t>(_Size);
                const auto _First              = _Text.data();
                const auto _Last               = _First + _Text.size();
                const auto _Root_name_end      = _Find_root_name_end(_First, _Last);
                const auto _Root_directory_end = ::std:: find_if_not(_Root_name_end, _Last, _Is_slash);
                if (_First != _Root_name_end && _Root_name_end != _Root_directory_end) {
                    
                    _Element._Text.assign(_Root_name_end, _Root_directory_end);
                    return *this;
                }

                
            } else if (_Is_slash(*_Position)) { 
                if (_Size == 0) { 
                    ++_Position;
                    return *this;
                }

                
                _Position += static_cast<ptrdiff_t>(_Size);
            } else { 
                _Position += static_cast<ptrdiff_t>(_Size);
            }

            if (_Get_unwrapped(_Position) == _End) {
                _Element.clear();
                return *this;
            }

            
            while (_Is_slash(*_Position)) { 
                if (_Get_unwrapped(++_Position) == _End) { 
                    --_Position;
                    _Element.clear();
                    return *this;
                }
            }

            _Element._Text.assign(_Get_unwrapped(_Position), ::std:: find_if(_Get_unwrapped(_Position), _End, _Is_slash));
            return *this;
        }

        _Path_iterator operator++(int) {
            _Path_iterator _Tmp = *this;
            ++*this;
            return _Tmp;
        }

        _Path_iterator& operator--() {
            const auto& _Text = _Mypath->native();
            _Adl_verify_range(_Text.begin(), _Position); 
            const auto _First = _Text.data();
            _Adl_verify_range(_First, _Position); 
            const auto _Last                   = _First + _Text.size();
            const auto _Root_name_end_ptr      = _Find_root_name_end(_First, _Last);
            const auto _Root_directory_end_ptr = ::std:: find_if_not(_Root_name_end_ptr, _Last, _Is_slash);

            if (_Root_name_end_ptr != _Root_directory_end_ptr && _Get_unwrapped(_Position) == _Root_directory_end_ptr) {
                
                _Seek_wrapped(_Position, _Root_name_end_ptr);
                _Element._Text.assign(
                    _Root_name_end_ptr, static_cast<size_t>(_Root_directory_end_ptr - _Root_name_end_ptr));
                return *this;
            }

            if (_First != _Root_name_end_ptr && _Get_unwrapped(_Position) == _Root_name_end_ptr) {
                
                
                _Seek_wrapped(_Position, _First);
                _Element._Text.assign(_First, static_cast<size_t>(_Root_name_end_ptr - _First));
                return *this;
            }

            
            if (_Get_unwrapped(_Position) == _Last && _Is_slash(_Position[-1])) { 
                --_Position;
                _Element.clear();
                return *this;
            }

            while (_Root_directory_end_ptr != _Get_unwrapped(_Position) && _Is_slash(_Position[-1])) {
                --_Position;
            }

            const auto _New_end = _Position;
            while (_Root_directory_end_ptr != _Get_unwrapped(_Position) && !_Is_slash(_Position[-1])) {
                --_Position;
            }

            _Element._Text.assign(_Position, _New_end);
            return *this;
        }

        _Path_iterator operator--(int) {
            _Path_iterator _Tmp = *this;
            --*this;
            return _Tmp;
        }

        [[nodiscard]] friend bool operator==(const _Path_iterator& _Lhs, const _Path_iterator& _Rhs) {
            return _Lhs._Position == _Rhs._Position;
        }


#line 1610 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\filesystem"


#line 1616 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\filesystem"

        using _Prevent_inheriting_unwrap = _Path_iterator;

        template <class _Iter2 = _Base_iter, enable_if_t<_Unwrappable_v<const _Iter2&>, int> = 0>
        [[nodiscard]] _Path_iterator<_Unwrapped_t<const _Iter2&>> _Unwrapped() const {
            return {_Position._Unwrapped(), _Element.native(), _Mypath};
        }

        static constexpr bool _Unwrap_when_unverified = _Do_unwrap_when_unverified_v<_Base_iter>;

        template <class _Other>
        friend class _Path_iterator;

        template <class _Other, enable_if_t<_Wrapped_seekable_v<_Base_iter, const _Other&>, int> = 0>
        constexpr void _Seek_to(const _Path_iterator<_Other>& _It) {
            _Position._Seek_to(_It._Position);
            _Element = _It._Element;
            
        }

    private:
        
        
        _Base_iter _Position{};
        path _Element{};
        const path* _Mypath{};
    };

    inline void swap(path& _Left, path& _Right) noexcept {
        _Left.swap(_Right);
    }

    [[nodiscard]] inline size_t hash_value(const path& _Path) noexcept {
        
        
        size_t _Val       = _FNV_offset_basis;
        const auto& _Text = _Path.native();
        const auto _First = _Text.data();
        const auto _Last  = _First + _Text.size();

        
        auto _Next = _Find_root_name_end(_First, _Last);
        _Val       = _Fnv1a_append_range(_Val, _First, _Next);

        
        bool _Slash_inserted = false;
        for (; _Next != _Last; ++_Next) {
            if (_Is_slash(*_Next)) {
                if (!_Slash_inserted) {
                    _Val            = _Fnv1a_append_value(_Val, path::preferred_separator);
                    _Slash_inserted = true;
                }
            } else {
                _Val            = _Fnv1a_append_value(_Val, *_Next);
                _Slash_inserted = false;
            }
        }

        return _Val;
    }

    [[nodiscard]] inline bool _Relative_path_contains_root_name(const path& _Path) {
        for (const auto& _File_name : _Path.relative_path()) {
            if (!_Parse_root_name(_File_name.native()).empty()) {
                return true;
            }
        }
        return false;
    }

    [[nodiscard]] inline path path::lexically_relative(const path& _Base) const {
        constexpr wstring_view _Dot     = L"."sv;
        constexpr wstring_view _Dot_dot = L".."sv;

        path _Result;

        if (root_name() != _Base.root_name() || is_absolute() != _Base.is_absolute()
            || (!has_root_directory() && _Base.has_root_directory()) || _Relative_path_contains_root_name(*this)
            || _Relative_path_contains_root_name(_Base)) {
            return _Result;
        }

        const iterator _This_end   = end();
        const iterator _Base_begin = _Base.begin();
        const iterator _Base_end   = _Base.end();

        auto _Mismatched  = ::std:: mismatch(begin(), _This_end, _Base_begin, _Base_end);
        iterator& _A_iter = _Mismatched.first;
        iterator& _B_iter = _Mismatched.second;

        if (_A_iter == _This_end && _B_iter == _Base_end) {
            _Result = _Dot;
            return _Result;
        }

        { 
            ptrdiff_t _B_dist = ::std:: distance(_Base_begin, _B_iter);

            const ptrdiff_t _Base_root_dist =
                static_cast<ptrdiff_t>(_Base.has_root_name()) + static_cast<ptrdiff_t>(_Base.has_root_directory());

            while (_B_dist < _Base_root_dist) {
                ++_B_iter;
                ++_B_dist;
            }
        }

        ptrdiff_t _Num = 0;

        for (; _B_iter != _Base_end; ++_B_iter) {
            const path& _Elem = *_B_iter;

            if (_Elem.empty()) { 
            } else if (_Elem == _Dot) { 
            } else if (_Elem == _Dot_dot) {
                --_Num;
            } else {
                ++_Num;
            }
        }

        if (_Num < 0) {
            return _Result;
        }

        if (_Num == 0 && (_A_iter == _This_end || _A_iter->empty())) {
            _Result = _Dot;
            return _Result;
        }

        for (; _Num > 0; --_Num) {
            _Result /= _Dot_dot;
        }

        for (; _A_iter != _This_end; ++_A_iter) {
            _Result /= *_A_iter;
        }

        return _Result;
    }

    [[nodiscard]] inline path::iterator path::begin() const {
        const auto _First         = _Text.data();
        const auto _Last          = _First + _Text.size();
        const auto _Root_name_end = _Find_root_name_end(_First, _Last);
        const wchar_t* _First_end;
        if (_First == _Root_name_end) { 
            auto _Root_directory_end = ::std:: find_if_not(_Root_name_end, _Last, _Is_slash);
            if (_First == _Root_directory_end) { 
                _First_end = ::std:: find_if(_Root_directory_end, _Last, _Is_slash);
            } else { 
                _First_end = _Root_directory_end;
            }
        } else { 
            _First_end = _Root_name_end;
        }

        return iterator(_Text.cbegin(), wstring_view(_First, static_cast<size_t>(_First_end - _First)), this);
    }

    [[nodiscard]] inline path::iterator path::end() const noexcept  {
        return iterator(_Text.cend(), this);
    }

    class filesystem_error : public system_error { 
    public:
        filesystem_error(const string& _Message, const error_code _Errcode)
            : system_error(_Errcode, _Message), _What(runtime_error::what()) {}

        filesystem_error(const string& _Message, const path& _Path1_arg, const error_code _Errcode)
            : system_error(_Errcode, _Message), _Path1(_Path1_arg), _Path2(),
              _What(_Pretty_message(runtime_error::what(), _Path1_arg)) {}

        filesystem_error(
            const string& _Message, const path& _Path1_arg, const path& _Path2_arg, const error_code _Errcode)
            : system_error(_Errcode, _Message), _Path1(_Path1_arg), _Path2(_Path2_arg),
              _What(_Pretty_message(runtime_error::what(), _Path1_arg, _Path2_arg)) {}

        [[nodiscard]] const path& path1() const noexcept {
            return _Path1;
        }

        [[nodiscard]] const path& path2() const noexcept {
            return _Path2;
        }

        [[nodiscard]] const char* what() const noexcept override {
            return _What.c_str();
        }

    private:
        static string _Pretty_message(const string_view _Op, const path& _Path1, const path& _Path2 = {}) {
            string _Result;
            
            const auto _Code_page   = __std_fs_code_page();
            const string _Path1_str = _Convert_wide_to_narrow_replace_chars<char_traits<char>>(
                _Code_page, _Path1.native(), allocator<char>{});
            const string _Path2_str = _Convert_wide_to_narrow_replace_chars<char_traits<char>>(
                _Code_page, _Path2.native(), allocator<char>{});
            _Result.reserve(_Op.size() + (_Path2_str.empty() ? 4 : 8) + _Path1_str.size() + _Path2_str.size());
            _Result += _Op;
            _Result += R"(: ")"sv; 
            _Result += _Path1_str;
            if (!_Path2_str.empty()) {
                _Result += R"(", ")"sv; 
                _Result += _Path2_str;
            }
            _Result += '"'; 
            return _Result;
        }

        path _Path1;
        path _Path2;
        string _What;


#line 1847 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\filesystem"
    };

    [[noreturn]] inline void _Throw_fs_error(const char* _Op, __std_win_error _Error) {
        throw filesystem_error(_Op, _Make_ec(_Error));
    }

    [[noreturn]] inline void _Throw_fs_error(const char* _Op, __std_win_error _Error, const path& _Path1) {
        throw filesystem_error(_Op, _Path1, _Make_ec(_Error));
    }

    [[noreturn]] inline void _Throw_fs_error(
        const char* _Op, __std_win_error _Error, const path& _Path1, const path& _Path2) {
        throw filesystem_error(_Op, _Path1, _Path2, _Make_ec(_Error));
    }

    [[noreturn]] inline void _Throw_fs_error(const char* _Op, const error_code& _Error, const path& _Path1) {
        throw filesystem_error(_Op, _Path1, _Error);
    }

    [[noreturn]] inline void _Throw_fs_error(
        const char* _Op, const error_code& _Error, const path& _Path1, const path& _Path2) {
        throw filesystem_error(_Op, _Path1, _Path2, _Error);
    }

    enum class file_type {
        none,
        not_found,
        regular,
        directory,
        symlink,

        block, 
        character, 
                   
                   
        fifo, 
        socket, 
        unknown,

        junction 
    };

    enum class perms {
        none = 0,

        owner_read  = 0400,
        owner_write = 0200,
        owner_exec  = 0100,
        owner_all   = 0700,

        group_read  = 0040,
        group_write = 0020,
        group_exec  = 0010,
        group_all   = 0070,

        others_read  = 0004,
        others_write = 0002,
        others_exec  = 0001,
        others_all   = 0007,

        all        = 0777, 
        set_uid    = 04000,
        set_gid    = 02000,
        sticky_bit = 01000,
        mask       = 07777,
        unknown    = 0xFFFF,

        _All_write               = owner_write | group_write | others_write,
        _File_attribute_readonly = all & ~_All_write 
    };

    [[nodiscard]] constexpr perms operator&(perms _Left, perms _Right) noexcept { using _IntTy = ::std:: underlying_type_t<perms>; return static_cast<perms>(static_cast<_IntTy>(_Left) & static_cast<_IntTy>(_Right)); } [[nodiscard]] constexpr perms operator|(perms _Left, perms _Right) noexcept { using _IntTy = ::std:: underlying_type_t<perms>; return static_cast<perms>(static_cast<_IntTy>(_Left) | static_cast<_IntTy>(_Right)); } [[nodiscard]] constexpr perms operator^(perms _Left, perms _Right) noexcept { using _IntTy = ::std:: underlying_type_t<perms>; return static_cast<perms>(static_cast<_IntTy>(_Left) ^ static_cast<_IntTy>(_Right)); } constexpr perms& operator&=(perms& _Left, perms _Right) noexcept { return _Left = _Left & _Right; } constexpr perms& operator|=(perms& _Left, perms _Right) noexcept { return _Left = _Left | _Right; } constexpr perms& operator^=(perms& _Left, perms _Right) noexcept { return _Left = _Left ^ _Right; } [[nodiscard]] constexpr perms operator~(perms _Left) noexcept { using _IntTy = ::std:: underlying_type_t<perms>; return static_cast<perms>(~static_cast<_IntTy>(_Left)); } [[nodiscard]] constexpr bool _Bitmask_includes( perms _Left, perms _Elements) noexcept { return (_Left & _Elements) != perms{}; } [[nodiscard]] constexpr bool _Bitmask_includes_all( perms _Left, perms _Elements) noexcept { return (_Left & _Elements) == _Elements; }

    enum class copy_options {
        none = static_cast<int>(__std_fs_copy_options::_None),

        _Existing_mask     = static_cast<int>(__std_fs_copy_options::_Existing_mask),
        skip_existing      = static_cast<int>(__std_fs_copy_options::_Skip_existing),
        overwrite_existing = static_cast<int>(__std_fs_copy_options::_Overwrite_existing),
        update_existing    = static_cast<int>(__std_fs_copy_options::_Update_existing),

        recursive = 0x10,

        _Symlinks_mask = 0xF00,
        copy_symlinks  = 0x100,
        skip_symlinks  = 0x200,

        _Copy_form_mask   = 0xF000,
        directories_only  = 0x1000,
        create_symlinks   = 0x2000,
        create_hard_links = 0x4000,

        _Unspecified_copy_prevention_tag = 0x10000 
    };

    [[nodiscard]] constexpr copy_options operator&(copy_options _Left, copy_options _Right) noexcept { using _IntTy = ::std:: underlying_type_t<copy_options>; return static_cast<copy_options>(static_cast<_IntTy>(_Left) & static_cast<_IntTy>(_Right)); } [[nodiscard]] constexpr copy_options operator|(copy_options _Left, copy_options _Right) noexcept { using _IntTy = ::std:: underlying_type_t<copy_options>; return static_cast<copy_options>(static_cast<_IntTy>(_Left) | static_cast<_IntTy>(_Right)); } [[nodiscard]] constexpr copy_options operator^(copy_options _Left, copy_options _Right) noexcept { using _IntTy = ::std:: underlying_type_t<copy_options>; return static_cast<copy_options>(static_cast<_IntTy>(_Left) ^ static_cast<_IntTy>(_Right)); } constexpr copy_options& operator&=(copy_options& _Left, copy_options _Right) noexcept { return _Left = _Left & _Right; } constexpr copy_options& operator|=(copy_options& _Left, copy_options _Right) noexcept { return _Left = _Left | _Right; } constexpr copy_options& operator^=(copy_options& _Left, copy_options _Right) noexcept { return _Left = _Left ^ _Right; } [[nodiscard]] constexpr copy_options operator~(copy_options _Left) noexcept { using _IntTy = ::std:: underlying_type_t<copy_options>; return static_cast<copy_options>(~static_cast<_IntTy>(_Left)); } [[nodiscard]] constexpr bool _Bitmask_includes( copy_options _Left, copy_options _Elements) noexcept { return (_Left & _Elements) != copy_options{}; } [[nodiscard]] constexpr bool _Bitmask_includes_all( copy_options _Left, copy_options _Elements) noexcept { return (_Left & _Elements) == _Elements; }

    class file_status {
    public:
        
        file_status() noexcept = default;
        explicit file_status(file_type _Ft, perms _Perms = perms::unknown) noexcept : _Myftype(_Ft), _Myperms(_Perms) {}
        file_status(const file_status&) noexcept = default;
        file_status(file_status&&) noexcept      = default;
        ~file_status() noexcept                  = default;

        
        file_status& operator=(const file_status&) noexcept = default;
        file_status& operator=(file_status&&) noexcept = default;

        
        void type(file_type _Ft) noexcept {
            _Myftype = _Ft;
        }

        void permissions(perms _Perms) noexcept {
            _Myperms = _Perms;
        }

        
        [[nodiscard]] file_type type() const noexcept {
            return _Myftype;
        }

        [[nodiscard]] perms permissions() const noexcept {
            return _Myperms;
        }


        [[nodiscard]] friend bool operator==(const file_status& _Lhs, const file_status& _Rhs) noexcept {
            return _Lhs._Myftype == _Rhs._Myftype && _Lhs._Myperms == _Rhs._Myperms;
        }
#line 1981 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\filesystem"

        void _Refresh(const __std_win_error _Error, const __std_fs_stats& _Stats) noexcept {
            if (_Error == __std_win_error::_Success) {
                const auto _Attrs = _Stats._Attributes;

                if (_Bitmask_includes(_Attrs, __std_fs_file_attr::_Readonly)) {
                    this->permissions(perms::_File_attribute_readonly);
                } else {
                    this->permissions(perms::all);
                }

                if (_Bitmask_includes(_Attrs, __std_fs_file_attr::_Reparse_point)) {
                    if (_Stats._Reparse_point_tag == __std_fs_reparse_tag::_Symlink) {
                        this->type(file_type::symlink);
                        return;
                    }

                    if (_Stats._Reparse_point_tag == __std_fs_reparse_tag::_Mount_point) {
                        this->type(file_type::junction);
                        return;
                    }

                    
                }

                if (_Bitmask_includes(_Attrs, __std_fs_file_attr::_Directory)) {
                    this->type(file_type::directory);
                } else {
                    this->type(file_type::regular);
                }

                return;
            }

            this->permissions(perms::unknown);
            this->type(__std_is_file_not_found(_Error) ? file_type::not_found : file_type::none);
        }

    private:
        file_type _Myftype = file_type::none;
        perms _Myperms     = perms::unknown;
    };

    [[nodiscard]] inline bool exists(
        const file_status _Status) noexcept { 
        switch (_Status.type()) {
        case file_type::none:
        case file_type::not_found:
            return false;
        case file_type::regular:
        case file_type::directory:
        case file_type::symlink:
        case file_type::block:
        case file_type::character:
        case file_type::fifo:
        case file_type::socket:
        case file_type::unknown:
        case file_type::junction:
        default:
            return true;
        }
    }

    [[nodiscard]] inline bool is_block_file(const file_status _Status) noexcept {
        
        return _Status.type() == file_type::block;
    }

    [[nodiscard]] inline bool is_character_file(const file_status _Status) noexcept {
        
        return _Status.type() == file_type::character;
    }

    [[nodiscard]] inline bool is_directory(const file_status _Status) noexcept {
        
        return _Status.type() == file_type::directory;
    }

    [[nodiscard]] inline bool is_fifo(const file_status _Status) noexcept {
        
        return _Status.type() == file_type::fifo;
    }

    [[nodiscard]] inline bool is_other(const file_status _Status) noexcept {
        
        switch (_Status.type()) {
        case file_type::none:
        case file_type::not_found:
        case file_type::regular:
        case file_type::directory:
        case file_type::symlink:
            return false;
        case file_type::block:
        case file_type::character:
        case file_type::fifo:
        case file_type::socket:
        case file_type::unknown:
        case file_type::junction:
        default:
            return true;
        }
    }

    [[nodiscard]] inline bool is_regular_file(const file_status _Status) noexcept {
        
        return _Status.type() == file_type::regular;
    }

    [[nodiscard]] inline bool is_socket(const file_status _Status) noexcept {
        
        return _Status.type() == file_type::socket;
    }

    [[nodiscard]] inline bool is_symlink(const file_status _Status) noexcept {
        
        return _Status.type() == file_type::symlink;
    }

    struct _File_status_and_error {
        file_status _Status;
        __std_win_error _Error;

        [[nodiscard]] bool _Not_good() const noexcept {
            
            
            return _Error != __std_win_error::_Success && _Status.type() != file_type::not_found
                && _Status.type() != file_type::unknown;
        }
    };

    inline constexpr auto _Status_stats_flags =
        __std_fs_stats_flags::_Attributes | __std_fs_stats_flags::_Follow_symlinks;

    inline constexpr auto _Symlink_status_stats_flags =
        __std_fs_stats_flags::_Attributes | __std_fs_stats_flags::_Reparse_tag;


    using file_time_type = ::std::chrono:: time_point<::std::chrono:: file_clock>;


#line 2122 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\filesystem"

    class directory_entry {
    public:
        
        directory_entry() noexcept : _Cached_data{}, _Path() {}

        directory_entry(const directory_entry&)     = default;
        directory_entry(directory_entry&&) noexcept = default;
        explicit directory_entry(const filesystem::path& _Path_arg) : _Cached_data{}, _Path(_Path_arg) {
            (void) _Refresh(_Cached_data, _Path);
        }

        directory_entry(const filesystem::path& _Path_arg, error_code& _Ec) : _Cached_data{}, _Path(_Path_arg) {
            _Ec.clear();
            (void) _Refresh(_Cached_data, _Path);
        }

        ~directory_entry() = default;

        
        directory_entry& operator=(const directory_entry&) = default;
        directory_entry& operator=(directory_entry&&) noexcept = default;

        
        void assign(const filesystem::path& _Path_arg) {
            _Path.assign(_Path_arg);
            (void) _Refresh(_Cached_data, _Path);
        }

        void assign(const filesystem::path& _Path_arg, error_code& _Ec) {
            _Ec.clear(); 
            _Path.assign(_Path_arg);
            (void) _Refresh(_Cached_data, _Path);
        }

        void replace_filename(const filesystem::path& _Path_arg) {
            _Path.replace_filename(_Path_arg);
            (void) _Refresh(_Cached_data, _Path);
        }

        void replace_filename(const filesystem::path& _Path_arg, error_code& _Ec) {
            _Ec.clear(); 
            _Path.replace_filename(_Path_arg);
            (void) _Refresh(_Cached_data, _Path);
        }

        void refresh() {
            const auto _Error = _Refresh(_Cached_data, _Path);
            if (_Error != __std_win_error::_Success) {
                _Throw_fs_error("directory_entry::refresh", _Error, _Path);
            }
        }

        void refresh(error_code& _Ec) noexcept {
            _Ec = _Make_ec(_Refresh(_Cached_data, _Path));
        }


        void clear_cache() noexcept {
            _Cached_data._Available = __std_fs_stats_flags::_None;
        }
#line 2184 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\filesystem"

    private:
        [[nodiscard]] bool _Has_cached_attribute(const __std_fs_file_attr _Attrs) const noexcept {
            return _Bitmask_includes(_Cached_data._Attributes, _Attrs);
        }

    public:
        
        [[nodiscard]] const filesystem::path& path() const noexcept {
            return _Path;
        }

        operator const filesystem::path&() const noexcept {
            return _Path;
        }

        [[nodiscard]] bool exists() const {
            const auto _Type = this->status().type();
            return _Type != file_type::not_found && _Type != file_type::none;
        }

        [[nodiscard]] bool exists(error_code& _Ec) const noexcept {
            const auto _Type = this->status(_Ec).type();
            return _Type != file_type::not_found && _Type != file_type::none;
        }

        [[nodiscard]] bool is_block_file() const {
            return false;
        }

        [[nodiscard]] bool is_block_file(error_code& _Ec) const noexcept {
            _Ec.clear();
            return false;
        }

        [[nodiscard]] bool is_character_file() const {
            return false;
        }

        [[nodiscard]] bool is_character_file(error_code& _Ec) const noexcept {
            _Ec.clear();
            return false;
        }

        [[nodiscard]] bool is_directory() const {
            return ::std:: filesystem::is_directory(this->status());
        }

        [[nodiscard]] bool is_directory(error_code& _Ec) const noexcept {
            return ::std:: filesystem::is_directory(this->status(_Ec));
        }

        [[nodiscard]] bool is_fifo() const {
            return false;
        }

        [[nodiscard]] bool is_fifo(error_code& _Ec) const noexcept {
            _Ec.clear();
            return false;
        }

        [[nodiscard]] bool is_other() const {
            return ::std:: filesystem::is_other(this->status());
        }

        [[nodiscard]] bool is_other(error_code& _Ec) const noexcept {
            return ::std:: filesystem::is_other(this->status(_Ec));
        }

        [[nodiscard]] bool is_regular_file() const {
            return ::std:: filesystem::is_regular_file(this->status());
        }

        [[nodiscard]] bool is_regular_file(error_code& _Ec) const noexcept {
            return ::std:: filesystem::is_regular_file(this->status(_Ec));
        }

        [[nodiscard]] bool is_socket() const {
            return false;
        }

        [[nodiscard]] bool is_socket(error_code& _Ec) const noexcept {
            _Ec.clear();
            return false;
        }

        [[nodiscard]] bool _Is_symlink_or_junction() const noexcept {
            return _Has_cached_attribute(__std_fs_file_attr::_Reparse_point)
                && (_Cached_data._Reparse_point_tag == __std_fs_reparse_tag::_Symlink
                    || _Cached_data._Reparse_point_tag == __std_fs_reparse_tag::_Mount_point);
        }

        [[nodiscard]] bool is_symlink() const {
            return ::std:: filesystem::is_symlink(this->symlink_status());
        }

        [[nodiscard]] bool is_symlink(error_code& _Ec) const noexcept {
            return ::std:: filesystem::is_symlink(this->symlink_status(_Ec));
        }

        [[nodiscard]] bool _Available(const __std_fs_stats_flags _Flags) const noexcept {
            return _Bitmask_includes(_Cached_data._Available, _Flags);
        }

    private:
        [[nodiscard]] __std_win_error _File_size(uintmax_t& _Result) const noexcept {
            if (_Available(__std_fs_stats_flags::_File_size)) {
                _Result = _Cached_data._File_size;
                return __std_win_error::_Success;
            }

            __std_fs_stats _Stats;
            constexpr auto _Flags = __std_fs_stats_flags::_File_size | __std_fs_stats_flags::_Follow_symlinks;
            const auto _Error =
                __std_fs_get_stats(_Path.c_str(), &_Stats, _Flags, _Cached_data._Symlink_hint_attributes());
            if (_Error == __std_win_error::_Success) {
                _Result = _Stats._File_size;
            } else {
                _Result = static_cast<uintmax_t>(-1);
            }

            return _Error;
        }

    public:
        [[nodiscard]] uintmax_t file_size() const {
            uintmax_t _Result;
            const auto _Error = _File_size(_Result);
            if (_Error != __std_win_error::_Success) {
                _Throw_fs_error("directory_entry::file_size", _Error, _Path);
            }

            return _Result;
        }

        [[nodiscard]] uintmax_t file_size(error_code& _Ec) const noexcept {
            uintmax_t _Result;
            _Ec = _Make_ec(_File_size(_Result));
            return _Result;
        }

    private:
        [[nodiscard]] __std_win_error _Hard_link_count(uintmax_t& _Result) const noexcept {
            if (_Available(__std_fs_stats_flags::_Link_count)) {
                _Result = _Cached_data._Link_count;
                return __std_win_error::_Success;
            }

            __std_fs_stats _Stats;
            constexpr auto _Flags = __std_fs_stats_flags::_Link_count | __std_fs_stats_flags::_Follow_symlinks;
            const auto _Error =
                __std_fs_get_stats(_Path.c_str(), &_Stats, _Flags, _Cached_data._Symlink_hint_attributes());
            if (_Error == __std_win_error::_Success) {
                _Result = _Stats._Link_count;
            } else {
                _Result = static_cast<uintmax_t>(-1);
            }

            return _Error;
        }

    public:
        [[nodiscard]] uintmax_t hard_link_count() const {
            uintmax_t _Result;
            const auto _Error = _Hard_link_count(_Result);
            if (_Error != __std_win_error::_Success) {
                _Throw_fs_error("directory_entry::hard_link_count", _Error, _Path);
            }

            return _Result;
        }

        [[nodiscard]] uintmax_t hard_link_count(error_code& _Ec) const noexcept {
            uintmax_t _Result;
            _Ec = _Make_ec(_Hard_link_count(_Result));
            return _Result;
        }

    private:
        [[nodiscard]] __std_win_error _Last_write_time(file_time_type& _Result) const noexcept {
            if (_Available(__std_fs_stats_flags::_Last_write_time)) {
                _Result = file_time_type{file_time_type::duration{_Cached_data._Last_write_time}};
                return __std_win_error::_Success;
            }

            __std_fs_stats _Stats;
            constexpr auto _Flags = __std_fs_stats_flags::_Last_write_time | __std_fs_stats_flags::_Follow_symlinks;
            const auto _Error =
                __std_fs_get_stats(_Path.c_str(), &_Stats, _Flags, _Cached_data._Symlink_hint_attributes());
            if (_Error == __std_win_error::_Success) {
                _Result = file_time_type{file_time_type::duration{_Stats._Last_write_time}};
            } else {
                _Result = file_time_type{file_time_type::duration{(-9223372036854775807i64 - 1)}};
            }

            return _Error;
        }

    public:
        [[nodiscard]] file_time_type last_write_time() const {
            file_time_type _Result;
            const auto _Error = _Last_write_time(_Result);
            if (_Error != __std_win_error::_Success) {
                _Throw_fs_error("directory_entry::last_write_time", _Error, _Path);
            }

            return _Result;
        }

        [[nodiscard]] file_time_type last_write_time(error_code& _Ec) const noexcept {
            file_time_type _Result;
            _Ec = _Make_ec(_Last_write_time(_Result));
            return _Result;
        }

    private:
        [[nodiscard]] _File_status_and_error _Get_any_status(const __std_fs_stats_flags _Flags) const noexcept {
            _File_status_and_error _Result;
            __std_fs_stats _Stats;

            if (_Bitmask_includes_all(_Cached_data._Available, _Flags)) {
                _Result._Error = __std_win_error::_Success;
                _Result._Status._Refresh(__std_win_error::_Success, _Cached_data);
            } else {
                const auto _Error =
                    __std_fs_get_stats(_Path.c_str(), &_Stats, _Flags, _Cached_data._Symlink_hint_attributes());
                _Result._Error = _Error;
                _Result._Status._Refresh(_Error, _Stats);
            }

            return _Result;
        }

    public:
        [[nodiscard]] file_status status() const {
            const auto _Result = _Get_any_status(_Status_stats_flags);
            if (_Result._Not_good()) {
                _Throw_fs_error("directory_entry::status", _Result._Error, _Path);
            }

            return _Result._Status;
        }

        [[nodiscard]] file_status status(error_code& _Ec) const noexcept {
            const auto _Result = _Get_any_status(_Status_stats_flags);
            _Ec                = _Make_ec(_Result._Error);
            return _Result._Status;
        }

        [[nodiscard]] file_status symlink_status() const {
            const auto _Result = _Get_any_status(_Symlink_status_stats_flags);
            if (_Result._Not_good()) {
                _Throw_fs_error("directory_entry::symlink_status", _Result._Error, _Path);
            }

            return _Result._Status;
        }

        [[nodiscard]] file_status symlink_status(error_code& _Ec) const noexcept {
            const auto _Result = _Get_any_status(_Symlink_status_stats_flags);
            _Ec                = _Make_ec(_Result._Error);
            return _Result._Status;
        }

        [[nodiscard]] bool operator==(const directory_entry& _Rhs) const noexcept {
            return _Path == _Rhs._Path;
        }


        [[nodiscard]] strong_ordering operator<=>(const directory_entry& _Rhs) const noexcept {
            return _Path <=> _Rhs._Path;
        }


#line 2477 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\filesystem"

        
        template <class _Elem, class _Traits>
        friend ::std:: basic_ostream<_Elem, _Traits>& operator<<( 
            ::std:: basic_ostream<_Elem, _Traits>& _Ostr, const directory_entry& _Entry) { 
            
            return _Ostr << _Entry.path();
        }

    private:
        void _Refresh(const __std_fs_find_data& _Data) noexcept {
            _Cached_data._Attributes        = _Data._Attributes;
            _Cached_data._Reparse_point_tag = _Data._Reparse_point_tag;
            _Cached_data._Available         = __std_fs_stats_flags::_Attributes | __std_fs_stats_flags::_Reparse_tag;
            if (!_Bitmask_includes(_Data._Attributes, __std_fs_file_attr::_Reparse_point)) {
                _Cached_data._File_size = (static_cast<uintmax_t>(_Data._File_size_high) << 32)
                                        + static_cast<uintmax_t>(_Data._File_size_low);
                :: memcpy(
                    &_Cached_data._Last_write_time, &_Data._Last_write_time, sizeof(_Cached_data._Last_write_time));
                _Cached_data._Available |= __std_fs_stats_flags::_File_size | __std_fs_stats_flags::_Last_write_time;
            }
        }

        [[nodiscard]] static __std_win_error _Refresh(__std_fs_stats& _Stats, const filesystem::path& _Path) noexcept {
            const auto _Error = __std_fs_get_stats(_Path.c_str(), &_Stats, __std_fs_stats_flags::_All_data);
            if (_Error == __std_win_error::_Success) {
                if (_Bitmask_includes(_Stats._Attributes, __std_fs_file_attr::_Reparse_point)) {
                    _Stats._Available = __std_fs_stats_flags::_Attributes | __std_fs_stats_flags::_Reparse_tag;
                } else {
                    _Stats._Available = __std_fs_stats_flags::_All_data;
                }
            } else {
                _Stats._Available = __std_fs_stats_flags::_None;
            }

            return _Error;
        }

        friend struct _Dir_enum_impl;
        friend struct _Recursive_dir_enum_impl;
        friend void _Copy_impl(
            const directory_entry& _From, const ::std:: filesystem::path& _To, copy_options _Options, error_code& _Ec);

        __std_fs_stats _Cached_data;
        filesystem::path _Path;
    };

    enum class directory_options { none = 0, follow_directory_symlink = 1, skip_permission_denied = 2 };
    [[nodiscard]] constexpr directory_options operator&(directory_options _Left, directory_options _Right) noexcept { using _IntTy = ::std:: underlying_type_t<directory_options>; return static_cast<directory_options>(static_cast<_IntTy>(_Left) & static_cast<_IntTy>(_Right)); } [[nodiscard]] constexpr directory_options operator|(directory_options _Left, directory_options _Right) noexcept { using _IntTy = ::std:: underlying_type_t<directory_options>; return static_cast<directory_options>(static_cast<_IntTy>(_Left) | static_cast<_IntTy>(_Right)); } [[nodiscard]] constexpr directory_options operator^(directory_options _Left, directory_options _Right) noexcept { using _IntTy = ::std:: underlying_type_t<directory_options>; return static_cast<directory_options>(static_cast<_IntTy>(_Left) ^ static_cast<_IntTy>(_Right)); } constexpr directory_options& operator&=(directory_options& _Left, directory_options _Right) noexcept { return _Left = _Left & _Right; } constexpr directory_options& operator|=(directory_options& _Left, directory_options _Right) noexcept { return _Left = _Left | _Right; } constexpr directory_options& operator^=(directory_options& _Left, directory_options _Right) noexcept { return _Left = _Left ^ _Right; } [[nodiscard]] constexpr directory_options operator~(directory_options _Left) noexcept { using _IntTy = ::std:: underlying_type_t<directory_options>; return static_cast<directory_options>(~static_cast<_IntTy>(_Left)); } [[nodiscard]] constexpr bool _Bitmask_includes( directory_options _Left, directory_options _Elements) noexcept { return (_Left & _Elements) != directory_options{}; } [[nodiscard]] constexpr bool _Bitmask_includes_all( directory_options _Left, directory_options _Elements) noexcept { return (_Left & _Elements) == _Elements; }

    struct _Dir_enum_impl {
        [[nodiscard]] static __std_win_error _Advance_and_reset_if_no_more_files(shared_ptr<_Dir_enum_impl>& _Ptr) {
            auto& _Impl = *_Ptr;
            __std_fs_find_data _Data;
            do {
                const auto _Error = __std_fs_directory_iterator_advance(_Impl._Dir._Handle, &_Data);
                if (_Error == __std_win_error::_No_more_files) {
                    _Ptr.reset();
                    return __std_win_error::_Success;
                }

                if (_Error != __std_win_error::_Success) {
                    return _Error;
                }
            } while (_Is_dot_or_dotdot(_Data));
            _Impl._Refresh(_Data); 
            return __std_win_error::_Success;
        }

        [[nodiscard]] static __std_win_error _Skip_dots(
            __std_fs_dir_handle _Dir_handle, __std_fs_find_data& _Data) noexcept {
            while (_Is_dot_or_dotdot(_Data)) {
                const auto _Error = __std_fs_directory_iterator_advance(_Dir_handle, &_Data);
                if (_Error != __std_win_error::_Success) {
                    return _Error;
                }
            }

            return __std_win_error::_Success;
        }

        [[nodiscard]] static __std_win_error _Open_dir(
            path& _Path, const directory_options _Options_arg, _Find_file_handle& _Dir, __std_fs_find_data& _Data) {
            const size_t _Null_term_len = :: wcslen(_Path.c_str());
            if (_Null_term_len == 0 || _Null_term_len != _Path.native().size()) {
                return __std_win_error::_File_not_found;
            }

            _Path /= L"*"sv;
            auto _Error = _Dir._Open(_Path.c_str(), &_Data);
            if (_Error == __std_win_error::_Success) {
                return _Skip_dots(_Dir._Handle, _Data);
            }

            if (_Error == __std_win_error::_Access_denied
                && _Bitmask_includes(_Options_arg, directory_options::skip_permission_denied)) {
                _Error = __std_win_error::_No_more_files;
            }

            return _Error;
        }

        struct _Creator { 
            path _Path;
            _Find_file_handle _Dir;
            __std_fs_find_data _Find_data;

            struct _Create_status {
                bool _Should_create_impl;
                __std_win_error _Error;
            };

            _Create_status _Status;

            _Creator(const path& _Path_arg, const directory_options _Options) : _Path(_Path_arg) {
                const auto _Error = _Open_dir(_Path, _Options, _Dir, _Find_data);
                if (_Error == __std_win_error::_Success) {
                    _Status = {true, __std_win_error::_Success};
                } else if (_Error == __std_win_error::_No_more_files) {
                    _Status = {false, __std_win_error::_Success};
                } else {
                    _Status = {false, _Error};
                }
            }
        };

        void _Refresh(const __std_fs_find_data& _Data) {
            _Entry._Refresh(_Data);
            _Entry._Path.replace_filename(wstring_view{_Data._File_name});
        }

        explicit _Dir_enum_impl(_Creator&& _Create_data, const directory_options = {})
            : _Dir(::std:: move(_Create_data._Dir)) {
            
            _Entry._Path = ::std:: move(_Create_data._Path);
            _Refresh(_Create_data._Find_data);
        }

        template <class _Dir_enum_kind>
        [[nodiscard]] static __std_win_error _Initialize_dir_enum(
            shared_ptr<_Dir_enum_kind>& _Impl, const path& _Path, const directory_options _Options = {}) {
            _Creator _Create_data(_Path, _Options);
            if (_Create_data._Status._Should_create_impl) {
                _Impl = ::std:: make_shared<_Dir_enum_kind>(::std:: move(_Create_data), _Options);
            }
            return _Create_data._Status._Error;
        }

        directory_entry _Entry;
        _Find_file_handle _Dir;
    };

    class directory_iterator;
    class recursive_directory_iterator;

    struct _Directory_entry_proxy {
        [[nodiscard]] directory_entry operator*() && noexcept {
            return ::std:: move(_Entry);
        }

    private:
        friend directory_iterator;
        friend recursive_directory_iterator;

        explicit _Directory_entry_proxy(const directory_entry& _Entry_arg) : _Entry(_Entry_arg) {}

        directory_entry _Entry;
    };

    class directory_iterator {
    public:
        using iterator_category = input_iterator_tag;
        using value_type        = directory_entry;
        using difference_type   = ptrdiff_t;
        using pointer           = const directory_entry*;
        using reference         = const directory_entry&;

        
        directory_iterator() noexcept = default;
        explicit directory_iterator(const path& _Path) {
            const auto _Error = _Dir_enum_impl::_Initialize_dir_enum(_Impl, _Path);
            if (_Error != __std_win_error::_Success) {
                _Throw_fs_error("directory_iterator::directory_iterator", _Error, _Path);
            }
        }

        directory_iterator(const path& _Path, const directory_options _Options) {
            const auto _Error = _Dir_enum_impl::_Initialize_dir_enum(_Impl, _Path, _Options);
            if (_Error != __std_win_error::_Success) {
                _Throw_fs_error("directory_iterator::directory_iterator", _Error, _Path);
            }
        }

        directory_iterator(const path& _Path, error_code& _Ec) {
            _Ec = _Make_ec(_Dir_enum_impl::_Initialize_dir_enum(_Impl, _Path));
        }

        directory_iterator(const path& _Path, const directory_options _Options, error_code& _Ec) {
            _Ec = _Make_ec(_Dir_enum_impl::_Initialize_dir_enum(_Impl, _Path, _Options));
        }

        directory_iterator(const directory_iterator&) noexcept = default; 
        directory_iterator(directory_iterator&&) noexcept      = default;
        ~directory_iterator() noexcept                         = default;

        directory_iterator& operator=(const directory_iterator&) noexcept = default; 
        directory_iterator& operator=(directory_iterator&&) noexcept = default;

        [[nodiscard]] const directory_entry& operator*() const noexcept  {
            return _Impl->_Entry;
        }

        [[nodiscard]] const directory_entry* operator->() const noexcept  {
            return &**this;
        }

        directory_iterator& operator++() {
            const auto _Error = _Dir_enum_impl::_Advance_and_reset_if_no_more_files(_Impl);
            if (_Error != __std_win_error::_Success) {
                _Throw_fs_error("directory_iterator::operator++", _Error);
            }

            return *this;
        }

        directory_iterator& increment(error_code& _Ec) {
            _Ec = _Make_ec(_Dir_enum_impl::_Advance_and_reset_if_no_more_files(_Impl));
            return *this;
        }

        
        [[nodiscard]] bool operator==(const directory_iterator& _Rhs) const noexcept  {
            return _Impl == _Rhs._Impl;
        }


#line 2717 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\filesystem"

        _Directory_entry_proxy operator++(int) {
            _Directory_entry_proxy _Proxy(**this);
            ++*this;
            return _Proxy;
        }

        [[nodiscard]] bool _At_end() const noexcept {
            return !_Impl;
        }

    private:
        shared_ptr<_Dir_enum_impl> _Impl;
    };

    [[nodiscard]] inline directory_iterator begin(directory_iterator _Iter) noexcept {
        return _Iter;
    }

    [[nodiscard]] inline directory_iterator end(directory_iterator) noexcept {
        return {};
    }

    struct _Should_recurse_result {
        bool _Should_recurse;
        __std_win_error _Error;
    };

    struct _Recursive_dir_enum_impl : _Dir_enum_impl {
        vector<_Find_file_handle> _Stack;
        directory_options _Options = {};
        bool _Recursion_pending    = true;

        [[nodiscard]] _Should_recurse_result _Should_recurse() const noexcept {
            bool _Should_recurse   = false;
            __std_win_error _Error = __std_win_error::_Success;
            if (_Recursion_pending) {
                if (_Entry._Is_symlink_or_junction()) {
                    if (_Bitmask_includes(_Options, directory_options::follow_directory_symlink)) {
                        
                        __std_fs_stats _Target_stats;
                        constexpr auto _Flags =
                            __std_fs_stats_flags::_Attributes | __std_fs_stats_flags::_Follow_symlinks;
                        _Error = __std_fs_get_stats(
                            _Entry._Path.c_str(), &_Target_stats, _Flags, _Entry._Cached_data._Attributes);
                        if (_Error == __std_win_error::_Success) {
                            _Should_recurse =
                                _Bitmask_includes(_Target_stats._Attributes, __std_fs_file_attr::_Directory);
                        } else if (__std_is_file_not_found(_Error)
                                   || (_Error == __std_win_error::_Access_denied
                                       && _Bitmask_includes(_Options, directory_options::skip_permission_denied))) {
                            
                            _Error = __std_win_error::_Success;
                        }
                    }
                } else {
                    _Should_recurse = _Entry._Has_cached_attribute(__std_fs_file_attr::_Directory);
                }
            }

            return {_Should_recurse, _Error};
        }

        [[nodiscard]] __std_win_error _Advance_and_skip_dots(__std_fs_find_data& _Data) noexcept {
            const auto _Error = __std_fs_directory_iterator_advance(_Dir._Handle, &_Data);
            if (_Error != __std_win_error::_Success) {
                return _Error;
            }

            return _Skip_dots(_Dir._Handle, _Data);
        }

        [[nodiscard]] static __std_win_error _Pop_and_reset_if_no_more_files(shared_ptr<_Recursive_dir_enum_impl>& _Ptr) {
            __std_win_error _Error;
            auto& _Impl = *_Ptr;
            __std_fs_find_data _Data;

            _Impl._Recursion_pending = true;

            do {
                if (_Impl._Stack.empty()) {
                    _Error = __std_win_error::_Success;
                    break;
                }

                _Impl._Dir = ::std:: move(_Impl._Stack.back());
                _Impl._Stack.pop_back();
                _Impl._Entry._Path._Remove_filename_and_separator();
                _Error = _Impl._Advance_and_skip_dots(_Data);

                if (_Error == __std_win_error::_Success) {
                    _Impl._Refresh(_Data);
                    return __std_win_error::_Success;
                }
            } while (_Error == __std_win_error::_No_more_files);

            _Ptr.reset();
            return _Error;
        }

        [[nodiscard]] static __std_win_error _Advance_and_reset_if_no_more_files(
            shared_ptr<_Recursive_dir_enum_impl>& _Ptr) {
            auto& _Impl = *_Ptr;
            __std_fs_find_data _Data;
            auto [_Should_recurse, _Error] = _Impl._Should_recurse();
            if (_Error != __std_win_error::_Success) {
                _Ptr.reset();
                return _Error;
            }

            if (_Should_recurse) {
                _Impl._Stack.push_back(::std:: move(_Impl._Dir));
                _Error = _Open_dir(_Impl._Entry._Path, _Impl._Options, _Impl._Dir, _Data);
            } else {
                _Error = _Impl._Advance_and_skip_dots(_Data);
            }

            _Impl._Recursion_pending = true;
            for (;; _Error = _Impl._Advance_and_skip_dots(_Data)) {
                if (_Error == __std_win_error::_Success) {
                    _Impl._Refresh(_Data);
                    return __std_win_error::_Success;
                }

                if (_Error != __std_win_error::_No_more_files) {
                    break;
                }

                
                if (_Impl._Stack.empty()) { 
                    _Error = __std_win_error::_Success;
                    break;
                }

                _Impl._Dir = ::std:: move(_Impl._Stack.back());
                _Impl._Stack.pop_back();
                _Impl._Entry._Path._Remove_filename_and_separator();
            }

            _Ptr.reset();
            return _Error;
        }

        _Recursive_dir_enum_impl(_Dir_enum_impl::_Creator&& _Create_data, const directory_options _Options_arg)
            : _Dir_enum_impl(::std:: move(_Create_data)), _Options(_Options_arg) {}
    };

    class recursive_directory_iterator {
    public:
        using iterator_category = input_iterator_tag;
        using value_type        = directory_entry;
        using difference_type   = ptrdiff_t;
        using pointer           = const directory_entry*;
        using reference         = const directory_entry&;

        
        recursive_directory_iterator() noexcept = default;
        explicit recursive_directory_iterator(const path& _Path) {
            const auto _Error = _Dir_enum_impl::_Initialize_dir_enum(_Impl, _Path);
            if (_Error != __std_win_error::_Success) {
                _Throw_fs_error("recursive_directory_iterator::recursive_directory_iterator", _Error, _Path);
            }
        }

        recursive_directory_iterator(const path& _Path, const directory_options _Options) {
            const auto _Error = _Dir_enum_impl::_Initialize_dir_enum(_Impl, _Path, _Options);
            if (_Error != __std_win_error::_Success) {
                _Throw_fs_error("recursive_directory_iterator::recursive_directory_iterator", _Error, _Path);
            }
        }

        recursive_directory_iterator(const path& _Path, const directory_options _Options, error_code& _Ec) {
            _Ec = _Make_ec(_Dir_enum_impl::_Initialize_dir_enum(_Impl, _Path, _Options));
        }

        recursive_directory_iterator(const path& _Path, error_code& _Ec) {
            _Ec = _Make_ec(_Dir_enum_impl::_Initialize_dir_enum(_Impl, _Path));
        }

        recursive_directory_iterator(const recursive_directory_iterator&) noexcept = default; 
        recursive_directory_iterator(recursive_directory_iterator&&) noexcept      = default;
        ~recursive_directory_iterator() noexcept                                   = default;

        
        [[nodiscard]] directory_options options() const noexcept  {
            return _Impl->_Options;
        }
        [[nodiscard]] int depth() const noexcept  {
            
            
            return static_cast<int>(_Impl->_Stack.size());
        }
        [[nodiscard]] bool recursion_pending() const noexcept  {
            return _Impl->_Recursion_pending;
        }

        [[nodiscard]] const directory_entry& operator*() const noexcept  {
            return _Impl->_Entry;
        }

        [[nodiscard]] const directory_entry* operator->() const noexcept  {
            return &**this;
        }

        
        recursive_directory_iterator& operator=(recursive_directory_iterator&&) noexcept = default;
        recursive_directory_iterator& operator=(const recursive_directory_iterator&) noexcept = default; 

        recursive_directory_iterator& operator++() {
            const auto _Error = _Recursive_dir_enum_impl::_Advance_and_reset_if_no_more_files(_Impl);
            if (_Error != __std_win_error::_Success) {
                _Throw_fs_error("recursive_directory_iterator::operator++", _Error);
            }
            return *this;
        }

        recursive_directory_iterator& increment(error_code& _Ec) {
            _Ec = _Make_ec(_Recursive_dir_enum_impl::_Advance_and_reset_if_no_more_files(_Impl));
            return *this;
        }

        void pop() {
            const auto _Error = _Recursive_dir_enum_impl::_Pop_and_reset_if_no_more_files(_Impl);
            if (_Error != __std_win_error::_Success) {
                _Throw_fs_error("recursive_directory_iterator::pop", _Error);
            }
        }

        void pop(error_code& _Ec) {
            _Ec = _Make_ec(_Recursive_dir_enum_impl::_Pop_and_reset_if_no_more_files(_Impl));
        }

        void disable_recursion_pending() noexcept {
            _Impl->_Recursion_pending = false;
        }

        
        [[nodiscard]] bool operator==(const recursive_directory_iterator& _Rhs) const noexcept {
            return _Impl == _Rhs._Impl;
        }


#line 2967 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\filesystem"

        _Directory_entry_proxy operator++(int) {
            _Directory_entry_proxy _Proxy(**this);
            ++*this;
            return _Proxy;
        }

    private:
        shared_ptr<_Recursive_dir_enum_impl> _Impl;
    };

    [[nodiscard]] inline recursive_directory_iterator begin(recursive_directory_iterator _Iter) noexcept {
        return _Iter;
    }

    [[nodiscard]] inline recursive_directory_iterator end(recursive_directory_iterator) noexcept {
        return {};
    }

    [[nodiscard]] inline __std_win_error _Absolute(path& _Result, const wstring& _Text) { 
        if (_Text.empty()) {
            return __std_win_error::_Success;
        }

        _Result._Text.resize(__std_fs_max_path);
        __std_win_error _Err;
        for (;;) {
            const auto _Requested_size = static_cast<unsigned long>(_Result._Text.size());
            const auto _Full_path_result =
                __std_fs_get_full_path_name(_Text.c_str(), _Requested_size, _Result._Text.data());
            _Err = _Full_path_result._Error;
            _Result._Text.resize(_Full_path_result._Size);
            if (_Full_path_result._Size < _Requested_size) {
                break;
            }
        }

        return _Err;
    }

    [[nodiscard]] inline path absolute(const path& _Input) {
        
        
        path _Result;
        const auto _Err = _Absolute(_Result, _Input.native());
        if (_Err != __std_win_error::_Success) {
            _Throw_fs_error("absolute", _Err, _Input);
        }

        return _Result;
    }

    [[nodiscard]] inline path absolute(const path& _Input, error_code& _Ec) {
        
        
        _Ec.clear(); 
        path _Result;
        _Ec = _Make_ec(_Absolute(_Result, _Input.native()));
        return _Result;
    }

    [[nodiscard]] inline __std_win_error _Canonical(path& _Result, const wstring& _Text) { 
        if (_Text.empty()) {
            return __std_win_error::_Success;
        }

        auto _Name_kind = __std_fs_volume_name_kind::_Dos;
        {
            __std_win_error _Err;
            const _Fs_file _Handle(_Text.c_str(), __std_access_rights::_File_read_attributes,
                __std_fs_file_flags::_Backup_semantics, &_Err);
            if (_Err != __std_win_error::_Success) {
                return _Err;
            }

            _Result._Text.resize(__std_fs_max_path);
            for (;;) {
                const auto _Requested_size    = static_cast<unsigned long>(_Result._Text.size());
                const auto _Final_path_result = __std_fs_get_final_path_name_by_handle(
                    _Handle._Raw, _Result._Text.data(), _Requested_size, _Name_kind);
                _Err = _Final_path_result._Error;
                if (_Final_path_result._Size == 0) {
                    if (_Err == __std_win_error::_Path_not_found && _Name_kind == __std_fs_volume_name_kind::_Dos) {
                        
                        _Name_kind = __std_fs_volume_name_kind::_Nt;
                        continue;
                    }

                    _Result._Text.clear();
                    return _Err;
                }

                _Result._Text.resize(_Final_path_result._Size);
                if (_Final_path_result._Size < _Requested_size) {
                    break;
                }
            }
        } 

        if (_Name_kind == __std_fs_volume_name_kind::_Dos) {
            if (_Is_drive_prefix_with_slash_slash_question(_Result._Text)) {
                
                _Result._Text.erase(0, 4);
            } else if (_Result._Text._Starts_with(LR"(\\?\UNC\)"sv)) {
                
                _Result._Text.erase(2, 6); 
            }
        } else { 
            _Result._Text.insert(0, LR"(\\?\GLOBALROOT)"sv);
        }

        return __std_win_error::_Success;
    }

    [[nodiscard]] inline path canonical(const path& _Input) {
        
        
        path _Result;
        const auto _Err = _Canonical(_Result, _Input.native());
        if (_Err != __std_win_error::_Success) {
            _Throw_fs_error("canonical", _Err, _Input);
        }

        return _Result;
    }

    [[nodiscard]] inline path canonical(const path& _Input, error_code& _Ec) {
        
        
        _Ec.clear(); 
        path _Result;
        _Ec = _Make_ec(_Canonical(_Result, _Input.native()));
        return _Result;
    }

    [[nodiscard]] inline unique_ptr<wchar_t[]> _Get_cleaned_symlink_target(const path& _To) noexcept {
        
        
        const auto& _To_str = _To.native();
        
        unique_ptr<wchar_t[]> _Cleaned_link(::new (nothrow) wchar_t[_To_str.size() + 1]);
        if (!_Cleaned_link) {
            return _Cleaned_link;
        }

        const auto _First = _To_str.c_str();
        const auto _Last  = _First + _To_str.size();
        auto _Next        = _Find_root_name_end(_First, _Last);
        auto _Dest        = ::std:: replace_copy_if(_First, _Next, _Cleaned_link.get(), _Is_slash, L'\\');
        for (;;) {
            const wchar_t _Ch = *_Next;
            if (_Is_slash(_Ch)) {
                *_Dest = L'\\';
                do {
                    ++_Next;
                } while (_Is_slash(*_Next));
            } else {
                *_Dest = _Ch;
                if (_Ch == L'\0') {
                    break;
                }

                ++_Next;
            }

            ++_Dest;
        }

        return _Cleaned_link;
    }

    inline void create_directory_symlink(const path& _To, const path& _New_symlink) {
        
        const auto _Cleaned = _Get_cleaned_symlink_target(_To);
        if (!_Cleaned) {
            _Xbad_alloc();
        }

        
        const auto _Err = __std_fs_create_directory_symbolic_link(_New_symlink.c_str(), _Cleaned.get());
        if (_Err != __std_win_error::_Success) {
            _Throw_fs_error("create_directory_symlink", _Err, _To, _New_symlink);
        }
    }

    inline void create_directory_symlink(const path& _To, const path& _New_symlink, error_code& _Ec) noexcept {
        
        const auto _Cleaned = _Get_cleaned_symlink_target(_To);
        if (_Cleaned) {
            
            _Ec = _Make_ec(__std_fs_create_directory_symbolic_link(_New_symlink.c_str(), _Cleaned.get()));
        } else {
            _Ec = ::std:: make_error_code(errc::not_enough_memory);
        }
    }

    inline void create_hard_link(const path& _To, const path& _New_hard_link) {
        
        
        const auto _Err = __std_fs_create_hard_link(_New_hard_link.c_str(), _To.c_str());
        if (_Err != __std_win_error::_Success) {
            _Throw_fs_error("create_hard_link", _Err, _To, _New_hard_link);
        }
    }

    inline void create_hard_link(const path& _To, const path& _New_hard_link, error_code& _Ec) noexcept {
        
        
        _Ec = _Make_ec(__std_fs_create_hard_link(_New_hard_link.c_str(), _To.c_str()));
    }

    inline void create_symlink(const path& _To, const path& _New_symlink) {
        
        const auto _Cleaned = _Get_cleaned_symlink_target(_To);
        if (!_Cleaned) {
            _Xbad_alloc();
        }

        
        const auto _Err = __std_fs_create_symbolic_link(_New_symlink.c_str(), _Cleaned.get());
        if (_Err != __std_win_error::_Success) {
            _Throw_fs_error("create_symlink", _Err, _To, _New_symlink);
        }
    }

    inline void create_symlink(const path& _To, const path& _New_symlink, error_code& _Ec) noexcept {
        
        const auto _Cleaned = _Get_cleaned_symlink_target(_To);
        if (_Cleaned) {
            
            _Ec = _Make_ec(__std_fs_create_symbolic_link(_New_symlink.c_str(), _Cleaned.get()));
        } else {
            _Ec = ::std:: make_error_code(errc::not_enough_memory);
        }
    }

    [[nodiscard]] inline __std_win_error _Read_symlink_reparse_data(
        const _Fs_file& _Handle, unique_ptr<char[]>& _Buffer_unique_ptr) noexcept {
        constexpr auto _Buffer_size = 16 * 1024 + sizeof(wchar_t); 

        _Buffer_unique_ptr.reset(::new (nothrow) char[_Buffer_size]);
        if (!_Buffer_unique_ptr) {
            return __std_win_error::_Not_enough_memory;
        }

        const auto _Buffer         = reinterpret_cast<__std_fs_reparse_data_buffer*>(_Buffer_unique_ptr.get());
        const __std_win_error _Err = __std_fs_read_reparse_data_buffer(_Handle._Raw, _Buffer, _Buffer_size);
        if (_Err != __std_win_error::_Success) {
            return _Err;
        }

        return __std_win_error::_Success;
    }

    [[nodiscard]] inline __std_win_error _Read_symlink(const path& _Symlink_path, path& _Result) noexcept {
        __std_win_error _Err;
        unique_ptr<char[]> _Buffer_unique_ptr;
        {
            const _Fs_file _Handle(_Symlink_path.c_str(), __std_access_rights::_File_read_attributes,
                __std_fs_file_flags::_Backup_semantics | __std_fs_file_flags::_Open_reparse_point, &_Err);
            if (_Err != __std_win_error::_Success) {
                return _Err;
            }

            _Err = _Read_symlink_reparse_data(_Handle, _Buffer_unique_ptr);
            if (_Err != __std_win_error::_Success) {
                return _Err;
            }
        } 

        const auto _Buffer = reinterpret_cast<__std_fs_reparse_data_buffer*>(_Buffer_unique_ptr.get());
        unsigned short _Length;
        wchar_t* _Offset;
        _Err = __std_fs_read_name_from_reparse_data_buffer(_Buffer, &_Offset, &_Length);
        if (_Err != __std_win_error::_Success) {
            return _Err;
        }

        _Result._Text.resize(_Length);
        :: memcpy(_Result._Text.data(), _Offset, _Length * sizeof(wchar_t));

        return __std_win_error::_Success;
    }

    [[nodiscard]] inline path read_symlink(const path& _Symlink_path, error_code& _Ec) {
        _Ec.clear();
        path _Result;
        _Ec = _Make_ec(_Read_symlink(_Symlink_path, _Result));
        return _Result;
    }

    [[nodiscard]] inline path read_symlink(const path& _Symlink_path) {
        path _Result;
        const auto _Err = _Read_symlink(_Symlink_path, _Result);
        if (_Err != __std_win_error::_Success) {
            _Throw_fs_error("read_symlink", _Err, _Symlink_path);
        }
        return _Result;
    }

    [[nodiscard]] inline __std_win_error _Copy_symlink(const path& _Symlink, const path& _New_symlink) noexcept {
        __std_win_error _Err;
        unique_ptr<char[]> _Buffer_unique_ptr;
        bool _Is_directory;
        {
            const _Fs_file _Handle(_Symlink.c_str(), __std_access_rights::_File_read_attributes,
                __std_fs_file_flags::_Backup_semantics | __std_fs_file_flags::_Open_reparse_point, &_Err);
            if (_Err != __std_win_error::_Success) {
                return _Err;
            }

            _Err = _Read_symlink_reparse_data(_Handle, _Buffer_unique_ptr);
            if (_Err != __std_win_error::_Success) {
                return _Err;
            }

            unsigned long _File_attributes;
            _Err = __std_fs_get_file_attributes_by_handle(_Handle._Raw, &_File_attributes);
            if (_Err != __std_win_error::_Success) {
                return _Err;
            }

            _Is_directory = (_File_attributes & static_cast<unsigned long>(__std_fs_file_attr::_Directory)) != 0;
        } 

        const auto _Buffer = reinterpret_cast<__std_fs_reparse_data_buffer*>(_Buffer_unique_ptr.get());
        unsigned short _Length;
        wchar_t* _Offset;
        _Err = __std_fs_read_name_from_reparse_data_buffer(_Buffer, &_Offset, &_Length);
        if (_Err != __std_win_error::_Success) {
            return _Err;
        }

        _Offset[_Length] = L'\0';

        if (_Is_directory) {
            _Err = __std_fs_create_directory_symbolic_link(_New_symlink.c_str(), _Offset);
        } else {
            _Err = __std_fs_create_symbolic_link(_New_symlink.c_str(), _Offset);
        }

        return _Err;
    }

    inline void copy_symlink(const path& _Symlink, const path& _New_symlink, error_code& _Ec) {
        _Ec = _Make_ec(_Copy_symlink(_Symlink, _New_symlink));
    }

    inline void copy_symlink(const path& _Symlink, const path& _New_symlink) {
        const auto _Err = _Copy_symlink(_Symlink, _New_symlink);
        if (_Err != __std_win_error::_Success) {
            _Throw_fs_error("copy_symlink", _Err, _Symlink, _New_symlink);
        }
    }

    inline bool copy_file(const path& _From, const path& _To, const copy_options _Options, error_code& _Ec) noexcept
     {
        
        const auto _Result =
            __std_fs_copy_file(_From.c_str(), _To.c_str(), static_cast<__std_fs_copy_options>(_Options));
        _Ec = _Make_ec(_Result._Error);
        return _Result._Copied;
    }

    inline bool copy_file(const path& _From, const path& _To, const copy_options _Options) {
        
        const auto _Result =
            __std_fs_copy_file(_From.c_str(), _To.c_str(), static_cast<__std_fs_copy_options>(_Options));
        if (_Result._Error != __std_win_error::_Success) {
            _Throw_fs_error("copy_file", _Result._Error, _From, _To);
        }

        return _Result._Copied;
    }

    inline bool copy_file(const path& _From, const path& _To, error_code& _Ec) noexcept  {
        
        return ::std:: filesystem::copy_file(_From, _To, copy_options::none, _Ec);
    }

    inline bool copy_file(const path& _From, const path& _To) {
        
        return ::std:: filesystem::copy_file(_From, _To, copy_options::none);
    }

    [[nodiscard]] inline pair<__std_win_error, bool> _Equivalent(
        const wchar_t* const _Lhs, const wchar_t* const _Rhs) noexcept {
        __std_fs_file_id _Left_id;
        __std_fs_file_id _Right_id;
        auto _Last_error = __std_fs_get_file_id(&_Left_id, _Lhs);
        if (_Last_error != __std_win_error::_Success) {
            return {_Last_error, false};
        }

        _Last_error = __std_fs_get_file_id(&_Right_id, _Rhs);
        if (_Last_error != __std_win_error::_Success) {
            return {_Last_error, false};
        }

        return {__std_win_error::_Success, :: memcmp(&_Left_id, &_Right_id, sizeof(__std_fs_file_id)) == 0};
    }

    [[nodiscard]] inline bool equivalent(const path& _Lhs, const path& _Rhs) {
        
        const auto _Result = _Equivalent(_Lhs.c_str(), _Rhs.c_str());
        if (_Result.first != __std_win_error::_Success) {
            _Throw_fs_error("equivalent", _Result.first, _Lhs, _Rhs);
        }

        return _Result.second;
    }

    [[nodiscard]] inline bool equivalent(const path& _Lhs, const path& _Rhs, error_code& _Ec) noexcept {
        
        const auto _Result = _Equivalent(_Lhs.c_str(), _Rhs.c_str());
        _Ec                = _Make_ec(_Result.first);
        return _Result.second;
    }

    [[nodiscard]] inline file_status status(const path& _Path);
    [[nodiscard]] inline file_status status(const path& _Path, error_code& _Ec) noexcept;
    [[nodiscard]] inline file_status symlink_status(const path& _Path);
    [[nodiscard]] inline file_status symlink_status(const path& _Path, error_code& _Ec) noexcept;

    [[nodiscard]] inline bool exists(const path& _Target, error_code& _Ec) noexcept {
        const auto _Type = ::std:: filesystem::status(_Target, _Ec).type();
        if (_Type != file_type::none) {
            _Ec.clear();
            return _Type != file_type::not_found;
        }

        return false;
    }

    [[nodiscard]] inline bool exists(const path& _Target) {
        error_code _Ec;
        const bool _Result = ::std:: filesystem::exists(_Target, _Ec);
        if (_Ec) {
            _Throw_fs_error("exists", _Ec, _Target);
        }

        return _Result;
    }

    [[nodiscard]] inline __std_win_error _File_size(const path& _Path, uintmax_t& _Result) noexcept {
        __std_fs_stats _Stats;
        const auto _Error = __std_fs_get_stats(
            _Path.c_str(), &_Stats, __std_fs_stats_flags::_Follow_symlinks | __std_fs_stats_flags::_File_size);
        if (_Error == __std_win_error::_Success) {
            _Result = _Stats._File_size;
        } else {
            _Result = static_cast<uintmax_t>(-1);
        }

        return _Error;
    }

    [[nodiscard]] inline uintmax_t file_size(const path& _Path) {
        uintmax_t _Result;
        const auto _Error = _File_size(_Path, _Result);
        if (_Error != __std_win_error::_Success) {
            _Throw_fs_error("file_size", _Error, _Path);
        }

        return _Result;
    }

    [[nodiscard]] inline uintmax_t file_size(const path& _Path, error_code& _Ec) noexcept {
        uintmax_t _Result;
        _Ec = _Make_ec(_File_size(_Path, _Result));
        return _Result;
    }

    [[nodiscard]] inline __std_win_error _Hard_link_count(const path& _Path, uintmax_t& _Result) noexcept {
        __std_fs_stats _Stats;
        const auto _Error = __std_fs_get_stats(
            _Path.c_str(), &_Stats, __std_fs_stats_flags::_Follow_symlinks | __std_fs_stats_flags::_Link_count);
        if (_Error == __std_win_error::_Success) {
            _Result = _Stats._Link_count;
        } else {
            _Result = static_cast<uintmax_t>(-1);
        }

        return _Error;
    }

    [[nodiscard]] inline uintmax_t hard_link_count(const path& _Target) { 
        uintmax_t _Result;
        const auto _Err = _Hard_link_count(_Target.c_str(), _Result);
        if (_Err != __std_win_error::_Success) {
            _Throw_fs_error("hard_link_count", _Err, _Target);
        }

        return _Result;
    }

    [[nodiscard]] inline uintmax_t hard_link_count(const path& _Target, error_code& _Ec) noexcept {
        
        uintmax_t _Result;
        _Ec = _Make_ec(_Hard_link_count(_Target.c_str(), _Result));
        return _Result;
    }

    [[nodiscard]] inline bool is_block_file(const path&) noexcept  {
        
        return false;
    }

    [[nodiscard]] inline bool is_block_file(const path& _Path, error_code& _Ec) noexcept {
        
        (void) ::std:: filesystem::status(_Path, _Ec);
        return false; 
    }

    [[nodiscard]] inline bool is_character_file(const path&) noexcept  {
        
        return false;
    }

    [[nodiscard]] inline bool is_character_file(const path& _Path, error_code& _Ec) noexcept {
        
        (void) ::std:: filesystem::status(_Path, _Ec);
        return false; 
    }

    [[nodiscard]] inline bool is_directory(const path& _Path) { 
        return ::std:: filesystem::is_directory(::std:: filesystem::status(_Path));
    }

    [[nodiscard]] inline bool is_directory(const path& _Path, error_code& _Ec) noexcept {
        
        return ::std:: filesystem::is_directory(::std:: filesystem::status(_Path, _Ec));
    }

    [[nodiscard]] inline bool is_empty(const path& _Path, error_code& _Ec) {
        
        constexpr auto _Flags = __std_fs_stats_flags::_Attributes | __std_fs_stats_flags::_File_size
                              | __std_fs_stats_flags::_Follow_symlinks;
        __std_fs_stats _Stats;
        const auto _Error = __std_fs_get_stats(_Path.c_str(), &_Stats, _Flags);
        _Ec               = _Make_ec(_Error);
        if (_Error != __std_win_error::_Success) {
            return false;
        }

        if ((_Stats._Attributes & __std_fs_file_attr::_Directory) == __std_fs_file_attr{}) {
            return _Stats._File_size == 0;
        } else {
            directory_iterator _Iter(_Path, _Ec);
            return !_Ec && _Iter._At_end();
        }
    }

    [[nodiscard]] inline bool is_empty(const path& _Path) {
        
        error_code _Ec;
        const bool _Result = is_empty(_Path, _Ec);
        if (_Ec) {
            _Throw_fs_error("is_empty", _Ec, _Path);
        }

        return _Result;
    }

    [[nodiscard]] inline bool is_fifo(const path&) noexcept  {
        
        return false;
    }

    [[nodiscard]] inline bool is_fifo(const path& _Path, error_code& _Ec) noexcept {
        
        (void) ::std:: filesystem::status(_Path, _Ec);
        return false; 
    }

    [[nodiscard]] inline bool is_other(const path& _Path) { 
        return ::std:: filesystem::is_other(::std:: filesystem::status(_Path));
    }

    [[nodiscard]] inline bool is_other(const path& _Path, error_code& _Ec) noexcept {
        
        return ::std:: filesystem::is_other(::std:: filesystem::status(_Path, _Ec));
    }

    [[nodiscard]] inline bool is_regular_file(const path& _Path) { 
        return ::std:: filesystem::is_regular_file(::std:: filesystem::status(_Path));
    }

    [[nodiscard]] inline bool is_regular_file(const path& _Path, error_code& _Ec) noexcept {
        
        return ::std:: filesystem::is_regular_file(::std:: filesystem::status(_Path, _Ec));
    }

    [[nodiscard]] inline bool is_socket(const path&) noexcept  {
        
        return false;
    }

    [[nodiscard]] inline bool is_socket(const path& _Path, error_code& _Ec) noexcept {
        
        (void) ::std:: filesystem::status(_Path, _Ec);
        return false; 
    }

    [[nodiscard]] inline bool is_symlink(const path& _Path) { 
        return ::std:: filesystem::is_symlink(::std:: filesystem::symlink_status(_Path));
    }

    [[nodiscard]] inline bool is_symlink(const path& _Path, error_code& _Ec) noexcept { 
        return ::std:: filesystem::is_symlink(::std:: filesystem::symlink_status(_Path, _Ec));
    }

    inline bool remove(const path& _Target) {
        
        
        const auto _Result = __std_fs_remove(_Target.c_str());
        if (_Result._Error != __std_win_error::_Success) {
            _Throw_fs_error("remove", _Result._Error, _Target);
        }

        return _Result._Removed;
    }

    inline bool remove(const path& _Target, error_code& _Ec) noexcept {
        
        
        const auto _Result = __std_fs_remove(_Target.c_str());
        _Ec                = _Make_ec(_Result._Error);
        return _Result._Removed;
    }

    inline void rename(const path& _Old_p, const path& _New_p) {
        
        
        const auto _Err = __std_fs_rename(_Old_p.c_str(), _New_p.c_str());
        if (_Err != __std_win_error::_Success) {
            _Throw_fs_error("rename", _Err, _Old_p, _New_p);
        }
    }

    inline void rename(const path& _Old_p, const path& _New_p, error_code& _Ec) noexcept {
        
        
        _Ec = _Make_ec(__std_fs_rename(_Old_p.c_str(), _New_p.c_str()));
    }

    inline void resize_file(const path& _Target, const uintmax_t _New_size) {
        
        const auto _Err = __std_fs_resize_file(_Target.c_str(), _New_size);
        if (_Err != __std_win_error::_Success) {
            _Throw_fs_error("resize_file", _Err, _Target);
        }
    }

    inline void resize_file(const path& _Target, const uintmax_t _New_size, error_code& _Ec) noexcept {
        
        _Ec = _Make_ec(__std_fs_resize_file(_Target.c_str(), _New_size));
    }

    struct space_info {
        uintmax_t capacity;
        uintmax_t free;
        uintmax_t available;


        [[nodiscard]] friend constexpr bool operator==(const space_info&, const space_info&) noexcept = default;
#line 3637 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\filesystem"
    };

    [[nodiscard]] inline space_info space(const path& _Target) {
        
        space_info _Result;
        const auto _Last_error = __std_fs_space(_Target.c_str(), &_Result.available, &_Result.capacity, &_Result.free);
        if (_Last_error != __std_win_error::_Success) {
            _Throw_fs_error("space", _Last_error, _Target);
        }

        return _Result;
    }

    [[nodiscard]] inline space_info space(const path& _Target, error_code& _Ec) noexcept {
        
        space_info _Result;
        _Ec = _Make_ec(__std_fs_space(_Target.c_str(), &_Result.available, &_Result.capacity, &_Result.free));
        return _Result;
    }

    [[nodiscard]] inline bool status_known(const file_status _Status) noexcept {
        return _Status.type() != file_type::none;
    }

    [[nodiscard]] inline _File_status_and_error _Get_any_status(
        const path& _Path, const __std_fs_stats_flags _Flags) noexcept {
        _File_status_and_error _Result;
        __std_fs_stats _Stats;

        const auto _Error = __std_fs_get_stats(_Path.c_str(), &_Stats, _Flags);
        _Result._Error    = _Error;
        _Result._Status._Refresh(_Error, _Stats);

        return _Result;
    }

    [[nodiscard]] inline file_status status(const path& _Path, error_code& _Ec) noexcept {
        const auto _Result = _Get_any_status(_Path, _Status_stats_flags);
        _Ec                = _Make_ec(_Result._Error);
        return _Result._Status;
    }

    [[nodiscard]] inline file_status status(const path& _Path) {
        const auto _Result = _Get_any_status(_Path, _Status_stats_flags);
        if (_Result._Not_good()) {
            _Throw_fs_error("status", _Result._Error, _Path);
        }
        return _Result._Status;
    }

    [[nodiscard]] inline file_status symlink_status(const path& _Path, error_code& _Ec) noexcept {
        const auto _Result = _Get_any_status(_Path, _Symlink_status_stats_flags);
        _Ec                = _Make_ec(_Result._Error);
        return _Result._Status;
    }

    [[nodiscard]] inline file_status symlink_status(const path& _Path) {
        const auto _Result = _Get_any_status(_Path, _Symlink_status_stats_flags);
        if (_Result._Not_good()) {
            _Throw_fs_error("symlink_status", _Result._Error, _Path);
        }

        return _Result._Status;
    }

    inline bool create_directory(const path& _Path) {
        const auto _Result = __std_fs_create_directory(_Path.c_str());
        if (_Result._Error != __std_win_error::_Success) {
            _Throw_fs_error("create_directory", _Result._Error, _Path);
        }

        return _Result._Created;
    }

    inline bool create_directory(const path& _Path, error_code& _Ec) noexcept {
        const auto _Result = __std_fs_create_directory(_Path.c_str());
        _Ec                = _Make_ec(_Result._Error);
        return _Result._Created;
    }

    inline bool create_directory(const path& _Path, const path& _Existing_p) {
        const auto _Result = __std_fs_create_directory(_Path.c_str());
        if (_Result._Error != __std_win_error::_Success) {
            _Throw_fs_error("create_directory", _Result._Error, _Path, _Existing_p);
        }

        return _Result._Created;
    }

    inline bool create_directory(const path& _Path, const path&, error_code& _Ec) noexcept {
        const auto _Result = __std_fs_create_directory(_Path.c_str());
        _Ec                = _Make_ec(_Result._Error);
        return _Result._Created;
    }

    inline bool create_directories(const path& _Path, error_code& _Ec) {
        if (_Path.empty()) {
            _Ec = _Make_ec(__std_win_error::_Path_not_found);
            return false;
        }

        _Ec.clear(); 
        const wstring& _Text = _Path.native();
        wstring _Tmp;
        _Tmp.reserve(_Text.size());
        auto _Cursor        = _Text.data();
        const auto _End     = _Text.data() + _Text.size();
        auto _Root_path_end = _Find_relative_path(_Cursor, _End);
        if (_Root_path_end != _Cursor && _End - _Root_path_end >= 3 && _Is_drive_prefix(_Root_path_end)
            && _Is_slash(_Root_path_end[2])) {
            
            _Root_path_end += 2;
        }

        _Tmp.append(_Cursor, _Root_path_end);
        _Cursor = _Root_path_end;

        
        bool _Created_last                              = false;
        __std_win_error _Error                          = __std_win_error::_Success;
        __std_win_error _Most_recent_not_file_not_found = __std_win_error::_Success;
        while (_Cursor != _End) {
            const auto _Added_end = ::std:: find_if(::std:: find_if_not(_Cursor, _End, _Is_slash), _End, _Is_slash);
            _Tmp.append(_Cursor, _Added_end);
            const auto _Create_result = __std_fs_create_directory(_Tmp.c_str());
            _Error                    = _Create_result._Error;
            _Created_last             = _Create_result._Created;
            if (_Error != __std_win_error::_Success && !__std_is_file_not_found(_Error)) {
                _Most_recent_not_file_not_found = _Error;
            }

            _Cursor = _Added_end;
        }

        if (_Error != __std_win_error::_Success && _Most_recent_not_file_not_found != __std_win_error::_Success) {
            _Error = _Most_recent_not_file_not_found;
        }

        _Ec = _Make_ec(_Error);
        return _Created_last;
    }

    inline bool create_directories(const path& _Path) {
        error_code _Ec;
        const bool _Result = ::std:: filesystem::create_directories(_Path, _Ec);
        if (_Ec) {
            _Throw_fs_error("create_directories", _Ec, _Path);
        }

        return _Result;
    }

    inline constexpr int _Remove_all_retry_count = 10;

    inline void _Remove_all_dir(const path& _Path, error_code& _Ec, uintmax_t& _Removed_count) {
        
        for (directory_iterator _It(_Path, _Ec);; _It.increment(_Ec)) { 
            if (_Ec) {
                if (_Ec.category() != ::std:: system_category()
                    || !__std_is_file_not_found(static_cast<__std_win_error>(_Ec.value()))) {
                    return;
                }

                break;
            }

            if (_It._At_end()) {
                break;
            }

            const auto& _Subpath  = _It->path();
            const auto _Substatus = _It->symlink_status(_Ec);
            if (_Ec) {
                return;
            }

            if (_Substatus.type() == file_type::directory) {
                _Remove_all_dir(_Subpath, _Ec, _Removed_count);
            } else {
                _Removed_count += ::std:: filesystem::remove(_Subpath, _Ec);
            }

            if (_Ec) {
                return;
            }
        }

        for (int _Retry = 0; _Retry < _Remove_all_retry_count; ++_Retry) {
            
            
            const auto _Path_remove_result = __std_fs_remove(_Path.c_str());
            _Removed_count += _Path_remove_result._Removed;
            _Ec = _Make_ec(_Path_remove_result._Error);
            if (_Path_remove_result._Error != __std_win_error::_Directory_not_empty
                && _Path_remove_result._Error != __std_win_error::_Access_denied) {
                
                
                return;
            }
        }
    }

    inline uintmax_t remove_all(const path& _Path, error_code& _Ec) { 
        _Ec.clear(); 
        const auto _First_remove_result = __std_fs_remove(_Path.c_str());
        uintmax_t _Removed_count        = _First_remove_result._Removed;
        _Ec                             = _Make_ec(_First_remove_result._Error);
        if (_First_remove_result._Error == __std_win_error::_Directory_not_empty) {
            _Remove_all_dir(_Path, _Ec, _Removed_count);
        }

        if (_Ec) {
            _Removed_count = static_cast<uintmax_t>(-1);
        }

        return _Removed_count;
    }

    inline uintmax_t remove_all(const path& _Path) {
        error_code _Ec;
        const auto _Removed_count = ::std:: filesystem::remove_all(_Path, _Ec);
        if (_Ec) {
            _Throw_fs_error("remove_all", _Ec, _Path);
        }

        return _Removed_count;
    }

    [[nodiscard]] inline __std_win_error _Last_write_time(const path& _Path, file_time_type& _Result) noexcept {
        __std_fs_stats _Stats;
        const auto _Error = __std_fs_get_stats(
            _Path.c_str(), &_Stats, __std_fs_stats_flags::_Follow_symlinks | __std_fs_stats_flags::_Last_write_time);
        if (_Error == __std_win_error::_Success) {
            _Result = file_time_type{file_time_type::duration{_Stats._Last_write_time}};
        } else {
            _Result = (file_time_type::min)();
        }

        return _Error;
    }

    [[nodiscard]] inline file_time_type last_write_time(const path& _Path) {
        file_time_type _Result;
        const auto _Error = _Last_write_time(_Path, _Result);
        if (_Error != __std_win_error::_Success) {
            _Throw_fs_error("last_write_time", _Error, _Path);
        }

        return _Result;
    }

    [[nodiscard]] inline file_time_type last_write_time(const path& _Path, error_code& _Ec) noexcept {
        file_time_type _Result;
        _Ec = _Make_ec(_Last_write_time(_Path, _Result));
        return _Result;
    }

    inline void last_write_time(const path& _Target, const file_time_type _New_time) {
        
        const auto _Err = __std_fs_set_last_write_time(_New_time.time_since_epoch().count(), _Target.c_str());
        if (_Err != __std_win_error::_Success) {
            _Throw_fs_error("last_write_time", _Err, _Target);
        }
    }

    inline void last_write_time(const path& _Target, const file_time_type _New_time, error_code& _Ec) noexcept {
        
        _Ec = _Make_ec(__std_fs_set_last_write_time(_New_time.time_since_epoch().count(), _Target.c_str()));
    }

    enum class perm_options { replace = 0x1, add = 0x2, remove = 0x4, nofollow = 0x8 };

    [[nodiscard]] constexpr perm_options operator&(perm_options _Left, perm_options _Right) noexcept { using _IntTy = ::std:: underlying_type_t<perm_options>; return static_cast<perm_options>(static_cast<_IntTy>(_Left) & static_cast<_IntTy>(_Right)); } [[nodiscard]] constexpr perm_options operator|(perm_options _Left, perm_options _Right) noexcept { using _IntTy = ::std:: underlying_type_t<perm_options>; return static_cast<perm_options>(static_cast<_IntTy>(_Left) | static_cast<_IntTy>(_Right)); } [[nodiscard]] constexpr perm_options operator^(perm_options _Left, perm_options _Right) noexcept { using _IntTy = ::std:: underlying_type_t<perm_options>; return static_cast<perm_options>(static_cast<_IntTy>(_Left) ^ static_cast<_IntTy>(_Right)); } constexpr perm_options& operator&=(perm_options& _Left, perm_options _Right) noexcept { return _Left = _Left & _Right; } constexpr perm_options& operator|=(perm_options& _Left, perm_options _Right) noexcept { return _Left = _Left | _Right; } constexpr perm_options& operator^=(perm_options& _Left, perm_options _Right) noexcept { return _Left = _Left ^ _Right; } [[nodiscard]] constexpr perm_options operator~(perm_options _Left) noexcept { using _IntTy = ::std:: underlying_type_t<perm_options>; return static_cast<perm_options>(~static_cast<_IntTy>(_Left)); } [[nodiscard]] constexpr bool _Bitmask_includes( perm_options _Left, perm_options _Elements) noexcept { return (_Left & _Elements) != perm_options{}; } [[nodiscard]] constexpr bool _Bitmask_includes_all( perm_options _Left, perm_options _Elements) noexcept { return (_Left & _Elements) == _Elements; }

    [[nodiscard]] inline __std_win_error _Permissions(
        const path& _Target, const perms _Perms, perm_options _Options) noexcept {
        bool _Readonly;
        const bool _Follow_symlinks = (_Options & perm_options::nofollow) == perm_options{};
        _Options &= ~perm_options::nofollow;
        const auto _Write_perms = _Perms & perms::_All_write;
        switch (_Options) {
        case perm_options::replace:
            
            _Readonly = _Write_perms == perms::none;
            break;
        case perm_options::add:
            if (_Write_perms == perms::none) {
                
                
                return __std_win_error::_Success;
            }

            _Readonly = false;
            break;
        case perm_options::remove:
            if (_Write_perms != perms::_All_write) {
                
                
                return __std_win_error::_Success;
            }

            _Readonly = true;
            break;
        case perm_options::nofollow: 
        default:
            return __std_win_error::_Invalid_parameter;
        }

        return __std_fs_change_permissions(_Target.c_str(), _Follow_symlinks, _Readonly);
    }

    inline void permissions(
        const path& _Target, const perms _Perms, const perm_options _Options = perm_options::replace) {
        const auto _Err = _Permissions(_Target, _Perms, _Options);
        if (_Err != __std_win_error::_Success) {
            _Throw_fs_error("permissions", _Err, _Target);
        }
    }

    inline void permissions(
        const path& _Target, const perms _Perms, const perm_options _Options, error_code& _Ec) noexcept {
        _Ec = _Make_ec(_Permissions(_Target, _Perms, _Options));
    }

    inline void permissions(const path& _Target, const perms _Perms, error_code& _Ec) noexcept {
        ::std:: filesystem::permissions(_Target, _Perms, perm_options::replace, _Ec);
    }

    [[nodiscard]] inline path temp_directory_path(error_code& _Ec) {
        
        _Ec.clear(); 
        path _Result;
        _Result._Text.resize(__std_fs_temp_path_max);
        const auto _Temp_result = __std_fs_get_temp_path(_Result._Text.data());
        _Result._Text.resize(_Temp_result._Size);
        if (_Temp_result._Error == __std_win_error::_Max) { 
            _Ec = ::std:: make_error_code(errc::not_a_directory);
        } else {
            _Ec = _Make_ec(_Temp_result._Error);
        }

        return _Result;
    }

    [[nodiscard]] inline path temp_directory_path() {
        
        error_code _Ec; 
        path _Result(::std:: filesystem::temp_directory_path(_Ec));
        if (_Ec) {
            _Throw_fs_error("temp_directory_path", _Ec, _Result);
        }
        return _Result;
    }

    [[nodiscard]] inline __std_win_error _Current_path(path& _Result) noexcept {
        _Result._Text.resize(__std_fs_max_path);
        for (;;) {
            const auto _Requested_size = static_cast<unsigned long>(_Result._Text.size());
            const auto _Temp_result    = __std_fs_get_current_path(_Requested_size, _Result._Text.data());
            _Result._Text.resize(_Temp_result._Size);
            if (_Temp_result._Size < _Requested_size) {
                return _Temp_result._Error;
            }
        }
    }

    [[nodiscard]] inline path current_path(error_code& _Ec) {
        _Ec.clear();
        path _Result;
        _Ec = _Make_ec(_Current_path(_Result));
        return _Result;
    }

    [[nodiscard]] inline path current_path() {
        path _Result;
        const auto _Err = _Current_path(_Result);
        if (_Err != __std_win_error::_Success) {
            _Throw_fs_error("current_path()", _Err);
        }
        return _Result;
    }

    inline void current_path(const path& _To, error_code& _Ec) noexcept { 
        _Ec = _Make_ec(__std_fs_set_current_path(_To._Text.data()));
    }

    inline void current_path(const path& _To) { 
        const auto _Err = __std_fs_set_current_path(_To._Text.data());
        if (_Err != __std_win_error::_Success) {
            _Throw_fs_error("current_path(const path&)", _Err, _To);
        }
    }

    [[nodiscard]] inline path weakly_canonical(const path& _Input, error_code& _Ec) {
        
        _Ec.clear(); 

        path _Temp;

        {
            const auto _Err = _Canonical(_Temp, _Input.native());

            if (_Err == __std_win_error::_Success) {
                return _Temp;
            }

            if (!__std_is_file_not_found(_Err)) {
                _Ec = _Make_ec(_Err);
                return {};
            }
        }

        const path _Normalized = _Input.lexically_normal();

        path _Result = _Normalized.root_path();

        const path _Normalized_relative = _Normalized.relative_path();

        bool _Call_canonical = true;

        for (const auto& _Elem : _Normalized_relative) {
            _Result /= _Elem;

            if (_Call_canonical) {
                _Temp.clear();

                const auto _Err = _Canonical(_Temp, _Result.native());

                if (_Err == __std_win_error::_Success) {
                    _Result = ::std:: move(_Temp);
                } else if (__std_is_file_not_found(_Err)) {
                    _Call_canonical = false;
                } else {
                    _Ec = _Make_ec(_Err);
                    return {};
                }
            }
        }

        return _Result;
    }

    [[nodiscard]] inline path weakly_canonical(const path& _Input) {
        
        error_code _Ec;

        path _Result = ::std:: filesystem::weakly_canonical(_Input, _Ec);

        if (_Ec) {
            _Throw_fs_error("weakly_canonical", _Ec, _Input);
        }

        return _Result;
    }

    [[nodiscard]] inline path proximate(const path& _Path, const path& _Base = ::std:: filesystem::current_path()) {
        
        const path _Weakly_canonical_path = ::std:: filesystem::weakly_canonical(_Path);
        const path _Weakly_canonical_base = ::std:: filesystem::weakly_canonical(_Base);
        return _Weakly_canonical_path.lexically_proximate(_Weakly_canonical_base);
    }

    [[nodiscard]] inline path proximate(const path& _Path, const path& _Base, error_code& _Ec) {
        
        const path _Weakly_canonical_path = ::std:: filesystem::weakly_canonical(_Path, _Ec);

        if (_Ec) {
            return {};
        }

        const path _Weakly_canonical_base = ::std:: filesystem::weakly_canonical(_Base, _Ec);

        if (_Ec) {
            return {};
        }

        return _Weakly_canonical_path.lexically_proximate(_Weakly_canonical_base);
    }

    [[nodiscard]] inline path proximate(const path& _Path, error_code& _Ec) {
        
        const path _Base = ::std:: filesystem::current_path(_Ec);
        
        if (_Ec) {
            return {};
        }

        return ::std:: filesystem::proximate(_Path, _Base, _Ec);
    }

    [[nodiscard]] inline path relative(const path& _Path, const path& _Base = ::std:: filesystem::current_path()) {
        
        const path _Weakly_canonical_path = ::std:: filesystem::weakly_canonical(_Path);
        const path _Weakly_canonical_base = ::std:: filesystem::weakly_canonical(_Base);
        return _Weakly_canonical_path.lexically_relative(_Weakly_canonical_base);
    }

    [[nodiscard]] inline path relative(const path& _Path, const path& _Base, error_code& _Ec) {
        
        const path _Weakly_canonical_path = ::std:: filesystem::weakly_canonical(_Path, _Ec);

        if (_Ec) {
            return {};
        }

        const path _Weakly_canonical_base = ::std:: filesystem::weakly_canonical(_Base, _Ec);

        if (_Ec) {
            return {};
        }

        return _Weakly_canonical_path.lexically_relative(_Weakly_canonical_base);
    }

    [[nodiscard]] inline path relative(const path& _Path, error_code& _Ec) {
        
        const path _Base = ::std:: filesystem::current_path(_Ec);
        
        if (_Ec) {
            return {};
        }

        return ::std:: filesystem::relative(_Path, _Base, _Ec);
    }

    inline void _Copy_impl(
        const directory_entry& _From, const path& _To, const copy_options _Options, error_code& _Ec) {
        
        
        const bool _Flink = (_Options & (copy_options::skip_symlinks | copy_options::copy_symlinks))
                         != copy_options::none; 
        const auto _Fstat = _From._Get_any_status(_Flink ? _Symlink_status_stats_flags : _Status_stats_flags);
        if (_Fstat._Error != __std_win_error::_Success) { 
            _Ec = _Make_ec(_Fstat._Error);
            return;
        }

        const bool _Tlink =
            (_Options & (copy_options::create_symlinks | copy_options::skip_symlinks)) != copy_options::none;
        const auto _Tstat = _Get_any_status(_To, _Tlink ? _Symlink_status_stats_flags : _Status_stats_flags);
        if (_Tstat._Not_good()) {
            _Ec = _Make_ec(_Tstat._Error);
            return;
        }

        if (::std:: filesystem::exists(_Tstat._Status)) {
            if (::std:: filesystem::equivalent(_From, _To, _Ec)) { 
                _Ec = ::std:: make_error_code(errc::file_exists);
                return;
            }

            if (_Ec) {
                return;
            }
        }

        if (::std:: filesystem::is_other(_Fstat._Status) || ::std:: filesystem::is_other(_Tstat._Status)) {
            
            _Ec = ::std:: make_error_code(errc::operation_not_supported);
            return;
        }

        if (::std:: filesystem::is_directory(_Fstat._Status) && ::std:: filesystem::is_regular_file(_Tstat._Status)) {
            
            _Ec = ::std:: make_error_code(errc::file_exists);
            return;
        }

        if (::std:: filesystem::is_symlink(_Fstat._Status)) {
            if ((_Options & copy_options::skip_symlinks) != copy_options::none) {
                return;
            }

            if (!::std:: filesystem::exists(_Tstat._Status)
                && (_Options & copy_options::copy_symlinks) != copy_options::none) {
                
                ::std:: filesystem::copy_symlink(_From, _To, _Ec);
                return;
            }

            
            _Ec = ::std:: make_error_code(errc::operation_not_supported);
            return;
        }

        if (::std:: filesystem::is_regular_file(_Fstat._Status)) {
            if ((_Options & copy_options::directories_only) != copy_options::none) {
                return;
            }

            if ((_Options & copy_options::create_symlinks) != copy_options::none) {
                
                ::std:: filesystem::create_symlink(_From, _To, _Ec);
                return;
            }

            if ((_Options & copy_options::create_hard_links) != copy_options::none) {
                
                ::std:: filesystem::create_hard_link(_From, _To, _Ec);
                return;
            }

            if (::std:: filesystem::is_directory(_Tstat._Status)) {
                
                ::std:: filesystem::copy_file(_From, _To / _From.path().filename(), _Options, _Ec);
                return;
            }

            
            ::std:: filesystem::copy_file(_From, _To, _Options, _Ec);
            return;
        }

        
        if (::std:: filesystem::is_directory(_Fstat._Status)) {
            if ((_Options & copy_options::create_symlinks) != copy_options::none) {
                _Ec = ::std:: make_error_code(errc::is_a_directory);
                return;
            }

            ::std:: filesystem::create_directory(_To, _From, _Ec);
            if (_Ec) {
                return;
            }

            
            if ((_Options & copy_options::recursive) != copy_options::none
                || (_Options & copy_options::directories_only) == copy_options::none) {
                for (directory_iterator _It(_From, _Ec);; _It.increment(_Ec)) {
                    if (_Ec || _It._At_end()) {
                        return;
                    }

                    
                    bool _Recurse = (_Options & copy_options::recursive) != copy_options::none;
                    if (!_Recurse) {
                        const auto _Child_status_result =
                            _It->_Get_any_status(_Flink ? _Symlink_status_stats_flags : _Status_stats_flags);
                        if (_Child_status_result._Error != __std_win_error::_Success) {
                            _Ec = _Make_ec(_Child_status_result._Error);
                            return;
                        }

                        _Recurse = !::std:: filesystem::is_directory(_Child_status_result._Status);
                    }

                    if (_Recurse) {
                        _Copy_impl(*_It, _To / _It->path().filename(), _Options, _Ec);
                        if (_Ec) {
                            return;
                        }
                    }
                }
            }
        }

        
    }

    inline void copy(const path& _From, const path& _To, const copy_options _Options, error_code& _Ec) {
        const directory_entry _From_dir(_From, _Ec);
        if (_Ec) { 
            return;
        }

        _Copy_impl(_From_dir, _To, _Options, _Ec);
    }

    inline void copy(const path& _From, const path& _To, const copy_options _Options) {
        error_code _Ec;
        ::std:: filesystem::copy(_From, _To, _Options, _Ec);
        if (_Ec) {
            _Throw_fs_error("copy", _Ec, _From, _To);
        }
    }

    inline void copy(const path& _From, const path& _To, error_code& _Ec) {
        return ::std:: filesystem::copy(_From, _To, copy_options::none, _Ec);
    }

    inline void copy(const path& _From, const path& _To) {
        return ::std:: filesystem::copy(_From, _To, copy_options::none);
    }
} 

template <>
struct hash<filesystem::path> {
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef filesystem::path _Unnameable_argument;
    [[deprecated( "warning STL4007: Many result_type typedefs " "and all argument_type, first_argument_type, and second_argument_type typedefs are deprecated in C++17. " "You can define _SILENCE_CXX17_ADAPTOR_TYPEDEFS_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef size_t _Unnameable_result;
    [[nodiscard]] size_t operator()(const filesystem::path& _Path) const noexcept {
        return ::std:: filesystem::hash_value(_Path);
    }
};


namespace ranges {
    template <>
    inline constexpr bool enable_borrowed_range<filesystem::directory_iterator> = true;
    template <>
    inline constexpr bool enable_borrowed_range<filesystem::recursive_directory_iterator> = true;
    template <>
    inline constexpr bool enable_view<filesystem::directory_iterator> = true;
    template <>
    inline constexpr bool enable_view<filesystem::recursive_directory_iterator> = true;
} 
#line 4362 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\filesystem"

}


#pragma warning(pop)
#pragma pack(pop)
#line 4370 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\filesystem"
#line 4371 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\filesystem"
#line 4372 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\filesystem"
#line 97 "all-std.cxx"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"


#pragma once


#line 29 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"

#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


#line 40 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"


#line 47 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"
#line 48 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"


#line 57 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"
#line 58 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"

namespace std {

enum _Meta_type { 
    _Meta_lpar  = '(',
    _Meta_rpar  = ')',
    _Meta_dlr   = '$',
    _Meta_caret = '^',
    _Meta_dot   = '.',
    _Meta_star  = '*',
    _Meta_plus  = '+',
    _Meta_query = '?',
    _Meta_lsq   = '[',
    _Meta_rsq   = ']',
    _Meta_bar   = '|',
    _Meta_esc   = '\\',
    _Meta_dash  = '-',
    _Meta_lbr   = '{',
    _Meta_rbr   = '}',
    _Meta_comma = ',',
    _Meta_colon = ':',
    _Meta_equal = '=',
    _Meta_exc   = '!',
    _Meta_eos   = -1,
    _Meta_nl    = '\n',
    _Meta_cr    = '\r',
    _Meta_bsp   = '\b',
    _Meta_chr   = 0,

    _Esc_bsl      = '\\',
    _Esc_word     = 'b',
    _Esc_not_word = 'B',
    _Esc_ctrl_a   = 'a',
    _Esc_ctrl_b   = 'b',
    _Esc_ctrl_f   = 'f',
    _Esc_ctrl_n   = 'n',
    _Esc_ctrl_r   = 'r',
    _Esc_ctrl_t   = 't',
    _Esc_ctrl_v   = 'v',
    _Esc_ctrl     = 'c',
    _Esc_hex      = 'x',
    _Esc_uni      = 'u'
};

namespace regex_constants {
    
    enum syntax_option_type : int { 
        ECMAScript = 0x01,
        basic      = 0x02,
        extended   = 0x04,
        awk        = 0x08,
        grep       = 0x10,
        egrep      = 0x20,
        _Gmask     = 0x3F,

        icase    = 0x0100,
        nosubs   = 0x0200,
        optimize = 0x0400,
        collate  = 0x0800
    };

    [[nodiscard]] constexpr syntax_option_type operator&(syntax_option_type _Left, syntax_option_type _Right) noexcept { using _IntTy = ::std:: underlying_type_t<syntax_option_type>; return static_cast<syntax_option_type>(static_cast<_IntTy>(_Left) & static_cast<_IntTy>(_Right)); } [[nodiscard]] constexpr syntax_option_type operator|(syntax_option_type _Left, syntax_option_type _Right) noexcept { using _IntTy = ::std:: underlying_type_t<syntax_option_type>; return static_cast<syntax_option_type>(static_cast<_IntTy>(_Left) | static_cast<_IntTy>(_Right)); } [[nodiscard]] constexpr syntax_option_type operator^(syntax_option_type _Left, syntax_option_type _Right) noexcept { using _IntTy = ::std:: underlying_type_t<syntax_option_type>; return static_cast<syntax_option_type>(static_cast<_IntTy>(_Left) ^ static_cast<_IntTy>(_Right)); } constexpr syntax_option_type& operator&=(syntax_option_type& _Left, syntax_option_type _Right) noexcept { return _Left = _Left & _Right; } constexpr syntax_option_type& operator|=(syntax_option_type& _Left, syntax_option_type _Right) noexcept { return _Left = _Left | _Right; } constexpr syntax_option_type& operator^=(syntax_option_type& _Left, syntax_option_type _Right) noexcept { return _Left = _Left ^ _Right; } [[nodiscard]] constexpr syntax_option_type operator~(syntax_option_type _Left) noexcept { using _IntTy = ::std:: underlying_type_t<syntax_option_type>; return static_cast<syntax_option_type>(~static_cast<_IntTy>(_Left)); } [[nodiscard]] constexpr bool _Bitmask_includes( syntax_option_type _Left, syntax_option_type _Elements) noexcept { return (_Left & _Elements) != syntax_option_type{}; } [[nodiscard]] constexpr bool _Bitmask_includes_all( syntax_option_type _Left, syntax_option_type _Elements) noexcept { return (_Left & _Elements) == _Elements; }

    enum match_flag_type : int { 
        match_default     = 0x0000,
        match_not_bol     = 0x0001,
        match_not_eol     = 0x0002,
        match_not_bow     = 0x0004,
        match_not_eow     = 0x0008,
        match_any         = 0x0010,
        match_not_null    = 0x0020,
        match_continuous  = 0x0040,
        match_prev_avail  = 0x0100,
        format_default    = 0x0000,
        format_sed        = 0x0400,
        format_no_copy    = 0x0800,
        format_first_only = 0x1000,
        _Match_not_null   = 0x2000,
        _Skip_zero_length = 0x4000,
    };

    [[nodiscard]] constexpr match_flag_type operator&(match_flag_type _Left, match_flag_type _Right) noexcept { using _IntTy = ::std:: underlying_type_t<match_flag_type>; return static_cast<match_flag_type>(static_cast<_IntTy>(_Left) & static_cast<_IntTy>(_Right)); } [[nodiscard]] constexpr match_flag_type operator|(match_flag_type _Left, match_flag_type _Right) noexcept { using _IntTy = ::std:: underlying_type_t<match_flag_type>; return static_cast<match_flag_type>(static_cast<_IntTy>(_Left) | static_cast<_IntTy>(_Right)); } [[nodiscard]] constexpr match_flag_type operator^(match_flag_type _Left, match_flag_type _Right) noexcept { using _IntTy = ::std:: underlying_type_t<match_flag_type>; return static_cast<match_flag_type>(static_cast<_IntTy>(_Left) ^ static_cast<_IntTy>(_Right)); } constexpr match_flag_type& operator&=(match_flag_type& _Left, match_flag_type _Right) noexcept { return _Left = _Left & _Right; } constexpr match_flag_type& operator|=(match_flag_type& _Left, match_flag_type _Right) noexcept { return _Left = _Left | _Right; } constexpr match_flag_type& operator^=(match_flag_type& _Left, match_flag_type _Right) noexcept { return _Left = _Left ^ _Right; } [[nodiscard]] constexpr match_flag_type operator~(match_flag_type _Left) noexcept { using _IntTy = ::std:: underlying_type_t<match_flag_type>; return static_cast<match_flag_type>(~static_cast<_IntTy>(_Left)); } [[nodiscard]] constexpr bool _Bitmask_includes( match_flag_type _Left, match_flag_type _Elements) noexcept { return (_Left & _Elements) != match_flag_type{}; } [[nodiscard]] constexpr bool _Bitmask_includes_all( match_flag_type _Left, match_flag_type _Elements) noexcept { return (_Left & _Elements) == _Elements; }

    enum error_type { 
        error_collate,
        error_ctype,
        error_escape,
        error_backref,
        error_brack,
        error_paren,
        error_brace,
        error_badbrace,
        error_range,
        error_space,
        error_badrepeat,
        error_complexity,
        error_stack,
        error_parse,
        error_syntax
    };
} 

[[noreturn]]  void __cdecl _Xregex_error(regex_constants::error_type _Code);

template <class _Elem>
class regex_traits;

struct _Cl_names { 
    const char* _Narrow;
    const wchar_t* _Wide;
    unsigned int _Len;
    ctype_base::mask _Ctype;

    template <class _Elem>
    const _Elem* _Get() const;
};

template <>
inline const char* _Cl_names::_Get<char>() const { 
    return _Narrow;
}

template <>
inline const wchar_t* _Cl_names::_Get<wchar_t>() const { 
    return _Wide;
}

template <class _RxTraits>
struct _Cmp_cs { 
    using _Elem = typename _RxTraits::char_type;
    bool operator()(_Elem _Ex1, _Elem _Ex2) {
        return _Ex1 == _Ex2;
    }
};

template <class _RxTraits>
struct _Cmp_icase { 
    using _Elem = typename _RxTraits::char_type;

    explicit _Cmp_icase(const _RxTraits& _Tr) : _Traits(_Tr) {}

    bool operator()(_Elem _Ex1, _Elem _Ex2) {
        return _Traits.translate_nocase(_Ex1) == _Traits.translate_nocase(_Ex2);
    }

    const _RxTraits& _Traits;
};

template <class _RxTraits>
struct _Cmp_collate { 
    using _Elem = typename _RxTraits::char_type;

    explicit _Cmp_collate(const _RxTraits& _Tr) : _Traits(_Tr) {}

    bool operator()(_Elem _Ex1, _Elem _Ex2) {
        return _Traits.translate(_Ex1) == _Traits.translate(_Ex2);
    }

    const _RxTraits& _Traits;
};

struct _Regex_traits_base { 
    enum _Char_class_type {
        _Ch_none   = 0,
        _Ch_alnum  = ctype_base::alnum,
        _Ch_alpha  = ctype_base::alpha,
        _Ch_cntrl  = ctype_base::cntrl,
        _Ch_digit  = ctype_base::digit,
        _Ch_graph  = ctype_base::graph,
        _Ch_lower  = ctype_base::lower,
        _Ch_print  = ctype_base::print,
        _Ch_punct  = ctype_base::punct,
        _Ch_space  = ctype_base::space,
        _Ch_upper  = ctype_base::upper,
        _Ch_xdigit = ctype_base::xdigit,
        _Ch_blank  = ctype_base::blank
    };
    using char_class_type = ctype_base::mask;
};

template <class _Elem>
class _Regex_traits : public _Regex_traits_base { 
public:
    using _Uelem      = make_unsigned_t<_Elem>;
    using char_type   = _Elem;
    using size_type   = size_t;
    using string_type = basic_string<_Elem>;
    using locale_type = locale;

    static size_type length(const _Elem* _Str) {
        return char_traits<_Elem>::length(_Str);
    }

    _Regex_traits() {
        _Cache_locale();
    }

    _Regex_traits(const _Regex_traits& _Right) : _Loc(_Right._Loc) {
        _Cache_locale();
    }

    _Regex_traits& operator=(const _Regex_traits& _Right) {
        _Loc = _Right._Loc;
        _Cache_locale();
        return *this;
    }

    _Elem translate(_Elem _Ch) const { 
        string_type _Res = _Getcoll()->transform(::std:: addressof(_Ch), ::std:: addressof(_Ch) + 1);
        return _Res.size() == 1 ? _Res[0] : _Ch;
    }

    _Elem translate_nocase(_Elem _Ch) const { 
        return _Getctype()->tolower(_Ch);
    }

    template <class _FwdIt>
    string_type transform(_FwdIt _First, _FwdIt _Last) const { 
        const string_type _Str(_First, _Last);
        return _Getcoll()->transform(_Str.data(), _Str.data() + _Str.size());
    }

    template <class _FwdIt>
    string_type transform_primary(_FwdIt _First, _FwdIt _Last) const {
        
        string_type _Res;

        if (_First != _Last) { 
            vector<_Elem> _Temp(_First, _Last);

            _Getctype()->tolower(_Temp.data(), _Temp.data() + _Temp.size());
            _Res = _Getcoll()->transform(_Temp.data(), _Temp.data() + _Temp.size());
        }
        return _Res;
    }

    bool isctype(_Elem _Ch, char_class_type _Fx) const {
        if (_Fx != static_cast<char_class_type>(-1)) {
            return _Getctype()->is(_Fx, _Ch);
        } else {
            return _Ch == '_' 
                || _Getctype()->is(_Ch_alnum, _Ch);
        }
    }

    template <class _Iter>
    char_class_type lookup_classname(_Iter _First, _Iter _Last, bool _Icase = false) const {
        

        static constexpr _Cl_names _Names[] = {
            
            { "alnum", L"alnum", sizeof("alnum") / sizeof("alnum"[0]) - 1, _Ch_alnum },
            { "alpha", L"alpha", sizeof("alpha") / sizeof("alpha"[0]) - 1, _Ch_alpha },
            { "blank", L"blank", sizeof("blank") / sizeof("blank"[0]) - 1, _Ch_blank },
            { "cntrl", L"cntrl", sizeof("cntrl") / sizeof("cntrl"[0]) - 1, _Ch_cntrl },
            { "d", L"d", sizeof("d") / sizeof("d"[0]) - 1, _Ch_digit },
            { "digit", L"digit", sizeof("digit") / sizeof("digit"[0]) - 1, _Ch_digit },
            { "graph", L"graph", sizeof("graph") / sizeof("graph"[0]) - 1, _Ch_graph },
            { "lower", L"lower", sizeof("lower") / sizeof("lower"[0]) - 1, _Ch_lower },
            { "print", L"print", sizeof("print") / sizeof("print"[0]) - 1, _Ch_print },
            { "punct", L"punct", sizeof("punct") / sizeof("punct"[0]) - 1, _Ch_punct },
            { "space", L"space", sizeof("space") / sizeof("space"[0]) - 1, _Ch_space },
            { "s", L"s", sizeof("s") / sizeof("s"[0]) - 1, _Ch_space },
            { "upper", L"upper", sizeof("upper") / sizeof("upper"[0]) - 1, _Ch_upper },
            { "w", L"w", sizeof("w") / sizeof("w"[0]) - 1, static_cast<ctype_base::mask>(-1) },
            { "xdigit", L"xdigit", sizeof("xdigit") / sizeof("xdigit"[0]) - 1, _Ch_xdigit },
            {nullptr, nullptr, 0, 0},
        };


        _Adl_verify_range(_First, _Last);
        unsigned int _Ix = 0;
        for (; _Names[_Ix]._Get<_Elem>(); ++_Ix) {
            if (::std:: equal(_Get_unwrapped(_First), _Get_unwrapped(_Last), _Names[_Ix]._Get<_Elem>(),
                    _Names[_Ix]._Get<_Elem>() + _Names[_Ix]._Len, _Cmp_icase<_Regex_traits<_Elem>>{*this})) {
                break;
            }
        }

        char_class_type _Mask{};
        if (_Names[_Ix]._Get<_Elem>()) {
            _Mask = _Names[_Ix]._Ctype;
        }

        if (_Icase && (_Mask & (_Ch_lower | _Ch_upper))) {
            _Mask |= _Ch_lower | _Ch_upper;
        }

        return _Mask;
    }

    template <class _FwdIt>
    string_type lookup_collatename(_FwdIt _First, _FwdIt _Last) const { 
        return string_type(_First, _Last);
    }

    locale_type imbue(locale_type _Lx) { 
        locale_type _Tmp = _Loc;
        _Loc             = _Lx;
        _Cache_locale();
        return _Tmp;
    }

    locale_type getloc() const {
        return _Loc;
    }

    const collate<_Elem>* _Getcoll() const { 
        return _Pcoll;
    }

    const ctype<_Elem>* _Getctype() const { 
        return _Pctype;
    }

private:
    void _Cache_locale() { 
        _Pcoll  = ::std:: addressof(::std:: use_facet<collate<_Elem>>(_Loc));
        _Pctype = ::std:: addressof(::std:: use_facet<ctype<_Elem>>(_Loc));
    }

    const collate<_Elem>* _Pcoll;
    const ctype<_Elem>* _Pctype;
    locale_type _Loc;
};

template <>
class regex_traits<char> : public _Regex_traits<char> {
public:
    int value(char _Ch, int _Base) const { 
        if ((_Base != 8 && '0' <= _Ch && _Ch <= '9') || (_Base == 8 && '0' <= _Ch && _Ch <= '7')) {
            return _Ch - '0';
        }

        if (_Base != 16) {
            return -1;
        }

        if ('a' <= _Ch && _Ch <= 'f') {
            return _Ch - 'a' + 10;
        }

        if ('A' <= _Ch && _Ch <= 'F') {
            return _Ch - 'A' + 10;
        }

        return -1;
    }
};

template <>
class regex_traits<wchar_t> : public _Regex_traits<wchar_t> {
public:
    int value(wchar_t _Ch, int _Base) const { 
        if ((_Base != 8 && L'0' <= _Ch && _Ch <= L'9') || (_Base == 8 && L'0' <= _Ch && _Ch <= L'7')) {
            return _Ch - L'0';
        }

        if (_Base != 16) {
            return -1;
        }

        if (L'a' <= _Ch && _Ch <= L'f') {
            return _Ch - L'a' + 10;
        }

        if (L'A' <= _Ch && _Ch <= L'F') {
            return _Ch - L'A' + 10;
        }

        return -1;
    }
};

class regex_error : public runtime_error { 
public:
    explicit regex_error(regex_constants::error_type _Ex) : runtime_error(_Stringify(_Ex)), _Err(_Ex) {}

    [[nodiscard]] regex_constants::error_type code() const {
        return _Err;
    }

private:
    static const char* _Stringify(regex_constants::error_type _Ex) { 
        switch (_Ex) { 
        case regex_constants::error_collate:
            return "regex_error(error_collate): The expression "
                   "contained an invalid collating element name.";
        case regex_constants::error_ctype:
            return "regex_error(error_ctype): The expression "
                   "contained an invalid character class name.";
        case regex_constants::error_escape:
            return "regex_error(error_escape): The expression "
                   "contained an invalid escaped character, "
                   "or a trailing escape.";
        case regex_constants::error_backref:
            return "regex_error(error_backref): The expression "
                   "contained an invalid back reference.";
        case regex_constants::error_brack:
            return "regex_error(error_brack): The expression "
                   "contained mismatched [ and ].";
        case regex_constants::error_paren:
            return "regex_error(error_paren): The expression "
                   "contained mismatched ( and ).";
        case regex_constants::error_brace:
            return "regex_error(error_brace): The expression "
                   "contained mismatched { and }.";
        case regex_constants::error_badbrace:
            return "regex_error(error_badbrace): The expression "
                   "contained an invalid range in a { expression }.";
        case regex_constants::error_range:
            return "regex_error(error_range): The expression "
                   "contained an invalid character range, "
                   "such as [b-a] in most encodings.";
        case regex_constants::error_space:
            return "regex_error(error_space): There was insufficient "
                   "memory to convert the expression into "
                   "a finite state machine.";
        case regex_constants::error_badrepeat:
            return "regex_error(error_badrepeat): One of *?+{ "
                   "was not preceded by a valid regular expression.";
        case regex_constants::error_complexity:
            return "regex_error(error_complexity): The complexity of "
                   "an attempted match against a regular expression "
                   "exceeded a pre-set level.";
        case regex_constants::error_stack:
            return "regex_error(error_stack): There was insufficient "
                   "memory to determine whether the regular expression "
                   "could match the specified character sequence.";
        case regex_constants::error_parse:
            return "regex_error(error_parse)";
        case regex_constants::error_syntax:
            return "regex_error(error_syntax)";
        default:
            return "regex_error";
        }
    }

    regex_constants::error_type _Err;
};

template <class _Traits, class _FwdIt1, class _FwdIt2>
int _Iter_compare3(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, true_type) {
    
    return _Traits_compare<_Traits>(
        _First1, static_cast<size_t>(_Last1 - _First1), _First2, static_cast<size_t>(_Last2 - _First2));
}

template <class _Traits, class _FwdIt1, class _FwdIt2>
int _Iter_compare3(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, false_type) {
    
    const pair<_FwdIt1, _FwdIt2> _Cmp = ::std:: mismatch(_First1, _Last1, _First2, _Last2, _Char_traits_eq<_Traits>{});

    if (_Cmp.first == _Last1) {
        if (_Cmp.second == _Last2) {
            return 0;
        } else {
            return -1;
        }
    }

    if (_Cmp.second == _Last2) {
        return 1;
    }

    if (_Traits::lt(*_Cmp.first, *_Cmp.second)) {
        return -1;
    } else {
        return 1;
    }
}

template <class _Traits, class _FwdIt1, class _FwdIt2>
int _Iter_compare2(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2) {
    
    return _Iter_compare3<_Traits>(
        _First1, _Last1, _First2, _Last2, bool_constant<conjunction_v<is_pointer<_FwdIt1>, is_pointer<_FwdIt2>>>{});
}

template <class _Traits, class _FwdIt1, class _FwdIt2>
int _Iter_compare(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2) {
    
    
    using _Elem = typename _Traits::char_type;
    static_assert(is_same_v<_Iter_value_t<_FwdIt1>, _Elem>, "bad _FwdIt1 to _Iter_compare");
    static_assert(is_same_v<_Iter_value_t<_FwdIt2>, _Elem>, "bad _FwdIt2 to _Iter_compare");

    _Adl_verify_range(_First1, _Last1);
    _Adl_verify_range(_First2, _Last2);
    return _Iter_compare2<_Traits>(
        _Get_unwrapped(_First1), _Get_unwrapped(_Last1), _Get_unwrapped(_First2), _Get_unwrapped(_Last2));
}

inline bool _Is_word(unsigned char _UCh) {
    
    static constexpr bool _Is_word_table[(numeric_limits<unsigned char>::max)() + 1] = {
        
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 
         0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 
         0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0
        
    };
    return _Is_word_table[_UCh];
}

inline bool _Is_word(char _Ch) {
    return _Is_word(static_cast<unsigned char>(_Ch));
}

template <class _Elem>
bool _Is_word(_Elem _Ch) {
    
    using _UElem = make_unsigned_t<_Elem>;

    const auto _UCh = static_cast<_UElem>(_Ch);
    return _UCh <= static_cast<_UElem>('z') && _Is_word(static_cast<unsigned char>(_UCh));
}


template <class _Ty, class = void>
struct _Get_member_comparison_category {
    using type = weak_ordering;
};

template <class _Ty>
struct _Get_member_comparison_category<_Ty, void_t<typename _Ty::comparison_category>> {
    using type = typename _Ty::comparison_category;
};
#line 595 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"

template <class _BidIt>
class sub_match : public pair<_BidIt, _BidIt> { 
public:
    using _Mybase         = pair<_BidIt, _BidIt>;
    using value_type      = typename iterator_traits<_BidIt>::value_type;
    using difference_type = typename iterator_traits<_BidIt>::difference_type;
    using iterator        = _BidIt;
    using string_type     = basic_string<value_type>;
    
    using _Traits = typename string_type::traits_type;
    
    using _Size_type = typename string_type::size_type;


    using _Comparison_category = typename _Get_member_comparison_category<_Traits>::type;
#line 612 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"

    constexpr sub_match() : _Mybase(), matched(false) {}

    bool matched;

    [[nodiscard]] difference_type length() const {
        const _Mybase _Range(_Effective_range());
        return ::std:: distance(_Range.first, _Range.second);
    }

    operator string_type() const { 
        return str();
    }

    [[nodiscard]] string_type str() const { 
        const _Mybase _Range(_Effective_range());
        return string_type(_Range.first, _Range.second);
    }

    [[nodiscard]] int compare(const sub_match& _Right) const { 
        const _Mybase _LRange(_Effective_range());
        const _Mybase _RRange(_Right._Effective_range());
        return _Iter_compare<_Traits>(_LRange.first, _LRange.second, _RRange.first, _RRange.second);
    }

    [[nodiscard]] int compare(const string_type& _Right) const { 
        return _Compare(_Right.data(), _Right.size());
    }

    [[nodiscard]] int compare(  const value_type* _Ptr) const { 
        return _Compare(_Ptr, _Traits::length(_Ptr));
    }

    int _Compare(const value_type* const _Ptr, const _Size_type _Count) const {
        
        const _Mybase _Range(_Effective_range());
        return _Iter_compare<_Traits>(_Range.first, _Range.second, _Ptr, _Ptr + _Count);
    }

    bool _Match_equal(const sub_match& _Right) const { 
        const _Mybase _LRange(_Effective_range());
        const _Mybase _RRange(_Right._Effective_range());
        return ::std:: equal(_LRange.first, _LRange.second, _RRange.first, _RRange.second, _Char_traits_eq<_Traits>{});
    }

    bool _Match_equal(const value_type* const _Ptr, const _Size_type _Count) const {
        
        const _Mybase _Range(_Effective_range());
        return ::std:: equal(_Range.first, _Range.second, _Ptr, _Ptr + _Count, _Char_traits_eq<_Traits>{});
    }

    bool _Match_equal(const value_type* const _Ptr) const { 
        return _Match_equal(_Ptr, _Traits::length(_Ptr));
    }

    bool _Less(const sub_match& _Right) const { 
        const _Mybase _LRange(_Effective_range());
        const _Mybase _RRange(_Right._Effective_range());
        return ::std:: lexicographical_compare(
            _LRange.first, _LRange.second, _RRange.first, _RRange.second, _Char_traits_lt<_Traits>{});
    }

    bool _Less(const value_type* const _Ptr, const _Size_type _Count) const {
        
        const _Mybase _Range(_Effective_range());
        return ::std:: lexicographical_compare(
            _Range.first, _Range.second, _Ptr, _Ptr + _Count, _Char_traits_lt<_Traits>{});
    }

    bool _Less(const value_type* const _Ptr) const { 
        return _Less(_Ptr, _Traits::length(_Ptr));
    }

    bool _Greater(const value_type* const _Ptr, const _Size_type _Count) const {
        
        const _Mybase _Range(_Effective_range());
        return ::std:: lexicographical_compare(
            _Ptr, _Ptr + _Count, _Range.first, _Range.second, _Char_traits_lt<_Traits>{});
    }

    bool _Greater(const value_type* const _Ptr) const { 
        return _Greater(_Ptr, _Traits::length(_Ptr));
    }

    _Mybase _Effective_range() const { 
        if (matched) {
            return *this;
        } else {
            return _Mybase{};
        }
    }
};

using csub_match  = sub_match<const char*>;
using wcsub_match = sub_match<const wchar_t*>;
using ssub_match  = sub_match<string::const_iterator>;
using wssub_match = sub_match<wstring::const_iterator>;

template <class _BidIt>
[[nodiscard]] bool operator==(const sub_match<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
    return _Left._Match_equal(_Right);
}


template <class _BidIt>
[[nodiscard]] auto operator<=>(const sub_match<_BidIt>& _Left, const sub_match<_BidIt>& _Right) {
    return static_cast<typename sub_match<_BidIt>::_Comparison_category>(_Left.compare(_Right) <=> 0);
}


#line 746 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"

template <class _BidIt>
[[nodiscard]] bool operator==(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>* _Right) {
    return _Left._Match_equal(_Right);
}


template <class _BidIt>
[[nodiscard]] auto operator<=>(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>* _Right) {
    return static_cast<typename sub_match<_BidIt>::_Comparison_category>(_Left.compare(_Right) <=> 0);
}


#line 813 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"

template <class _BidIt>
[[nodiscard]] bool operator==(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>& _Right) {
    return _Left._Match_equal(::std:: addressof(_Right), 1);
}


template <class _BidIt>
[[nodiscard]] auto operator<=>(const sub_match<_BidIt>& _Left, const _Iter_value_t<_BidIt>& _Right) {
    return static_cast<typename sub_match<_BidIt>::_Comparison_category>(
        _Left._Compare(::std:: addressof(_Right), 1) <=> 0);
}


#line 881 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"

template <class _BidIt, class _Traits, class _Alloc>
[[nodiscard]] bool operator==(
    const sub_match<_BidIt>& _Left, const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Right) {
    return _Left._Match_equal(_Right.data(), _Right.size());
}


template <class _BidIt, class _Traits, class _Alloc>
[[nodiscard]] auto operator<=>(
    const sub_match<_BidIt>& _Left, const basic_string<_Iter_value_t<_BidIt>, _Traits, _Alloc>& _Right) {
    return static_cast<typename sub_match<_BidIt>::_Comparison_category>(_Left.compare(_Right) <=> 0);
}


#line 961 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"

template <class _Elem, class _Traits, class _BidIt>
basic_ostream<_Elem, _Traits>& operator<<(basic_ostream<_Elem, _Traits>& _Ostr, const sub_match<_BidIt>& _Match) {
    return _Ostr << _Match.str();
}

template <class _BidIt, class _Alloc = allocator<sub_match<_BidIt>>>
class match_results;

template <class _BidIt, class _Alloc, class _InIt, class _OutIt>
_OutIt _Format_default(const match_results<_BidIt, _Alloc>& _Match, _OutIt _Out, _InIt _First, _InIt _Last,
    regex_constants::match_flag_type _Flags = regex_constants::format_default);

template <class _BidIt, class _Alloc, class _InIt, class _OutIt>
_OutIt _Format_sed(const match_results<_BidIt, _Alloc>& _Match, _OutIt _Out, _InIt _First, _InIt _Last,
    regex_constants::match_flag_type _Flags = regex_constants::format_default);

template <class _BidIt, class _Alloc>
class match_results { 
public:
    using _Elem     = sub_match<_BidIt>;
    using _MyCont   = vector<_Elem, _Alloc>;
    using _Mytraits = allocator_traits<_Alloc>;

    using value_type      = _Elem;
    using const_reference = const value_type&;
    using reference       = value_type&;
    using const_iterator  = typename _MyCont::const_iterator;
    using iterator        = const_iterator;
    using difference_type = typename iterator_traits<_BidIt>::difference_type;
    using size_type       = typename _Mytraits::size_type;
    using allocator_type  = _Alloc;
    using char_type       = typename iterator_traits<_BidIt>::value_type;
    using string_type     = basic_string<char_type>;

    match_results() : _Org(), _Ready(false) {}

    explicit match_results(const _Alloc& _Al) : _Org(), _Ready(false), _Matches(_Al) {}

    [[nodiscard]] bool ready() const noexcept  {
        return _Ready;
    }

    [[nodiscard]] size_type size() const noexcept  {
        return _Matches.size();
    }

    [[nodiscard]] size_type max_size() const {
        return _Matches.max_size();
    }

    [[nodiscard]] bool empty() const noexcept  {
        return _Matches.empty();
    }

    [[nodiscard]] difference_type length(size_type _Sub = 0) const {
        return (*this)[_Sub].length();
    }

    [[nodiscard]] difference_type position(size_type _Sub = 0) const {
        return ::std:: distance(_Org, (*this)[_Sub].first);
    }

    [[nodiscard]] string_type str(size_type _Sub = 0) const {
        return string_type((*this)[_Sub]);
    }

    [[nodiscard]] const_reference operator[](size_type _Sub) const noexcept  {
        return _Matches.size() <= _Sub ? _Null_elem : _Matches[_Sub];
    }

    [[nodiscard]] const_reference prefix() const noexcept  {
        return _Prefix;
    }

    [[nodiscard]] const_reference suffix() const noexcept  {
        return _Suffix;
    }

    [[nodiscard]] const_iterator begin() const noexcept  {
        return _Matches.begin();
    }

    [[nodiscard]] const_iterator end() const noexcept  {
        return _Matches.end();
    }

    [[nodiscard]] const_iterator cbegin() const noexcept  {
        return _Matches.begin();
    }

    [[nodiscard]] const_iterator cend() const noexcept  {
        return _Matches.end();
    }

    const _Elem* _Unchecked_begin() const noexcept {
        return _Matches._Unchecked_begin();
    }

    const _Elem* _Unchecked_end() const noexcept {
        return _Matches._Unchecked_end();
    }

    template <class _OutIt>
    _OutIt _Format1(_OutIt _Out, const char_type* _Fmt_begin, const char_type* _Fmt_end,
        regex_constants::match_flag_type _Flags) const { 
        return _Flags & regex_constants::format_sed ? _Format_sed(*this, _Out, _Fmt_begin, _Fmt_end, _Flags)
                                                    : _Format_default(*this, _Out, _Fmt_begin, _Fmt_end, _Flags);
    }

    template <class _OutIt>
    _OutIt format(_OutIt _Out, const char_type* _Fmt_begin, const char_type* _Fmt_end,
        regex_constants::match_flag_type _Flags = regex_constants::format_default) const {
        
        _Adl_verify_range(_Fmt_begin, _Fmt_end);
        _Seek_wrapped(_Out, _Format1(_Get_unwrapped_unverified(_Out), _Fmt_begin, _Fmt_end, _Flags));
        return _Out;
    }

    template <class _OutIt, class _Traits1, class _Alloc1>
    _OutIt format(_OutIt _Out, const basic_string<char_type, _Traits1, _Alloc1>& _Fmt,
        regex_constants::match_flag_type _Flags = regex_constants::format_default) const {
        
        _Seek_wrapped(_Out, _Format1(_Get_unwrapped_unverified(_Out), _Fmt.data(), _Fmt.data() + _Fmt.size(), _Flags));
        return _Out;
    }

    template <class _Traits1, class _Alloc1>
    [[nodiscard]] basic_string<char_type, _Traits1, _Alloc1> format(const basic_string<char_type, _Traits1, _Alloc1>& _Fmt,
        regex_constants::match_flag_type _Flags = regex_constants::format_default) const {
        
        basic_string<char_type, _Traits1, _Alloc1> _Str;
        format(::std:: back_inserter(_Str), _Fmt.data(), _Fmt.data() + _Fmt.size(), _Flags);
        return _Str;
    }

    [[nodiscard]] string_type format(
        const char_type* _Fmt_begin, regex_constants::match_flag_type _Flags = regex_constants::format_default) const {
        
        return format(static_cast<string_type>(_Fmt_begin), _Flags);
    }

    [[nodiscard]] allocator_type get_allocator() const noexcept  {
        return static_cast<allocator_type>(_Matches.get_allocator());
    }

    void swap(match_results& _Right) noexcept(_Is_nothrow_swappable<_BidIt>::value)  {
        ::std:: swap(_Ready, _Right._Ready);
        _Swap_adl(_Org, _Right._Org);
        _Matches.swap(_Right._Matches);
        ::std:: swap(_Prefix, _Right._Prefix);
        ::std:: swap(_Suffix, _Right._Suffix);
    }

    void _Resize(unsigned int _Nx) {
        _Matches.resize(_Nx);
    }

    _Elem& _Pfx() noexcept {
        return _Prefix;
    }

    _Elem& _Sfx() noexcept {
        return _Suffix;
    }

    _Elem& _Null() noexcept {
        return _Null_elem;
    }

    _Elem& _At(unsigned int _Sub) noexcept {
        return _Matches[_Sub];
    }

    _Elem _At(unsigned int _Sub) const noexcept {
        return _Matches[_Sub];
    }

    _BidIt _Org;
    bool _Ready;

private:
    _MyCont _Matches;
    _Elem _Prefix;
    _Elem _Suffix;
    _Elem _Null_elem;
};

template <class _BidIt, class _Alloc>
[[nodiscard]] bool operator==(const match_results<_BidIt, _Alloc>& _Left, const match_results<_BidIt, _Alloc>& _Right) {
    if (!_Left.ready() && !_Right.ready()) {
        return true;
    } else if (!_Left.ready() || !_Right.ready()) {
        return false;
    } else if (_Left.empty() && _Right.empty()) {
        return true;
    } else if (_Left.empty() || _Right.empty()) {
        return false;
    } else {
        return _Left.size() == _Right.size() && _Left.prefix() == _Right.prefix() && _Left.suffix() == _Right.suffix()
            && ::std:: equal(_Left.begin(), _Left.end(), _Right.begin());
    }
}


#line 1171 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"

const unsigned int _BRE_MAX_GRP = 9U;

const unsigned int _Bmp_max   = 256U; 
const unsigned int _Bmp_shift = 3U;
const unsigned int _Bmp_chrs  = 1U << _Bmp_shift; 
const unsigned int _Bmp_mask  = _Bmp_chrs - 1U;
const unsigned int _Bmp_size  = (_Bmp_max + _Bmp_chrs - 1U) / _Bmp_chrs;

const unsigned int _Buf_incr        = 16U;
const unsigned int _ARRAY_THRESHOLD = 4U;

enum _Node_flags : int { 
    _Fl_none    = 0x00,
    _Fl_negate  = 0x01,
    _Fl_greedy  = 0x02,
    _Fl_final   = 0x04,
    _Fl_longest = 0x08
};

[[nodiscard]] constexpr _Node_flags operator&(_Node_flags _Left, _Node_flags _Right) noexcept { using _IntTy = ::std:: underlying_type_t<_Node_flags>; return static_cast<_Node_flags>(static_cast<_IntTy>(_Left) & static_cast<_IntTy>(_Right)); } [[nodiscard]] constexpr _Node_flags operator|(_Node_flags _Left, _Node_flags _Right) noexcept { using _IntTy = ::std:: underlying_type_t<_Node_flags>; return static_cast<_Node_flags>(static_cast<_IntTy>(_Left) | static_cast<_IntTy>(_Right)); } [[nodiscard]] constexpr _Node_flags operator^(_Node_flags _Left, _Node_flags _Right) noexcept { using _IntTy = ::std:: underlying_type_t<_Node_flags>; return static_cast<_Node_flags>(static_cast<_IntTy>(_Left) ^ static_cast<_IntTy>(_Right)); } constexpr _Node_flags& operator&=(_Node_flags& _Left, _Node_flags _Right) noexcept { return _Left = _Left & _Right; } constexpr _Node_flags& operator|=(_Node_flags& _Left, _Node_flags _Right) noexcept { return _Left = _Left | _Right; } constexpr _Node_flags& operator^=(_Node_flags& _Left, _Node_flags _Right) noexcept { return _Left = _Left ^ _Right; } [[nodiscard]] constexpr _Node_flags operator~(_Node_flags _Left) noexcept { using _IntTy = ::std:: underlying_type_t<_Node_flags>; return static_cast<_Node_flags>(~static_cast<_IntTy>(_Left)); } [[nodiscard]] constexpr bool _Bitmask_includes( _Node_flags _Left, _Node_flags _Elements) noexcept { return (_Left & _Elements) != _Node_flags{}; } [[nodiscard]] constexpr bool _Bitmask_includes_all( _Node_flags _Left, _Node_flags _Elements) noexcept { return (_Left & _Elements) == _Elements; }

enum _Node_type { 
    _N_none,
    _N_nop,
    _N_bol,
    _N_eol,
    _N_wbound,
    _N_dot,
    _N_str,
    _N_class,
    _N_group,
    _N_end_group,
    _N_assert,
    _N_neg_assert,
    _N_end_assert,
    _N_capture,
    _N_end_capture,
    _N_back,
    _N_if,
    _N_endif,
    _N_rep,
    _N_end_rep,
    _N_begin,
    _N_end
};

template <class _Elem>
struct _Buf { 
    _Buf() : _Sz(0), _Nchrs(0), _Chrs(nullptr) {}

    ~_Buf() noexcept {
        :: free(_Chrs);
    }

    unsigned int _Size() const {
        return _Nchrs;
    }

    _Elem _At(unsigned int _Idx) const {


#line 1234 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"

        return _Chrs[_Idx];
    }

    const _Elem* _Str() const {
        return _Chrs;
    }

    void _Insert(_Elem _Ch) { 
        if (_Sz <= _Nchrs) {
            _Expand(_Nchrs + _Buf_incr);
        }

        _Chrs[_Nchrs++] = _Ch;
    }

    _Elem _Del() { 
        return _Chrs[--_Nchrs];
    }

    template <class _FwdIt>
    void _Insert(_FwdIt _First, _FwdIt _Last) { 
        while (_First != _Last) {
            _Insert(*_First++);
        }
    }

private:
    void _Expand(unsigned int _Len) { 
        _Elem* _Tmp = static_cast<_Elem*>(:: realloc(_Chrs, _Get_size_of_n<sizeof(_Elem)>(_Len)));
        if (!_Tmp) {
            _Xbad_alloc();
        }

        _Chrs = _Tmp;
        _Sz   = _Len;
    }

    unsigned int _Sz;
    unsigned int _Nchrs;
    _Elem* _Chrs;
};

struct _Bitmap { 
    _Bitmap() {
        :: memset(_Chrs, '\0', _Bmp_size);
    }

    template <class _Elem>
    void _Mark(_Elem _Ch) { 
        static_assert(is_unsigned_v<_Elem>, "_Elem must be unsigned");
        unsigned int _Wide = _Ch;
        _Chrs[_Wide >> _Bmp_shift] |= (1 << (_Wide & _Bmp_mask));
    }

    template <class _Elem>
    bool _Find(_Elem _Ch) const {
        static_assert(is_unsigned_v<_Elem>, "_Elem must be unsigned");
        unsigned int _Wide = _Ch;
        return (_Chrs[_Wide >> _Bmp_shift] & (1 << (_Wide & _Bmp_mask))) != 0;
    }

private:
    unsigned char _Chrs[_Bmp_size];
};

template <class _Elem>
struct _Sequence { 
    explicit _Sequence(unsigned int _Len) : _Sz(_Len) {}

    unsigned int _Sz;
    _Buf<_Elem> _Data;
    _Sequence* _Next;
};

class _Node_base { 
public:
    explicit _Node_base(_Node_type _Ty, _Node_flags _Fl = _Fl_none)
        : _Kind(_Ty), _Flags(_Fl), _Next(nullptr), _Prev(nullptr) {}

    _Node_type _Kind;
    _Node_flags _Flags;
    _Node_base* _Next;
    _Node_base* _Prev;

    virtual ~_Node_base() noexcept {}
};

inline void _Destroy_node(_Node_base* _Nx, _Node_base* _Ne = nullptr) noexcept { 
    while (_Nx != _Ne && _Nx) { 
        _Node_base* _Tmp = _Nx;
        _Nx              = _Nx->_Next;
        _Tmp->_Next      = nullptr;
        delete _Tmp;
    }
}

class _Root_node : public _Node_base { 
public:
    _Root_node() : _Node_base(_N_begin), _Loops(0), _Marks(0), _Refs(0) {
        static_assert(sizeof(_Refs) == sizeof(_Atomic_counter_t), "invalid _Refs size");
    }

    regex_constants::syntax_option_type _Fl;
    unsigned int _Loops;
    unsigned int _Marks;
    unsigned int _Refs;
};

class _Node_end_group : public _Node_base { 
public:
    _Node_end_group(_Node_type _Ty, _Node_flags _Fl, _Node_base* _Bx) : _Node_base(_Ty, _Fl), _Back(_Bx) {}

    _Node_base* _Back;
};

class _Node_assert : public _Node_base { 
public:
    explicit _Node_assert(_Node_type _Ty, _Node_flags _Fl = _Fl_none) : _Node_base(_Ty, _Fl), _Child(nullptr) {}

    ~_Node_assert() noexcept {
        _Destroy_node(_Child);
    }

    _Node_base* _Child;
};

class _Node_capture : public _Node_base { 
public:
    explicit _Node_capture(unsigned int _Ix) : _Node_base(_N_capture, _Fl_none), _Idx(_Ix) {}

    unsigned int _Idx;
};

class _Node_back : public _Node_base { 
public:
    explicit _Node_back(unsigned int _Ix) : _Node_base(_N_back, _Fl_none), _Idx(_Ix) {}

    unsigned int _Idx;
};

template <class _Elem>
class _Node_str : public _Node_base { 
public:
    explicit _Node_str(_Node_flags _Fl = _Fl_none) : _Node_base(_N_str, _Fl) {}

    _Buf<_Elem> _Data;
};

template <class _Elem, class _RxTraits>
class _Node_class : public _Node_base { 
public:
    explicit _Node_class(_Node_type _Ty = _N_class, _Node_flags _Fl = _Fl_none)
        : _Node_base(_Ty, _Fl), _Coll(nullptr), _Small(nullptr), _Large(nullptr), _Ranges(nullptr), _Classes{},
          _Equiv(nullptr) {}

    ~_Node_class() noexcept {
        _Tidy(_Coll);
        delete _Small;
        delete _Large;
        delete _Ranges;
        _Tidy(_Equiv);
    }

    void _Tidy(_Sequence<_Elem>* _Head) noexcept { 
        while (_Head) { 
            _Sequence<_Elem>* _Temp = _Head;
            _Head                   = _Head->_Next;
            delete _Temp;
        }
    }

    _Sequence<_Elem>* _Coll;
    _Bitmap* _Small;
    _Buf<_Elem>* _Large;
    _Buf<_Elem>* _Ranges;
    typename _RxTraits::char_class_type _Classes;
    _Sequence<_Elem>* _Equiv;
};

class _Node_endif : public _Node_base { 
public:
    _Node_endif() : _Node_base(_N_endif, _Fl_none) {}
};

class _Node_if : public _Node_base { 
public:
    explicit _Node_if(_Node_base* _End)
        : _Node_base(_N_if, _Fl_none), _Endif(static_cast<_Node_endif*>(_End)), _Child(nullptr) {}

    ~_Node_if() noexcept {
        _Node_if* _Cur = _Child;
        while (_Cur) { 
            _Node_if* _Tmp = _Cur;
            _Cur           = _Cur->_Child;
            _Tmp->_Child   = nullptr;
            _Destroy_node(_Tmp, _Endif);
        }
    }

    _Node_endif* _Endif;
    _Node_if* _Child;
};

class _Node_rep;

class _Node_end_rep : public _Node_base { 
public:
    _Node_end_rep() : _Node_base(_N_end_rep), _Begin_rep(nullptr) {}

    _Node_rep* _Begin_rep;

    _Node_end_rep& operator=(const _Node_end_rep&) = delete;
};

struct _Loop_vals_t { 
    int _Loop_idx;
    void* _Loop_iter;
};

class _Node_rep : public _Node_base { 
public:
    _Node_rep(bool _Greedy, int _Mn, int _Mx, _Node_end_rep* _End, unsigned int _Number)
        : _Node_base(_N_rep, _Greedy ? _Fl_greedy : _Fl_none), _Min(_Mn), _Max(_Mx), _End_rep(_End),
          _Loop_number(_Number), _Simple_loop(-1) {}

    const int _Min;
    const int _Max;
    _Node_end_rep* _End_rep;
    unsigned int _Loop_number;
    int _Simple_loop; 

    _Node_rep& operator=(const _Node_rep&) = delete;
};

template <class _FwdIt, class _Elem, class _RxTraits>
class _Builder { 
public:
    using _Difft = typename iterator_traits<_FwdIt>::difference_type;

    _Builder(const _RxTraits& _Tr, regex_constants::syntax_option_type);
    bool _Beg_expr() const;
    void _Setlong();
    
    void _Tidy() noexcept;
    _Node_base* _Getmark() const;

    void _Add_nop();
    void _Add_bol();
    void _Add_eol();
    void _Add_wbound();
    void _Add_dot();
    void _Add_char(_Elem _Ch);
    void _Add_class();
    void _Add_char_to_class(_Elem _Ch);
    void _Add_range(_Elem _Ex0, _Elem _Ex1);
    void _Add_named_class(_Regex_traits_base::char_class_type, bool = false);
    void _Add_equiv(_FwdIt, _FwdIt, _Difft);
    void _Add_coll(_FwdIt, _FwdIt, _Difft);
    _Node_base* _Begin_group();
    void _End_group(_Node_base* _Back);
    _Node_base* _Begin_assert_group(bool);
    void _End_assert_group(_Node_base*);
    _Node_base* _Begin_capture_group(unsigned int _Idx);
    void _Add_backreference(unsigned int _Idx);
    _Node_base* _Begin_if(_Node_base* _Start);
    void _Else_if(_Node_base*, _Node_base*);
    void _Add_rep(int _Min, int _Max, bool _Greedy);
    void _Negate();
    void _Mark_final();
    _Root_node* _End_pattern();

private:
    _Node_base* _Link_node(_Node_base*);
    static void _Insert_node(_Node_base*, _Node_base*);
    _Node_base* _New_node(_Node_type _Kind);
    void _Add_str_node();
    bool _Beg_expr(_Node_base*) const;
    void _Add_char_to_bitmap(_Elem _Ch);
    void _Add_char_to_array(_Elem _Ch);
    void _Add_elts(_Node_class<_Elem, _RxTraits>*, _Regex_traits_base::char_class_type, bool);
    void _Char_to_elts(_FwdIt, _FwdIt, _Difft, _Sequence<_Elem>**);

    _Root_node* _Root;
    _Node_base* _Current;
    regex_constants::syntax_option_type _Flags;
    const _RxTraits& _Traits;
    const int _Bmax; 
    const int _Tmax; 

    unsigned int _Get_bmax() const;
    unsigned int _Get_tmax() const;

public:
    _Builder& operator=(const _Builder&) = delete;
};

template <class _BidIt>
class _Bt_state_t { 
public:
    _BidIt _Cur;
    vector<bool> _Grp_valid;
};

template <class _BidIt>
class _Tgt_state_t : public _Bt_state_t<_BidIt> { 
public:
    struct _Grp_t { 
        _BidIt _Begin;
        _BidIt _End;
    };

    vector<_Grp_t> _Grps;

    void operator=(const _Bt_state_t<_BidIt>& _Other) {
        static_cast<_Bt_state_t<_BidIt>&>(*this) = _Other;
    }
};

template <class _BidIt, class _Elem, class _RxTraits, class _It>
class _Matcher { 
public:
    _Matcher(_It _Pfirst, _It _Plast, const _RxTraits& _Tr, _Root_node* _Re, unsigned int _Nx,
        regex_constants::syntax_option_type _Sf, regex_constants::match_flag_type _Mf)
        : _End(_Plast), _First(_Pfirst), _Rep(_Re), _Sflags(_Sf), _Mflags(_Mf), _Matched(false),
          _Ncap(static_cast<int>(_Nx)), _Longest((_Re->_Flags & _Fl_longest) && !(_Mf & regex_constants::match_any)),
          _Traits(_Tr) {
        _Loop_vals.resize(_Re->_Loops);
        _Adl_verify_range(_Pfirst, _Plast);
    }

    void _Setf(regex_constants::match_flag_type _Mf) { 
        _Mflags |= _Mf;
    }

    void _Clearf(regex_constants::match_flag_type _Mf) { 
        _Mflags &= ~_Mf;
    }

    template <class _Alloc>
    bool _Match(_It _Pfirst, match_results<_BidIt, _Alloc>* _Matches, bool _Full_match) {
        
        _First = _Pfirst;
        return _Match(_Matches, _Full_match);
    }

    template <class _Alloc>
    bool _Match(match_results<_BidIt, _Alloc>* _Matches, bool _Full_match) {
        
        if (_Matches) { 
            _Matches->_Ready = true;
            _Matches->_Resize(0);
        }

        _Begin          = _First;
        _Tgt_state._Cur = _First;
        _Tgt_state._Grp_valid.resize(_Get_ncap());
        _Tgt_state._Grps.resize(_Get_ncap());
        _Cap                  = static_cast<bool>(_Matches);
        _Full                 = _Full_match;
        _Max_complexity_count = 10000000L;
        _Max_stack_count      = 1000L;

        _Matched = false;

        if (!_Match_pat(_Rep)) {
            return false;
        }

        if (_Matches) { 
            _Matches->_Resize(_Get_ncap());
            for (unsigned int _Idx = 0; _Idx < _Get_ncap(); ++_Idx) { 
                if (_Res._Grp_valid[_Idx]) { 
                    _Matches->_At(_Idx).matched = true;
                    _Matches->_At(_Idx).first   = _Res._Grps[_Idx]._Begin;
                    _Matches->_At(_Idx).second  = _Res._Grps[_Idx]._End;
                } else { 
                    _Matches->_At(_Idx).matched = false;
                    _Matches->_At(_Idx).first   = _End;
                    _Matches->_At(_Idx).second  = _End;
                }
            }
            _Matches->_Org           = _Begin;
            _Matches->_Pfx().first   = _Begin;
            _Matches->_Pfx().second  = _Matches->_At(0).first;
            _Matches->_Pfx().matched = _Matches->_Pfx().first != _Matches->_Pfx().second;

            _Matches->_Sfx().first   = _Matches->_At(0).second;
            _Matches->_Sfx().second  = _End;
            _Matches->_Sfx().matched = _Matches->_Sfx().first != _Matches->_Sfx().second;

            _Matches->_Null().first  = _End;
            _Matches->_Null().second = _End;
        }
        return true;
    }

    _BidIt _Skip(_BidIt, _BidIt, _Node_base* = nullptr);

private:
    _Tgt_state_t<_It> _Tgt_state;
    _Tgt_state_t<_It> _Res;
    vector<_Loop_vals_t> _Loop_vals;

    bool _Do_if(_Node_if*);
    bool _Do_rep0(_Node_rep*, bool);
    bool _Do_rep(_Node_rep*, bool, int);
    bool _Do_class(_Node_base*);
    bool _Match_pat(_Node_base*);
    bool _Better_match();
    bool _Is_wbound() const;

    unsigned int _Get_ncap() const;

    _It _Begin;
    _It _End;
    _It _First;
    _Node_base* _Rep;
    regex_constants::syntax_option_type _Sflags;
    regex_constants::match_flag_type _Mflags;
    bool _Matched;
    bool _Cap;
    int _Ncap; 
    bool _Longest;
    const _RxTraits& _Traits;
    bool _Full;
    long _Max_complexity_count;
    long _Max_stack_count;

public:
    _Matcher& operator=(const _Matcher&) = delete;
};

enum _Prs_ret { 
    _Prs_none,
    _Prs_chr,
    _Prs_set
};

template <class _FwdIt, class _Elem, class _RxTraits>
class _Parser { 
public:
    using char_class_type = typename _RxTraits::char_class_type;

    _Parser(const _RxTraits& _Tr, _FwdIt _Pfirst, _FwdIt _Plast, regex_constants::syntax_option_type _Fx);
    _Root_node* _Compile();

    unsigned int _Mark_count() const {
        return _Grp_idx + 1;
    }

private:
    
    void _Error(regex_constants::error_type);

    bool _Is_esc() const;
    void _Trans();
    void _Next();
    void _Expect(_Meta_type, regex_constants::error_type);

    
    int _Do_digits(int _Base, int _Count);
    bool _DecimalDigits();
    void _HexDigits(int);
    bool _OctalDigits();
    void _Do_ex_class(_Meta_type);
    bool _CharacterClassEscape(bool);
    _Prs_ret _ClassEscape(bool);
    _Prs_ret _ClassAtom();
    void _ClassRanges();
    void _CharacterClass();
    bool _IdentityEscape();
    bool _IsIdentityEscape() const;
    bool _Do_ffn(_Elem);
    bool _Do_ffnx(_Elem);
    bool _CharacterEscape();
    void _AtomEscape();
    void _Do_capture_group();
    void _Do_noncapture_group();
    void _Do_assert_group(bool);
    bool _Wrapped_disjunction();
    void _Quantifier();
    bool _Alternative();
    void _Disjunction();

    _FwdIt _Pat;
    _FwdIt _Begin;
    _FwdIt _End;
    unsigned int _Grp_idx;
    int _Disj_count;
    vector<bool> _Finished_grps;
    _Builder<_FwdIt, _Elem, _RxTraits> _Nfa;
    const _RxTraits& _Traits;
    regex_constants::syntax_option_type _Flags;
    int _Val;
    _Elem _Char;
    _Meta_type _Mchar;
    unsigned int _L_flags;
};

enum _Lang_flags { 
    _L_ext_rep    = 0x00000001, 
    _L_alt_pipe   = 0x00000002, 
    _L_alt_nl     = 0x00000004, 
    _L_nex_grp    = 0x00000008, 
    _L_nex_rep    = 0x00000010, 
    _L_nc_grp     = 0x00000020, 
    _L_asrt_gen   = 0x00000040, 
    _L_asrt_wrd   = 0x00000080, 
    _L_bckr       = 0x00000100, 
    _L_lim_bckr   = 0x00000200, 
    _L_ngr_rep    = 0x00000400, 
    _L_esc_uni    = 0x00000800, 
    _L_esc_hex    = 0x00001000, 
    _L_esc_oct    = 0x00002000, 
    _L_esc_bsl    = 0x00004000, 
    _L_esc_ffnx   = 0x00008000, 
    _L_esc_ffn    = 0x00010000, 
    _L_esc_wsd    = 0x00020000, 
    _L_esc_ctrl   = 0x00040000, 
    _L_no_nl      = 0x00080000, 
    _L_bzr_chr    = 0x00100000, 
    _L_grp_esc    = 0x00200000, 
    _L_ident_ECMA = 0x00400000, 
    _L_ident_ERE  = 0x00800000, 
    _L_ident_awk  = 0x01000000, 
    _L_anch_rstr  = 0x02000000, 
    _L_star_beg   = 0x04000000, 
    _L_empty_grp  = 0x08000000, 
    _L_paren_bal  = 0x10000000, 
    _L_brk_rstr   = 0x20000000, 
    _L_mtch_long  = 0x40000000, 
};

class _Regex_base : public _Container_base { 
public:


#line 1782 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"
};

template <class _Elem, class _RxTraits = regex_traits<_Elem>>
class basic_regex : public _Regex_base { 
public:
    using value_type  = _Elem;
    using traits_type = _RxTraits;
    using locale_type = typename _RxTraits::locale_type;
    using string_type = typename _RxTraits::string_type;
    using flag_type   = regex_constants::syntax_option_type;

    static constexpr flag_type icase      = regex_constants::icase;
    static constexpr flag_type nosubs     = regex_constants::nosubs;
    static constexpr flag_type optimize   = regex_constants::optimize;
    static constexpr flag_type collate    = regex_constants::collate;
    static constexpr flag_type ECMAScript = regex_constants::ECMAScript;
    static constexpr flag_type basic      = regex_constants::basic;
    static constexpr flag_type extended   = regex_constants::extended;
    static constexpr flag_type awk        = regex_constants::awk;
    static constexpr flag_type grep       = regex_constants::grep;
    static constexpr flag_type egrep      = regex_constants::egrep;

    basic_regex() : _Rep(nullptr) {} 

    explicit basic_regex(  const _Elem* _Ptr, flag_type _Flags = regex_constants::ECMAScript) : _Rep(nullptr) {
        _Reset(_Ptr, _Ptr + _RxTraits::length(_Ptr), _Flags, random_access_iterator_tag{});
    }

    basic_regex(  const _Elem* _Ptr, size_t _Count, flag_type _Flags = regex_constants::ECMAScript)
        : _Rep(nullptr) {
        if (_Ptr) {
            _Reset(_Ptr, _Ptr + _Count, _Flags, random_access_iterator_tag{});
            return;
        }

        _Xregex_error(regex_constants::error_parse);
    }

    template <class _STtraits, class _STalloc>
    explicit basic_regex(
        const basic_string<_Elem, _STtraits, _STalloc>& _Str, flag_type _Flags = regex_constants::ECMAScript)
        : _Rep(nullptr) {
        _Reset(_Str.data(), _Str.data() + static_cast<ptrdiff_t>(_Str.size()), _Flags, random_access_iterator_tag{});
    }

    template <class _InIt>
    basic_regex(_InIt _First, _InIt _Last, flag_type _Flags) : _Rep(nullptr) {
        _Adl_verify_range(_First, _Last);
        _Reset(_Get_unwrapped(_First), _Get_unwrapped(_Last), _Flags, _Iter_cat_t<_InIt>{});
    }

    template <class _InIt>
    basic_regex(_InIt _First, _InIt _Last) : _Rep(nullptr) {
        _Adl_verify_range(_First, _Last);
        _Reset(_Get_unwrapped(_First), _Get_unwrapped(_Last), regex_constants::ECMAScript, _Iter_cat_t<_InIt>{});
    }

    basic_regex(const basic_regex& _Right)


#line 1843 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"
        : _Rep(nullptr), _Traits(_Right._Traits)
#line 1845 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"
    { 
        _Reset(_Right._Rep);
    }

    basic_regex(initializer_list<_Elem> _Ilist, flag_type _Flags = regex_constants::ECMAScript) : _Rep(nullptr) {
        _Reset(_Ilist.begin(), _Ilist.end(), _Flags, random_access_iterator_tag{});
    }

    basic_regex& operator=(initializer_list<_Elem> _Ilist) { 
        return assign(_Ilist);
    }

    basic_regex& assign(initializer_list<_Elem> _Ilist, flag_type _Flags = regex_constants::ECMAScript) {
        
        _Reset(_Ilist.begin(), _Ilist.end(), _Flags, random_access_iterator_tag{});
        return *this;
    }

    basic_regex(basic_regex&& _Right) noexcept : _Rep(nullptr) {
        _Assign_rv(::std:: move(_Right));
    }

    basic_regex& operator=(basic_regex&& _Right) noexcept {
        _Assign_rv(::std:: move(_Right));
        return *this;
    }

    void _Assign_rv(basic_regex&& _Right) {
        if (this != ::std:: addressof(_Right)) { 
            _Tidy();


#line 1879 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"

            _Rep        = _Right._Rep;
            _Right._Rep = nullptr;
        }
    }

    basic_regex& assign(basic_regex&& _Right) noexcept {
        _Assign_rv(::std:: move(_Right));
        return *this;
    }

    ~basic_regex() noexcept {
        _Tidy();
    }

    basic_regex& operator=(const basic_regex& _Right) {
        return assign(_Right);
    }

    basic_regex& operator=(  const _Elem* _Ptr) {
        _Reset(_Ptr, _Ptr + _RxTraits::length(_Ptr), ECMAScript, random_access_iterator_tag{});
        return *this;
    }

    template <class _STtraits, class _STalloc>
    basic_regex& operator=(const basic_string<_Elem, _STtraits, _STalloc>& _Str) {
        _Reset(
            _Str.data(), _Str.data() + static_cast<ptrdiff_t>(_Str.size()), ECMAScript, random_access_iterator_tag{});
        return *this;
    }

    unsigned int _Loop_count() const {
        return _Rep ? _Rep->_Loops : 0;
    }

    [[nodiscard]] unsigned int mark_count() const {
        return _Rep ? _Rep->_Marks - 1 : 0;
    }

    basic_regex& assign(const basic_regex& _Right) {


#line 1922 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"

        _Reset(_Right._Rep);
        return *this;
    }

    basic_regex& assign(  const _Elem* _Ptr, flag_type _Flags = regex_constants::ECMAScript) {
        return assign(_Ptr, _RxTraits::length(_Ptr), _Flags);
    }

    basic_regex& assign(
          const _Elem* _Ptr, size_t _Count, flag_type _Flags = regex_constants::ECMAScript) {
        _Reset(_Ptr, _Ptr + _Count, _Flags, random_access_iterator_tag{});
        return *this;
    }

    template <class _STtraits, class _STalloc>
    basic_regex& assign(
        const basic_string<_Elem, _STtraits, _STalloc>& _Str, flag_type _Flags = regex_constants::ECMAScript) {
        _Reset(_Str.data(), _Str.data() + static_cast<ptrdiff_t>(_Str.size()), _Flags, random_access_iterator_tag{});
        return *this;
    }

    template <class _InIt>
    basic_regex& assign(_InIt _First, _InIt _Last, flag_type _Flags = regex_constants::ECMAScript) {
        _Adl_verify_range(_First, _Last);
        _Reset(_Get_unwrapped(_First), _Get_unwrapped(_Last), _Flags, _Iter_cat_t<_InIt>{});
        return *this;
    }

    [[nodiscard]] flag_type flags() const {
        return _Rep ? _Rep->_Fl : flag_type{};
    }

    locale_type imbue(locale_type _Loc) { 
        _Tidy();
        return _Traits.imbue(_Loc);
    }

    locale_type getloc() const {
        return _Traits.getloc();
    }

    void swap(basic_regex& _Right) noexcept  {
        ::std:: swap(_Rep, _Right._Rep);


#line 1970 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"
    }

    _Root_node* _Get() const {
        return _Rep;
    }

    bool _Empty() const {
        return _Rep == nullptr;
    }

    const _RxTraits& _Get_traits() const {
        return _Traits;
    }

private:
    _Root_node* _Rep;
    _RxTraits _Traits;


#line 1991 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"

    void _Tidy() noexcept { 
        if (_Rep && _InterlockedDecrement(reinterpret_cast<volatile long*>(&reinterpret_cast<_Atomic_counter_t&>(_Rep->_Refs))) == 0) {
            _Destroy_node(_Rep);
        }

        _Rep = nullptr;
    }

    template <class _InIt>
    void _Reset(_InIt _First, _InIt _Last, flag_type _Flags, input_iterator_tag) {
        
        basic_string<_Iter_value_t<_InIt>> _Str(_First, _Last);

        _Reset(_Str.data(), _Str.data() + static_cast<ptrdiff_t>(_Str.size()), _Flags, forward_iterator_tag{});
    }

    template <class _FwdIt>
    void _Reset(_FwdIt _First, _FwdIt _Last, flag_type _Flags, forward_iterator_tag) {
        

#line 2014 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"

        _Parser<_FwdIt, _Elem, _RxTraits> _Prs(_Traits, _First, _Last, _Flags);
        _Root_node* _Rx = _Prs._Compile();
        _Reset(_Rx);
    }

    void _Reset(_Root_node* _Rx) { 
        if (_Rx) {
            _InterlockedIncrement(reinterpret_cast<volatile long*>(&reinterpret_cast<_Atomic_counter_t&>(_Rx->_Refs)));
        }

        _Tidy();
        _Rep = _Rx;
    }
};


template <class _FwdIt>
basic_regex(_FwdIt, _FwdIt, regex_constants::syntax_option_type = regex_constants::ECMAScript)
    -> basic_regex<typename iterator_traits<_FwdIt>::value_type>;
#line 2035 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"

template <class _Elem, class _RxTraits>
void swap(basic_regex<_Elem, _RxTraits>& _Left, basic_regex<_Elem, _RxTraits>& _Right) noexcept  {
    _Left.swap(_Right);
}

template <class _BidIt, class _Alloc>
void swap(match_results<_BidIt, _Alloc>& _Left, match_results<_BidIt, _Alloc>& _Right) noexcept(
    noexcept(_Left.swap(_Right)))  {
    _Left.swap(_Right);
}

using regex   = basic_regex<char>;
using wregex  = basic_regex<wchar_t>;
using cmatch  = match_results<const char*>;
using wcmatch = match_results<const wchar_t*>;
using smatch  = match_results<string::const_iterator>;
using wsmatch = match_results<wstring::const_iterator>;

template <class _BidIt, class _Alloc, class _InIt, class _OutIt>
_OutIt _Format_default(const match_results<_BidIt, _Alloc>& _Match, _OutIt _Out, _InIt _First, _InIt _Last,
    regex_constants::match_flag_type) { 
    while (_First != _Last) { 
        if (*_First != '$') {
            *_Out++ = *_First++;
        } else if (++_First == _Last) {
            *_Out++ = '$'; 
        } else if (*_First == '$') { 
            *_Out++ = '$';
            ++_First;
        } else if (*_First == '`') { 
            _Out = ::std:: copy(_Match.prefix().first, _Match.prefix().second, _Out);
            ++_First;
        } else if (*_First == '\'') { 
            _Out = ::std:: copy(_Match.suffix().first, _Match.suffix().second, _Out);
            ++_First;
        } else if (*_First == '&') { 
            ++_First;
            if (_Match.size() != 0) {
                _Out = ::std:: copy(_Match._At(0).first, _Match._At(0).second, _Out);
            }
        } else if ('0' <= *_First && *_First <= '9') { 
            auto _Num              = static_cast<unsigned int>(*_First++ - '0');
            const bool _Two_digits = _First != _Last && '0' <= *_First && *_First <= '9';
            if (_Two_digits) { 
                _Num *= 10;
                _Num += static_cast<unsigned int>(*_First++ - '0');
            }
            if (_Num == 0) { 
                *_Out++ = '$';
                *_Out++ = '0';
                if (_Two_digits) {
                    *_Out++ = '0';
                }
            } else if (_Num < _Match.size()) {
                _Out = ::std:: copy(_Match._At(_Num).first, _Match._At(_Num).second, _Out);
            }
        } else { 
            *_Out++ = '$';
            *_Out++ = *_First++;
        }
    }
    return _Out;
}

template <class _BidIt, class _Alloc, class _InIt, class _OutIt>
_OutIt _Format_sed(const match_results<_BidIt, _Alloc>& _Match, _OutIt _Out, _InIt _First, _InIt _Last,
    regex_constants::match_flag_type) { 
    while (_First != _Last) { 
        if (*_First == '&') { 
            ++_First;
            if (_Match.size() != 0) {
                _Out = ::std:: copy(_Match._At(0).first, _Match._At(0).second, _Out);
            }
        } else if (*_First != '\\') {
            *_Out++ = *_First++;
        } else if (++_First != _Last) {
            if ('0' <= *_First && *_First <= '9') { 
                const auto _Num = static_cast<unsigned int>(*_First++ - '0');
                if (_Num < _Match.size()) {
                    _Out = ::std:: copy(_Match._At(_Num).first, _Match._At(_Num).second, _Out);
                }
            } else {
                *_Out++ = *_First++; 
            }
        }
    }

    return _Out;
}

template <class _BidIt, class _Alloc, class _Elem, class _RxTraits, class _It>
bool _Regex_match1(_It _First, _It _Last, match_results<_BidIt, _Alloc>* _Matches,
    const basic_regex<_Elem, _RxTraits>& _Re, regex_constants::match_flag_type _Flgs,
    bool _Full) { 
    if (_Re._Empty()) {
        return false;
    }

    _Matcher<_BidIt, _Elem, _RxTraits, _It> _Mx(
        _First, _Last, _Re._Get_traits(), _Re._Get(), _Re.mark_count() + 1, _Re.flags(), _Flgs);
    return _Mx._Match(_Matches, _Full);
}

template <class _BidIt, class _Alloc, class _Elem, class _RxTraits>
bool regex_match(_BidIt _First, _BidIt _Last, match_results<_BidIt, _Alloc>& _Matches,
    const basic_regex<_Elem, _RxTraits>& _Re, regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
    
    _Adl_verify_range(_First, _Last);
    return _Regex_match1(_First, _Last, ::std:: addressof(_Matches), _Re, _Flgs, true);
}

template <class _BidIt, class _Elem, class _RxTraits>
[[nodiscard]] bool regex_match(_BidIt _First, _BidIt _Last, const basic_regex<_Elem, _RxTraits>& _Re,
    regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
    
    _Adl_verify_range(_First, _Last);
    return _Regex_match1(_Get_unwrapped(_First), _Get_unwrapped(_Last),
        static_cast<match_results<_Unwrapped_t<const _BidIt&>>*>(nullptr), _Re, _Flgs | regex_constants::match_any,
        true);
}

template <class _Elem, class _RxTraits>
[[nodiscard]] bool regex_match(  const _Elem* _Str, const basic_regex<_Elem, _RxTraits>& _Re,
    regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
    
    const _Elem* _Last = _Str + char_traits<_Elem>::length(_Str);
    return _Regex_match1(
        _Str, _Last, static_cast<match_results<const _Elem*>*>(nullptr), _Re, _Flgs | regex_constants::match_any, true);
}

template <class _Elem, class _Alloc, class _RxTraits>
bool regex_match(  const _Elem* _Str, match_results<const _Elem*, _Alloc>& _Matches,
    const basic_regex<_Elem, _RxTraits>& _Re, regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
    
    const _Elem* _Last = _Str + char_traits<_Elem>::length(_Str);
    return _Regex_match1(_Str, _Last, ::std:: addressof(_Matches), _Re, _Flgs, true);
}

template <class _StTraits, class _StAlloc, class _Alloc, class _Elem, class _RxTraits>
bool regex_match(const basic_string<_Elem, _StTraits, _StAlloc>& _Str,
    match_results<typename basic_string<_Elem, _StTraits, _StAlloc>::const_iterator, _Alloc>& _Matches,
    const basic_regex<_Elem, _RxTraits>& _Re, regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
    
    return _Regex_match1(_Str.begin(), _Str.end(), ::std:: addressof(_Matches), _Re, _Flgs, true);
}

template <class _StTraits, class _StAlloc, class _Alloc, class _Elem, class _RxTraits>
bool regex_match(const basic_string<_Elem, _StTraits, _StAlloc>&&,
    match_results<typename basic_string<_Elem, _StTraits, _StAlloc>::const_iterator, _Alloc>&,
    const basic_regex<_Elem, _RxTraits>&, regex_constants::match_flag_type = regex_constants::match_default) = delete;

template <class _StTraits, class _StAlloc, class _Elem, class _RxTraits>
[[nodiscard]] bool regex_match(const basic_string<_Elem, _StTraits, _StAlloc>& _Str,
    const basic_regex<_Elem, _RxTraits>& _Re, regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
    
    return _Regex_match1(_Str.data(), _Str.data() + _Str.size(), static_cast<match_results<const _Elem*>*>(nullptr),
        _Re, _Flgs | regex_constants::match_any, true);
}

template <class _BidIt, class _Alloc, class _Elem, class _RxTraits, class _It>
bool _Regex_search2(_It _First, _It _Last, match_results<_BidIt, _Alloc>* _Matches,
    const basic_regex<_Elem, _RxTraits>& _Re, regex_constants::match_flag_type _Flgs, _It _Org) {
    
    if (_Re._Empty()) {
        return false;
    }

    bool _Found      = false;
    const _It _Begin = _First;
    if ((_Flgs & regex_constants::_Skip_zero_length) && _First != _Last) {
        ++_First;
    }

    _Matcher<_BidIt, _Elem, _RxTraits, _It> _Mx(
        _First, _Last, _Re._Get_traits(), _Re._Get(), _Re.mark_count() + 1, _Re.flags(), _Flgs);

    if (_Mx._Match(_Matches, false)) {
        _Found = true;
    } else if (_First != _Last && !(_Flgs & regex_constants::match_continuous)) { 
        _Mx._Setf(regex_constants::match_prev_avail);
        _Mx._Clearf(regex_constants::_Match_not_null);
        while ((_First = _Mx._Skip(++_First, _Last)) != _Last) {
            if (_Mx._Match(_First, _Matches, false)) { 
                _Found = true;
                break;
            }
        }

        if (!_Found && _Mx._Match(_Last, _Matches, false)) {
            _Found = true;
        }
    }

    if (_Found && _Matches) { 
        _Matches->_Org           = _Org;
        _Matches->_Pfx().first   = _Begin;
        _Matches->_Pfx().matched = _Matches->_Pfx().first != _Matches->_Pfx().second;
    }
    return _Found;
}

template <class _BidIt, class _Alloc, class _Elem, class _RxTraits>
bool regex_search(_BidIt _First, _BidIt _Last, match_results<_BidIt, _Alloc>& _Matches,
    const basic_regex<_Elem, _RxTraits>& _Re, regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
    
    _Adl_verify_range(_First, _Last);
    return _Regex_search2(_First, _Last, ::std:: addressof(_Matches), _Re, _Flgs, _First);
}

template <class _BidIt, class _Elem, class _RxTraits>
[[nodiscard]] bool regex_search(_BidIt _First, _BidIt _Last, const basic_regex<_Elem, _RxTraits>& _Re,
    regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
    
    _Adl_verify_range(_First, _Last);
    return _Regex_search2(_Get_unwrapped(_First), _Get_unwrapped(_Last),
        static_cast<match_results<_Unwrapped_t<const _BidIt&>>*>(nullptr), _Re, _Flgs | regex_constants::match_any,
        _Get_unwrapped(_First));
}

template <class _Elem, class _RxTraits>
[[nodiscard]] bool regex_search(  const _Elem* _Str, const basic_regex<_Elem, _RxTraits>& _Re,
    regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
    
    const _Elem* _Last = _Str + char_traits<_Elem>::length(_Str);
    return _Regex_search2(
        _Str, _Last, static_cast<match_results<const _Elem*>*>(nullptr), _Re, _Flgs | regex_constants::match_any, _Str);
}

template <class _Elem, class _Alloc, class _RxTraits>
bool regex_search(  const _Elem* _Str, match_results<const _Elem*, _Alloc>& _Matches,
    const basic_regex<_Elem, _RxTraits>& _Re, regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
    
    const _Elem* _Last = _Str + char_traits<_Elem>::length(_Str);
    return _Regex_search2(_Str, _Last, ::std:: addressof(_Matches), _Re, _Flgs, _Str);
}

template <class _StTraits, class _StAlloc, class _Alloc, class _Elem, class _RxTraits>
bool regex_search(const basic_string<_Elem, _StTraits, _StAlloc>& _Str,
    match_results<typename basic_string<_Elem, _StTraits, _StAlloc>::const_iterator, _Alloc>& _Matches,
    const basic_regex<_Elem, _RxTraits>& _Re, regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
    
    return _Regex_search2(_Str.begin(), _Str.end(), ::std:: addressof(_Matches), _Re, _Flgs, _Str.begin());
}

template <class _StTraits, class _StAlloc, class _Alloc, class _Elem, class _RxTraits>
bool regex_search(const basic_string<_Elem, _StTraits, _StAlloc>&&,
    match_results<typename basic_string<_Elem, _StTraits, _StAlloc>::const_iterator, _Alloc>&,
    const basic_regex<_Elem, _RxTraits>&, regex_constants::match_flag_type = regex_constants::match_default) = delete;

template <class _StTraits, class _StAlloc, class _Elem, class _RxTraits>
[[nodiscard]] bool regex_search(const basic_string<_Elem, _StTraits, _StAlloc>& _Str,
    const basic_regex<_Elem, _RxTraits>& _Re, regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
    
    using _Iter = typename basic_string<_Elem, _StTraits, _StAlloc>::const_pointer;

    _Iter _First = _Str.c_str();
    _Iter _Last  = _First + _Str.size();
    return _Regex_search2(
        _First, _Last, static_cast<match_results<_Iter>*>(nullptr), _Re, _Flgs | regex_constants::match_any, _First);
}

template <class _OutIt, class _BidIt, class _RxTraits, class _Elem, class _Traits, class _Alloc>
_OutIt _Regex_replace1(_OutIt _Result, _BidIt _First, _BidIt _Last, const basic_regex<_Elem, _RxTraits>& _Re,
    const basic_string<_Elem, _Traits, _Alloc>& _Fmt, regex_constants::match_flag_type _Flgs) {
    
    match_results<_BidIt> _Matches;
    _BidIt _Pos                             = _First;
    regex_constants::match_flag_type _Flags = _Flgs;
    regex_constants::match_flag_type _Not_null{};

    while (
        _Regex_search2(_Pos, _Last, ::std:: addressof(_Matches), _Re, _Flags | _Not_null, _Pos)) { 
        if (!(_Flgs & regex_constants::format_no_copy)) {
            _Result = ::std:: copy(_Matches.prefix().first, _Matches.prefix().second, _Result);
        }

        _Result = _Matches._Format1(_Result, _Fmt.data(), _Fmt.data() + _Fmt.size(), _Flags);

        _Pos = _Matches[0].second;
        if (_Pos == _Last || (_Flgs & regex_constants::format_first_only)) {
            break;
        }

        if (_Matches[0].first == _Matches[0].second) {
            _Not_null = regex_constants::_Match_not_null;
        } else { 
            _Not_null = regex_constants::match_flag_type{};
            _Flags |= regex_constants::match_prev_avail;
        }
    }
    return _Flgs & regex_constants::format_no_copy ? _Result : _Copy_unchecked(_Pos, _Last, _Result);
}

template <class _OutIt, class _BidIt, class _RxTraits, class _Elem, class _Traits, class _Alloc>
_OutIt regex_replace(_OutIt _Result, _BidIt _First, _BidIt _Last, const basic_regex<_Elem, _RxTraits>& _Re,
    const basic_string<_Elem, _Traits, _Alloc>& _Fmt,
    regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
    
    _Adl_verify_range(_First, _Last);
    _Seek_wrapped(_Result, _Regex_replace1(_Get_unwrapped_unverified(_Result), _Get_unwrapped(_First),
                               _Get_unwrapped(_Last), _Re, _Fmt, _Flgs));
    return _Result;
}

template <class _OutIt, class _BidIt, class _RxTraits, class _Elem>
_OutIt regex_replace(_OutIt _Result, _BidIt _First, _BidIt _Last, const basic_regex<_Elem, _RxTraits>& _Re,
    const _Elem* _Ptr, regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
    
    const basic_string<_Elem> _Fmt(_Ptr);
    return ::std:: regex_replace(_Result, _First, _Last, _Re, _Fmt, _Flgs);
}

template <class _RxTraits, class _Elem, class _Traits1, class _Alloc1, class _Traits2, class _Alloc2>
[[nodiscard]] basic_string<_Elem, _Traits1, _Alloc1> regex_replace(const basic_string<_Elem, _Traits1, _Alloc1>& _Str,
    const basic_regex<_Elem, _RxTraits>& _Re, const basic_string<_Elem, _Traits2, _Alloc2>& _Fmt,
    regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
    
    basic_string<_Elem, _Traits1, _Alloc1> _Res;
    ::std:: regex_replace(::std:: back_inserter(_Res), _Str.begin(), _Str.end(), _Re, _Fmt, _Flgs);
    return _Res;
}

template <class _RxTraits, class _Elem, class _Traits1, class _Alloc1>
[[nodiscard]] basic_string<_Elem, _Traits1, _Alloc1> regex_replace(const basic_string<_Elem, _Traits1, _Alloc1>& _Str,
    const basic_regex<_Elem, _RxTraits>& _Re, const _Elem* _Ptr,
    regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
    
    basic_string<_Elem, _Traits1, _Alloc1> _Res;
    const basic_string<_Elem> _Fmt(_Ptr);
    ::std:: regex_replace(::std:: back_inserter(_Res), _Str.begin(), _Str.end(), _Re, _Fmt, _Flgs);
    return _Res;
}

template <class _RxTraits, class _Elem, class _Traits2, class _Alloc2>
[[nodiscard]] basic_string<_Elem> regex_replace(const _Elem* _Pstr, const basic_regex<_Elem, _RxTraits>& _Re,
    const basic_string<_Elem, _Traits2, _Alloc2>& _Fmt,
    regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
    
    basic_string<_Elem> _Res;
    const basic_string<_Elem> _Str(_Pstr);
    ::std:: regex_replace(::std:: back_inserter(_Res), _Str.begin(), _Str.end(), _Re, _Fmt, _Flgs);
    return _Res;
}

template <class _RxTraits, class _Elem>
[[nodiscard]] basic_string<_Elem> regex_replace(const _Elem* _Pstr, const basic_regex<_Elem, _RxTraits>& _Re,
    const _Elem* _Ptr, regex_constants::match_flag_type _Flgs = regex_constants::match_default) {
    
    basic_string<_Elem> _Res;
    const basic_string<_Elem> _Str(_Pstr);
    const basic_string<_Elem> _Fmt(_Ptr);
    ::std:: regex_replace(::std:: back_inserter(_Res), _Str.begin(), _Str.end(), _Re, _Fmt, _Flgs);
    return _Res;
}

template <class _BidIt, class _Elem = _Iter_value_t<_BidIt>, class _RxTraits = regex_traits<_Elem>>
class regex_iterator : public _Iterator_base {
public:
    using regex_type        = basic_regex<_Elem, _RxTraits>;
    using value_type        = match_results<_BidIt>;
    using difference_type   = ptrdiff_t;
    using pointer           = const value_type*;
    using reference         = const value_type&;
    using iterator_category = forward_iterator_tag;

    regex_iterator() : _MyRe(nullptr) {} 

    regex_iterator(_BidIt _First, _BidIt _Last, const regex_type& _Re,
        regex_constants::match_flag_type _Fl = regex_constants::match_default)
        : _Begin(_First), _End(_Last), _MyRe(::std:: addressof(_Re)), _Flags(_Fl) {
        _Adl_verify_range(_Begin, _End);
        if (!_Regex_search2(_Begin, _End, ::std:: addressof(_MyVal), *_MyRe, _Flags, _Begin)) {
            _MyRe = nullptr;
        } else {
            this->_Adopt(_MyRe);
        }
    }

    regex_iterator(
        _BidIt, _BidIt, const regex_type&&, regex_constants::match_flag_type = regex_constants::match_default) = delete;

    [[nodiscard]] bool operator==(const regex_iterator& _Right) const {
        if (_MyRe != _Right._MyRe) {
            return false;
        } else if (!_MyRe) {
            return true;
        }

        return _Begin == _Right._Begin && _End == _Right._End && _Flags == _Right._Flags
            && _MyVal._At(0) == _Right._MyVal._At(0);
    }


#line 2433 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"

    [[nodiscard]] const value_type& operator*() const {


#line 2438 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"

        return _MyVal;
    }

    [[nodiscard]] const value_type* operator->() const {


#line 2446 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"

        return ::std:: addressof(_MyVal);
    }

    regex_iterator& operator++() {


#line 2454 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"

        _BidIt _Start = _MyVal._At(0).second;


#line 2460 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"

        bool _Skip_empty_match = false;
        if (_MyVal._At(0).first == _MyVal._At(0).second) { 
            if (_Start == _End) { 
                _MyRe = nullptr;


#line 2469 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"

                return *this;
            }

            
            if (_Regex_search2(_Start, _End, ::std:: addressof(_MyVal), *_MyRe,
                    _Flags | regex_constants::match_not_null | regex_constants::match_continuous, _Begin)) {
                return *this;
            }

            _Skip_empty_match = true;
        }
        _Flags = _Flags | regex_constants::match_prev_avail;

        auto _Tmp_flags = _Flags;
        if (_Skip_empty_match) {
            _Tmp_flags |= regex_constants::_Skip_zero_length;
        }

        
        if (!_Regex_search2(_Start, _End, ::std:: addressof(_MyVal), *_MyRe, _Tmp_flags, _Begin)) {
            
            _MyRe = nullptr;
        }

        return *this;
    }

    regex_iterator operator++(int) {
        regex_iterator _Tmp = *this;
        ++*this;
        return _Tmp;
    }

    bool _Atend() const { 
        return !_MyRe;
    }

private:
    _BidIt _Begin; 
    _BidIt _End; 
    const regex_type* _MyRe; 
    regex_constants::match_flag_type _Flags;
    match_results<_BidIt> _MyVal; 
};

using cregex_iterator  = regex_iterator<const char*>;
using wcregex_iterator = regex_iterator<const wchar_t*>;
using sregex_iterator  = regex_iterator<string::const_iterator>;
using wsregex_iterator = regex_iterator<wstring::const_iterator>;

template <class _BidIt, class _Elem = _Iter_value_t<_BidIt>, class _RxTraits = regex_traits<_Elem>>
class regex_token_iterator {
public:
    using _Position         = regex_iterator<_BidIt, _Elem, _RxTraits>;
    using regex_type        = basic_regex<_Elem, _RxTraits>;
    using value_type        = sub_match<_BidIt>;
    using difference_type   = ptrdiff_t;
    using pointer           = const value_type*;
    using reference         = const value_type&;
    using iterator_category = forward_iterator_tag;

    regex_token_iterator() : _Res(nullptr) {} 

    regex_token_iterator(_BidIt _First, _BidIt _Last, const regex_type& _Re, int _Sub = 0,
        regex_constants::match_flag_type _Fl = regex_constants::match_default)
        : _Pos(_First, _Last, _Re, _Fl), _Cur(0), _Subs(&_Sub, &_Sub + 1) {
        _Init(_First, _Last);
    }

    regex_token_iterator(_BidIt _First, _BidIt _Last, const regex_type& _Re, const vector<int>& _Subx,
        regex_constants::match_flag_type _Fl = regex_constants::match_default)
        : _Pos(_First, _Last, _Re, _Fl), _Cur(0), _Subs(_Subx.begin(), _Subx.end()) {
        if (_Subs.empty()) {
            _Res = nullptr; 
        } else {
            _Init(_First, _Last);
        }
    }

    template <size_t _Nx>
    regex_token_iterator(_BidIt _First, _BidIt _Last, const regex_type& _Re, const int (&_Subx)[_Nx],
        regex_constants::match_flag_type _Fl = regex_constants::match_default)
        : _Pos(_First, _Last, _Re, _Fl), _Cur(0), _Subs(_Subx, _Subx + _Nx) {
        _Init(_First, _Last);
    }

    regex_token_iterator(_BidIt _First, _BidIt _Last, const regex_type& _Re, initializer_list<int> _Ilist,
        regex_constants::match_flag_type _Fl = regex_constants::match_default)
        : _Pos(_First, _Last, _Re, _Fl), _Cur(0), _Subs(_Ilist.begin(), _Ilist.end()) {
        _Init(_First, _Last);
    }

    regex_token_iterator(_BidIt, _BidIt, const regex_type&&, int = 0,
        regex_constants::match_flag_type = regex_constants::match_default) = delete;

    regex_token_iterator(_BidIt, _BidIt, const regex_type&&, const vector<int>&,
        regex_constants::match_flag_type = regex_constants::match_default) = delete;

    template <size_t _Nx>
    regex_token_iterator(_BidIt, _BidIt, const regex_type&&, const int (&)[_Nx],
        regex_constants::match_flag_type = regex_constants::match_default) = delete;

    regex_token_iterator(_BidIt, _BidIt, const regex_type&&, initializer_list<int>,
        regex_constants::match_flag_type = regex_constants::match_default) = delete;

    regex_token_iterator(const regex_token_iterator& _Right)
        : _Pos(_Right._Pos), _Suffix(_Right._Suffix), _Cur(_Right._Cur), _Subs(_Right._Subs) {
        
        if (!_Right._Res) {
            _Res = nullptr;
        } else if (_Right._Res == ::std:: addressof(_Right._Suffix)) {
            _Res = ::std:: addressof(_Suffix);
        } else {
            _Res = _Current();
        }
    }

    regex_token_iterator& operator=(const regex_token_iterator& _Right) {
        if (this != ::std:: addressof(_Right)) { 
            _Pos    = _Right._Pos;
            _Cur    = _Right._Cur;
            _Suffix = _Right._Suffix;
            _Subs   = _Right._Subs;
            if (!_Right._Res) {
                _Res = nullptr;
            } else if (_Right._Res == ::std:: addressof(_Right._Suffix)) {
                _Res = ::std:: addressof(_Suffix);
            } else {
                _Res = _Current();
            }
        }
        return *this;
    }

    [[nodiscard]] bool operator==(const regex_token_iterator& _Right) const {
        if (!_Res || !_Right._Res) {
            return _Res == _Right._Res;
        }

        return *_Res == *_Right._Res && _Pos == _Right._Pos && _Subs == _Right._Subs;
    }


#line 2617 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"

    [[nodiscard]] const value_type& operator*() const {


#line 2622 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"

        ;
        return *_Res;
    }

    [[nodiscard]] const value_type* operator->() const {


#line 2631 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"

        return _Res;
    }

    regex_token_iterator& operator++() {


#line 2639 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"

        if (_Res == ::std:: addressof(_Suffix)) {
            _Res = nullptr;
        } else if (++_Cur < _Subs.size()) {
            _Res = _Current();
        } else { 
            _Cur = 0;
            _Position _Prev(_Pos);
            ++_Pos;
            if (!_Pos._Atend()) {
                _Res = _Current();
            } else if (_Has_suffix() && _Prev->suffix().length() != 0) { 
                _Suffix.matched = true;
                _Suffix.first   = _Prev->suffix().first;
                _Suffix.second  = _Prev->suffix().second;
                _Res            = ::std:: addressof(_Suffix);
            } else {
                _Res = nullptr;
            }
        }

        return *this;
    }

    regex_token_iterator operator++(int) {
        regex_token_iterator _Tmp = *this;
        ++*this;
        return _Tmp;
    }

private:
    _Position _Pos;
    const value_type* _Res;
    value_type _Suffix;
    size_t _Cur;
    vector<int> _Subs;

    bool _Has_suffix() const { 
        return ::std:: find(_Subs.begin(), _Subs.end(), -1) != _Subs.end();
    }

    void _Init(_BidIt _First, _BidIt _Last) { 
        _Adl_verify_range(_First, _Last);
        if (!_Pos._Atend()) {
            _Res = _Current();
        } else if (_Has_suffix()) { 
            _Suffix.matched = true;
            _Suffix.first   = _First;
            _Suffix.second  = _Last;
            _Res            = ::std:: addressof(_Suffix);
        } else {
            _Res = nullptr;
        }
    }

    const value_type* _Current() const {
        return &(_Subs[_Cur] == -1 ? _Pos->prefix() : (*_Pos)[static_cast<size_t>(_Subs[_Cur])]);
    }
};

using cregex_token_iterator  = regex_token_iterator<const char*>;
using wcregex_token_iterator = regex_token_iterator<const wchar_t*>;
using sregex_token_iterator  = regex_token_iterator<string::const_iterator>;
using wsregex_token_iterator = regex_token_iterator<wstring::const_iterator>;

template <class _FwdIt, class _Elem, class _RxTraits>
_Builder<_FwdIt, _Elem, _RxTraits>::_Builder(const _RxTraits& _Tr, regex_constants::syntax_option_type _Fx)
    : _Root(new _Root_node), _Current(_Root), _Flags(_Fx), _Traits(_Tr),
      _Bmax(static_cast<int>(_Fx & regex_constants::collate ? 0U : _Bmp_max)),
      _Tmax(static_cast<int>(_Fx & regex_constants::collate ? 0U : _ARRAY_THRESHOLD)) {}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Builder<_FwdIt, _Elem, _RxTraits>::_Setlong() { 
    _Root->_Flags |= _Fl_longest;
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Builder<_FwdIt, _Elem, _RxTraits>::_Negate() { 
    _Current->_Flags ^= _Fl_negate;
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Builder<_FwdIt, _Elem, _RxTraits>::_Mark_final() { 
    _Current->_Flags |= _Fl_final;
}

template <class _FwdIt, class _Elem, class _RxTraits>
_Node_base* _Builder<_FwdIt, _Elem, _RxTraits>::_Getmark() const {
    return _Current;
}

template <class _FwdIt, class _Elem, class _RxTraits>
bool _Builder<_FwdIt, _Elem, _RxTraits>::_Beg_expr(_Node_base* _Nx) const {
    
    return _Nx->_Kind == _N_begin || _Nx->_Kind == _N_group || _Nx->_Kind == _N_capture;
}

template <class _FwdIt, class _Elem, class _RxTraits>
bool _Builder<_FwdIt, _Elem, _RxTraits>::_Beg_expr() const { 
    return _Beg_expr(_Current) || (_Current->_Kind == _N_bol && _Beg_expr(_Current->_Prev));
}

template <class _FwdIt, class _Elem, class _RxTraits>
_Node_base* _Builder<_FwdIt, _Elem, _RxTraits>::_Link_node(_Node_base* _Nx) { 
    _Nx->_Prev = _Current;
    if (_Current->_Next) { 
        _Nx->_Next             = _Current->_Next;
        _Current->_Next->_Prev = _Nx;
    }
    _Current->_Next = _Nx;
    _Current        = _Nx;
    return _Nx;
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Builder<_FwdIt, _Elem, _RxTraits>::_Insert_node(_Node_base* _Insert_before, _Node_base* _To_insert) {
    
    _Insert_before->_Prev->_Next = _To_insert;
    _To_insert->_Prev            = _Insert_before->_Prev;
    _Insert_before->_Prev        = _To_insert;
    _To_insert->_Next            = _Insert_before;
}

template <class _FwdIt, class _Elem, class _RxTraits>
_Node_base* _Builder<_FwdIt, _Elem, _RxTraits>::_New_node(_Node_type _Kind) { 
    return _Link_node(new _Node_base(_Kind));
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Builder<_FwdIt, _Elem, _RxTraits>::_Add_nop() { 
    _New_node(_N_nop);
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Builder<_FwdIt, _Elem, _RxTraits>::_Add_bol() { 
    _New_node(_N_bol);
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Builder<_FwdIt, _Elem, _RxTraits>::_Add_eol() { 
    _New_node(_N_eol);
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Builder<_FwdIt, _Elem, _RxTraits>::_Add_wbound() { 
    _New_node(_N_wbound);
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Builder<_FwdIt, _Elem, _RxTraits>::_Add_dot() { 
    _New_node(_N_dot);
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Builder<_FwdIt, _Elem, _RxTraits>::_Add_str_node() { 
    _Link_node(new _Node_str<_Elem>);
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Builder<_FwdIt, _Elem, _RxTraits>::_Add_char(_Elem _Ch) { 
    if (_Current->_Kind != _N_str || (_Current->_Flags & _Fl_final)) {
        _Add_str_node();
    }

    if (_Flags & regex_constants::icase) {
        _Ch = _Traits.translate_nocase(_Ch);
    } else if (_Flags & regex_constants::collate) {
        _Ch = _Traits.translate(_Ch);
    }

    _Node_str<_Elem>* _Node = static_cast<_Node_str<_Elem>*>(_Current);
    _Node->_Data._Insert(_Ch);
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Builder<_FwdIt, _Elem, _RxTraits>::_Add_class() { 
    _Link_node(new _Node_class<_Elem, _RxTraits>);
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Builder<_FwdIt, _Elem, _RxTraits>::_Add_char_to_bitmap(_Elem _Ch) { 
    if (_Flags & regex_constants::icase) {
        _Ch = _Traits.translate_nocase(_Ch);
    }

    _Node_class<_Elem, _RxTraits>* _Node = static_cast<_Node_class<_Elem, _RxTraits>*>(_Current);

    if (!_Node->_Small) {
        _Node->_Small = new _Bitmap;
    }

    _Node->_Small->_Mark(static_cast<typename _RxTraits::_Uelem>(_Ch));
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Builder<_FwdIt, _Elem, _RxTraits>::_Add_char_to_array(_Elem _Ch) { 
    if (_Flags & regex_constants::icase) {
        _Ch = _Traits.translate_nocase(_Ch);
    }

    _Node_class<_Elem, _RxTraits>* _Node = static_cast<_Node_class<_Elem, _RxTraits>*>(_Current);
    if (!_Node->_Large) {
        _Node->_Large = new _Buf<_Elem>;
    }

    _Node->_Large->_Insert(_Ch);
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Builder<_FwdIt, _Elem, _RxTraits>::_Add_char_to_class(_Elem _Ch) { 
    if (static_cast<typename _RxTraits::_Uelem>(_Ch) < _Bmp_max) {
        _Add_char_to_bitmap(_Ch);
    } else {
        _Add_char_to_array(_Ch);
    }
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Builder<_FwdIt, _Elem, _RxTraits>::_Add_range(_Elem _Arg0, _Elem _Arg1) {
    
    unsigned int _Ex0;
    unsigned int _Ex1;
    if (_Flags & regex_constants::icase) { 
        _Ex0 = static_cast<unsigned int>(_Traits.translate_nocase(_Arg0));
        _Ex1 = static_cast<unsigned int>(_Traits.translate_nocase(_Arg1));
    } else {
        _Ex0 = static_cast<typename _RxTraits::_Uelem>(_Arg0);
        _Ex1 = static_cast<typename _RxTraits::_Uelem>(_Arg1);
    }

    _Node_class<_Elem, _RxTraits>* _Node = static_cast<_Node_class<_Elem, _RxTraits>*>(_Current);
    for (; _Ex0 <= _Ex1 && _Ex1 < _Get_bmax(); ++_Ex0) { 
        if (!_Node->_Small) {
            _Node->_Small = new _Bitmap;
        }

        _Node->_Small->_Mark(_Ex0);
    }
    if (_Ex1 >= _Ex0) {
        if (_Ex1 - _Ex0 < _Get_tmax()) {
            for (; _Ex0 <= _Ex1; ++_Ex0) {
                _Add_char_to_array(static_cast<_Elem>(_Ex0));
            }
        } else { 
            if (!_Node->_Ranges) {
                _Node->_Ranges = new _Buf<_Elem>;
            }

            _Node->_Ranges->_Insert(static_cast<_Elem>(_Ex0));
            _Node->_Ranges->_Insert(static_cast<_Elem>(_Ex1));
        }
    }
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Builder<_FwdIt, _Elem, _RxTraits>::_Add_elts(
    _Node_class<_Elem, _RxTraits>* _Node, _Regex_traits_base::char_class_type _Cl, bool _Negate) {
    
    for (unsigned int _Ch = 0; _Ch < _Bmp_max; ++_Ch) { 
        bool _Matches = _Traits.isctype(static_cast<_Elem>(_Ch), _Cl);
        if (_Matches != _Negate) { 
            if (!_Node->_Small) {
                _Node->_Small = new _Bitmap;
            }

            _Node->_Small->_Mark(_Ch);
        }
    }
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Builder<_FwdIt, _Elem, _RxTraits>::_Add_named_class(typename _Regex_traits_base::char_class_type _Cl,
    bool _Negate) { 
    _Node_class<_Elem, _RxTraits>* _Node = static_cast<_Node_class<_Elem, _RxTraits>*>(_Current);
    _Add_elts(_Node, _Cl, _Negate);
    if (_Bmp_max < static_cast<unsigned int>((numeric_limits<_Elem>::max)())) {
        _Node->_Classes = static_cast<_Regex_traits_base::char_class_type>(_Node->_Classes | _Cl);
    }
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Builder<_FwdIt, _Elem, _RxTraits>::_Char_to_elts(_FwdIt _First, _FwdIt _Last, _Difft _Diff,
    _Sequence<_Elem>** _Cur) { 
    while (*_Cur && static_cast<unsigned int>(_Diff) < (*_Cur)->_Sz) {
        _Cur = &(*_Cur)->_Next;
    }

    if (!(*_Cur) || static_cast<unsigned int>(_Diff) != (*_Cur)->_Sz) {
        
        _Sequence<_Elem>* _Node = *_Cur;
        *_Cur                   = new _Sequence<_Elem>(static_cast<unsigned int>(_Diff));
        (*_Cur)->_Next          = _Node;
    }
    (*_Cur)->_Data._Insert(_First, _Last);
}

template <class _FwdIt, class _Elem, class _RxTraits>
unsigned int _Builder<_FwdIt, _Elem, _RxTraits>::_Get_bmax() const {
    return static_cast<unsigned int>(_Bmax);
}

template <class _FwdIt, class _Elem, class _RxTraits>
unsigned int _Builder<_FwdIt, _Elem, _RxTraits>::_Get_tmax() const {
    return static_cast<unsigned int>(_Tmax);
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Builder<_FwdIt, _Elem, _RxTraits>::_Add_equiv(_FwdIt _First, _FwdIt _Last, _Difft _Diff) {
    
    _Node_class<_Elem, _RxTraits>* _Node = static_cast<_Node_class<_Elem, _RxTraits>*>(_Current);
    typename _RxTraits::string_type _Str = _Traits.transform_primary(_First, _Last);
    for (unsigned int _Ch = 0; _Ch < _Bmp_max; ++_Ch) { 
        _Elem _Ex = static_cast<_Elem>(_Ch);
        if (_Traits.transform_primary(::std:: addressof(_Ex), ::std:: addressof(_Ex) + 1)
            == _Str) { 
            if (!_Node->_Small) {
                _Node->_Small = new _Bitmap;
            }

            _Node->_Small->_Mark(_Ch);
        }
    }
    if (_Bmp_max < static_cast<unsigned int>((numeric_limits<_Elem>::max)())) { 
        _Sequence<_Elem>** _Cur = ::std:: addressof(_Node->_Equiv);
        _Char_to_elts(_First, _Last, _Diff, _Cur);
    }
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Builder<_FwdIt, _Elem, _RxTraits>::_Add_coll(_FwdIt _First, _FwdIt _Last, _Difft _Diff) {
    
    _Node_class<_Elem, _RxTraits>* _Node = static_cast<_Node_class<_Elem, _RxTraits>*>(_Current);
    _Sequence<_Elem>** _Cur              = ::std:: addressof(_Node->_Coll);
    _Char_to_elts(_First, _Last, _Diff, _Cur);
}

template <class _FwdIt, class _Elem, class _RxTraits>
_Node_base* _Builder<_FwdIt, _Elem, _RxTraits>::_Begin_group() { 
    return _New_node(_N_group);
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Builder<_FwdIt, _Elem, _RxTraits>::_End_group(_Node_base* _Back) { 
    _Node_type _Elt;
    if (_Back->_Kind == _N_group) {
        _Elt = _N_end_group;
    } else if (_Back->_Kind == _N_assert || _Back->_Kind == _N_neg_assert) {
        _Elt = _N_end_assert;
    } else {
        _Elt = _N_end_capture;
    }

    _Link_node(new _Node_end_group(_Elt, _Fl_none, _Back));
}

template <class _FwdIt, class _Elem, class _RxTraits>
_Node_base* _Builder<_FwdIt, _Elem, _RxTraits>::_Begin_assert_group(const bool _Neg) { 
    auto _Node1_unique   = ::std:: make_unique<_Node_assert>(_Neg ? _N_neg_assert : _N_assert);
    _Node_base* _Node2   = new _Node_base(_N_nop);
    _Node_assert* _Node1 = _Node1_unique.release();
    _Link_node(_Node1);
    _Node1->_Child = _Node2;
    _Node2->_Prev  = _Node1;
    _Current       = _Node2;
    return _Node1;
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Builder<_FwdIt, _Elem, _RxTraits>::_End_assert_group(_Node_base* _Nx) { 
    _End_group(_Nx);
    _Current = _Nx;
}

template <class _FwdIt, class _Elem, class _RxTraits>
_Node_base* _Builder<_FwdIt, _Elem, _RxTraits>::_Begin_capture_group(unsigned int _Idx) { 
    return _Link_node(new _Node_capture(_Idx));
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Builder<_FwdIt, _Elem, _RxTraits>::_Add_backreference(unsigned int _Idx) { 
    _Link_node(new _Node_back(_Idx));
}

template <class _FwdIt, class _Elem, class _RxTraits>
_Node_base* _Builder<_FwdIt, _Elem, _RxTraits>::_Begin_if(_Node_base* _Start) { 
    
    _Node_base* _Res = new _Node_endif;
    _Link_node(_Res);

    
    _Node_if* _Node1 = new _Node_if(_Res);
    _Node_base* _Pos = _Start->_Next;
    _Insert_node(_Pos, _Node1);
    return _Res;
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Builder<_FwdIt, _Elem, _RxTraits>::_Else_if(_Node_base* _Start, _Node_base* _End) { 
    _Node_if* _Parent  = static_cast<_Node_if*>(_Start->_Next);
    _Node_base* _First = _End->_Next;
    _End->_Next        = nullptr;
    _Node_base* _Last  = _Current;
    _Current           = _End;
    _End->_Next        = nullptr;
    _Last->_Next       = _End;
    while (_Parent->_Child) {
        _Parent = _Parent->_Child;
    }

    _Parent->_Child        = new _Node_if(_End);
    _Parent->_Child->_Next = _First;
    _First->_Prev          = _Parent->_Child;
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Builder<_FwdIt, _Elem, _RxTraits>::_Add_rep(int _Min, int _Max, bool _Greedy) { 
    if (_Current->_Kind == _N_str
        && static_cast<_Node_str<_Elem>*>(_Current)->_Data._Size() != 1) { 
        _Node_str<_Elem>* _Node = static_cast<_Node_str<_Elem>*>(_Current);
        _Add_char(_Node->_Data._Del());
    }

    _Node_base* _Pos = _Current;
    if (_Pos->_Kind == _N_end_group || _Pos->_Kind == _N_end_capture) {
        _Pos = static_cast<_Node_end_group*>(_Pos)->_Back;
    }

    if (_Min == 0 && _Max == 1) { 
                                  
        _Node_endif* _End       = new _Node_endif;
        _Node_if* _If_expr      = new _Node_if(_End);
        _Node_if* _If_empty_str = new _Node_if(_End);
        _Node_base* _Gbegin     = new _Node_base(_N_group);
        _Node_end_group* _Gend  = new _Node_end_group(_N_end_group, _Fl_none, _Gbegin);

        _If_empty_str->_Next = _Gbegin;
        _Gbegin->_Prev       = _If_empty_str;

        _Gbegin->_Next = _Gend;
        _Gend->_Prev   = _Gbegin;

        _Gend->_Next = _End;

        _If_expr->_Child = _If_empty_str;

        _Link_node(_End);
        _Insert_node(_Pos, _If_expr);

        if (!_Greedy) {
            _Swap_adl(_If_expr->_Next->_Prev, _If_empty_str->_Next->_Prev);
            _Swap_adl(_If_expr->_Next, _If_empty_str->_Next);
        }
    } else {
        _Node_end_rep* _Node0 = new _Node_end_rep();
        _Node_rep* _Nx        = new _Node_rep(_Greedy, _Min, _Max, _Node0, _Root->_Loops++);
        _Node0->_Begin_rep    = _Nx;
        _Link_node(_Node0);
        _Insert_node(_Pos, _Nx);
    }
}

template <class _FwdIt, class _Elem, class _RxTraits>
_Root_node* _Builder<_FwdIt, _Elem, _RxTraits>::_End_pattern() { 
    _New_node(_N_end);
    return _Root;
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Builder<_FwdIt, _Elem, _RxTraits>::_Tidy() noexcept { 
    _Destroy_node(_Root);
    _Root = nullptr;
}

template <class _BidIt, class _Elem, class _RxTraits, class _It>
bool _Matcher<_BidIt, _Elem, _RxTraits, _It>::_Do_if(_Node_if* _Node) { 
    _Tgt_state_t<_It> _St = _Tgt_state;

    
    for (; _Node; _Node = _Node->_Child) { 
        _Tgt_state = _St; 
        if (_Match_pat(_Node->_Next)) { 
            break;
        }
    }

    
    if (!_Node) {
        return false;
    }

    
    if (!_Longest) {
        return true;
    }

    
    _Tgt_state_t<_It> _Final = _Tgt_state;
    auto _Final_len          = ::std:: distance(_St._Cur, _Tgt_state._Cur);
    for (;;) { 
        _Node = _Node->_Child;
        if (!_Node) {
            break;
        }

        _Tgt_state = _St;
        if (_Match_pat(_Node->_Next)) { 
            const auto _Len = ::std:: distance(_St._Cur, _Tgt_state._Cur);
            if (_Final_len < _Len) { 
                _Final     = _Tgt_state;
                _Final_len = _Len;
            }
        }
    }

    
    _Tgt_state = _Final;
    return true;
}

template <class _BidIt, class _Elem, class _RxTraits, class _It>
bool _Matcher<_BidIt, _Elem, _RxTraits, _It>::_Do_rep0(
    _Node_rep* _Node, bool _Greedy) { 
    int _Ix               = 0;
    _Tgt_state_t<_It> _St = _Tgt_state;

    for (; _Ix < _Node->_Min; ++_Ix) { 
        _It _Cur = _Tgt_state._Cur;
        if (!_Match_pat(_Node->_Next)) { 
            _Tgt_state = _St;
            return false;
        } else if (_Cur == _Tgt_state._Cur) {
            _Ix = _Node->_Min - 1; 
        }
    }

    _Tgt_state_t<_It> _Final = _Tgt_state;
    bool _Matched0           = false;
    _It _Saved_pos           = _Tgt_state._Cur;

    if (_Match_pat(_Node->_End_rep->_Next)) {
        if (!_Greedy) {
            return true; 
        }

        
        _Final    = _Tgt_state;
        _Matched0 = true;
    }

    while (_Node->_Max == -1 || _Ix++ < _Node->_Max) { 
        _Tgt_state._Cur       = _Saved_pos;
        _Tgt_state._Grp_valid = _St._Grp_valid;
        if (!_Match_pat(_Node->_Next)) {
            break; 
        }

        _It _Mid = _Tgt_state._Cur;
        if (_Match_pat(_Node->_End_rep->_Next)) {
            if (!_Greedy) {
                return true; 
            }

            
            _Final    = _Tgt_state;
            _Matched0 = true;
        }

        if (_Saved_pos == _Mid) {
            break; 
        }

        _Saved_pos = _Mid;
    }

    _Tgt_state = _Matched0 ? _Final : _St;
    return _Matched0;
}

template <class _BidIt, class _Elem, class _RxTraits, class _It>
bool _Matcher<_BidIt, _Elem, _RxTraits, _It>::_Do_rep(_Node_rep* _Node, bool _Greedy, int _Init_idx) {
    
    if (_Node->_Simple_loop == 1) {
        return _Do_rep0(_Node, _Greedy);
    }

    bool _Matched0        = false;
    _Tgt_state_t<_It> _St = _Tgt_state;
    _Loop_vals_t* _Psav   = &_Loop_vals[_Node->_Loop_number];
    int _Loop_idx_sav     = _Psav->_Loop_idx;
    _It* _Loop_iter_sav   = static_cast<_It*>(_Psav->_Loop_iter);
    _It _Cur_iter         = _Tgt_state._Cur;

    bool _Progress = _Init_idx == 0 || *_Loop_iter_sav != _Cur_iter;

    if (0 <= _Node->_Max && _Node->_Max <= _Init_idx) {
        _Matched0 = _Match_pat(_Node->_End_rep->_Next); 
    } else if (_Init_idx < _Node->_Min) { 
        if (!_Progress) {
            _Matched0 = _Match_pat(_Node->_End_rep->_Next); 
        } else { 
            _Psav->_Loop_idx  = _Init_idx + 1;
            _Psav->_Loop_iter = ::std:: addressof(_Cur_iter);
            _Matched0         = _Match_pat(_Node->_Next);
        }
    } else if (!_Greedy) { 
        _Matched0 = _Match_pat(_Node->_End_rep->_Next);
        if (!_Matched0 && _Progress) { 
            _Tgt_state        = _St;
            _Psav->_Loop_idx  = _Init_idx + 1;
            _Psav->_Loop_iter = ::std:: addressof(_Cur_iter);
            _Matched0         = _Match_pat(_Node->_Next);
        }
    } else { 
        if (_Progress) { 
            _Psav->_Loop_idx  = _Init_idx + 1;
            _Psav->_Loop_iter = ::std:: addressof(_Cur_iter);
            _Matched0         = _Match_pat(_Node->_Next);
        }

        if ((_Progress || 1 >= _Init_idx) && !_Matched0) { 
            _Psav->_Loop_idx  = _Loop_idx_sav;
            _Psav->_Loop_iter = _Loop_iter_sav;
            _Tgt_state        = _St;
            _Matched0         = _Match_pat(_Node->_End_rep->_Next);
        }
    }

    if (!_Matched0) {
        _Tgt_state = _St;
    }

    _Psav->_Loop_idx  = _Loop_idx_sav;
    _Psav->_Loop_iter = _Loop_iter_sav;
    return _Matched0;
}

template <class _BidIt1, class _BidIt2, class _Pr>
_BidIt1 _Cmp_chrange(_BidIt1 _Begin1, _BidIt1 _End1, _BidIt2 _Begin2, _BidIt2 _End2, _Pr _Pred) {
    
    _BidIt1 _Res = _Begin1;
    while (_Begin1 != _End1 && _Begin2 != _End2) {
        if (!_Pred(*_Begin1++, *_Begin2++)) {
            return _Res;
        }
    }

    return _Begin2 == _End2 ? _Begin1 : _Res;
}

template <class _BidIt1, class _BidIt2, class _RxTraits>
_BidIt1 _Compare(_BidIt1 _Begin1, _BidIt1 _End1, _BidIt2 _Begin2, _BidIt2 _End2, const _RxTraits& _Traits,
    regex_constants::syntax_option_type _Sflags) { 
    _BidIt1 _Res = _End1;
    if (_Sflags & regex_constants::icase) {
        _Res = _Cmp_chrange(_Begin1, _End1, _Begin2, _End2, _Cmp_icase<_RxTraits>{_Traits});
    } else if (_Sflags & regex_constants::collate) {
        _Res = _Cmp_chrange(_Begin1, _End1, _Begin2, _End2, _Cmp_collate<_RxTraits>{_Traits});
    } else {
        _Res = _Cmp_chrange(_Begin1, _End1, _Begin2, _End2, _Cmp_cs<_RxTraits>{});
    }

    return _Res;
}

template <class _Elem>
bool _Lookup_range(unsigned int _Ch, const _Buf<_Elem>* _Bufptr) { 
    using _Uelem = make_unsigned_t<_Elem>;
    for (unsigned int _Ix = 0; _Ix < _Bufptr->_Size(); _Ix += 2) { 
        if (static_cast<_Uelem>(_Bufptr->_At(_Ix)) <= _Ch && _Ch <= static_cast<_Uelem>(_Bufptr->_At(_Ix + 1))) {
            return true;
        }
    }

    return false;
}

template <class _Elem, class _RxTraits>
bool _Lookup_equiv(typename _RxTraits::_Uelem _Ch, const _Sequence<_Elem>* _Eq, const _RxTraits& _Traits) {
    
    typename _RxTraits::string_type _Str0;
    typename _RxTraits::string_type _Str1;
    _Str1.push_back(static_cast<_Elem>(_Ch));
    _Str1 = _Traits.transform_primary(_Str1.begin(), _Str1.end());
    while (_Eq) { 
        for (unsigned int _Ix = 0; _Ix < _Eq->_Data._Size(); _Ix += _Eq->_Sz) { 
            _Str0.assign(_Eq->_Data._Str() + _Ix, _Eq->_Sz);
            _Str0 = _Traits.transform_primary(_Str0.begin(), _Str0.end());
            if (_Str0 == _Str1) {
                return true;
            }
        }
        _Eq = _Eq->_Next;
    }
    return false;
}

template <class _BidIt, class _Elem>
_BidIt _Lookup_coll(_BidIt _First, _BidIt _Last, const _Sequence<_Elem>* _Eq) {
    
    while (_Eq) { 
        for (unsigned int _Ix = 0; _Ix < _Eq->_Data._Size(); _Ix += _Eq->_Sz) { 
            _BidIt _Res = _First;
            for (size_t _Jx = 0; _Jx < _Eq->_Sz; ++_Jx) { 
                if (*_Res++ != *(_Eq->_Data._Str() + _Ix + _Jx)) {
                    break;
                }
            }
            if (_Res == _Last) {
                return _Last;
            }
        }
        _Eq = _Eq->_Next;
    }
    return _First;
}

template <class _BidIt, class _Elem, class _RxTraits, class _It>
bool _Matcher<_BidIt, _Elem, _RxTraits, _It>::_Do_class(_Node_base* _Nx) { 
    bool _Found;
    auto _Ch = static_cast<typename _RxTraits::_Uelem>(*_Tgt_state._Cur);
    if (_Sflags & regex_constants::icase) {
        _Ch = static_cast<typename _RxTraits::_Uelem>(_Traits.translate_nocase(static_cast<_Elem>(_Ch)));
    }

    _It _Res0 = _Tgt_state._Cur;
    ++_Res0;
    _It _Resx;
    _Node_class<_Elem, _RxTraits>* _Node = static_cast<_Node_class<_Elem, _RxTraits>*>(_Nx);
    if (_Node->_Coll
        && (_Resx = _Lookup_coll(_Tgt_state._Cur, _End, _Node->_Coll))
               != _Tgt_state._Cur) { 
        _Res0  = _Resx;
        _Found = true;
    } else if (_Node->_Ranges
               && (_Lookup_range(static_cast<typename _RxTraits::_Uelem>(
                                     _Sflags & regex_constants::collate ? _Traits.translate(static_cast<_Elem>(_Ch))
                                                                        : static_cast<_Elem>(_Ch)),
                   _Node->_Ranges))) {
        _Found = true;
    } else if (_Ch < _Bmp_max) {
        _Found = _Node->_Small && _Node->_Small->_Find(_Ch);
    } else if (_Node->_Large
               && ::std:: find(_Node->_Large->_Str(), _Node->_Large->_Str() + _Node->_Large->_Size(), _Ch)
                      != _Node->_Large->_Str() + _Node->_Large->_Size()) {
        _Found = true;
    } else if (_Node->_Classes != 0 && _Traits.isctype(static_cast<_Elem>(_Ch), _Node->_Classes)) {
        _Found = true;
    } else if (_Node->_Equiv && _Lookup_equiv(_Ch, _Node->_Equiv, _Traits)) {
        _Found = true;
    } else {
        _Found = false;
    }

    const bool _Negated = (_Node->_Flags & _Fl_negate) != 0;

    if (_Found == _Negated) {
        return false;
    } else { 
        _Tgt_state._Cur = _Res0;
        return true;
    }
}

template <class _BidIt, class _Elem, class _RxTraits, class _It>
bool _Matcher<_BidIt, _Elem, _RxTraits, _It>::_Better_match() { 
    for (unsigned int _Ix = 0; _Ix < _Get_ncap(); ++_Ix) { 
        if (_Res._Grp_valid[_Ix] && _Tgt_state._Grp_valid[_Ix]) {
            if (_Res._Grps[_Ix]._Begin != _Tgt_state._Grps[_Ix]._Begin) {
                return ::std:: distance(_Begin, _Res._Grps[_Ix]._Begin)
                     < ::std:: distance(_Begin, _Tgt_state._Grps[_Ix]._Begin);
            }

            if (_Res._Grps[_Ix]._End != _Tgt_state._Grps[_Ix]._End) {
                return ::std:: distance(_Begin, _Res._Grps[_Ix]._End) < ::std:: distance(_Begin, _Tgt_state._Grps[_Ix]._End);
            }
        }
    }
    return false;
}

template <class _BidIt, class _Elem, class _RxTraits, class _It>
bool _Matcher<_BidIt, _Elem, _RxTraits, _It>::_Is_wbound() const {
    if ((_Mflags & regex_constants::match_prev_avail)
        || _Tgt_state._Cur != _Begin) { 
        if (_Tgt_state._Cur == _End) {
            return (_Mflags & regex_constants::match_not_eow) == 0 && _Is_word(*_Prev_iter(_Tgt_state._Cur));
        } else {
            return _Is_word(*_Prev_iter(_Tgt_state._Cur)) != _Is_word(*_Tgt_state._Cur);
        }
    } else { 
        if (_Tgt_state._Cur == _End) {
            return (_Mflags & (regex_constants::match_not_bow | regex_constants::match_not_eow)) == 0;
        } else {
            return (_Mflags & regex_constants::match_not_bow) == 0 && _Is_word(*_Tgt_state._Cur);
        }
    }
}

template <class _BidIt, class _Elem, class _RxTraits, class _It>
unsigned int _Matcher<_BidIt, _Elem, _RxTraits, _It>::_Get_ncap() const {
    return static_cast<unsigned int>(_Ncap);
}

template <class _BidIt, class _Elem, class _RxTraits, class _It>
bool _Matcher<_BidIt, _Elem, _RxTraits, _It>::_Match_pat(_Node_base* _Nx) { 
    if (0 < _Max_stack_count && --_Max_stack_count <= 0) {
        _Xregex_error(regex_constants::error_stack);
    }

    if (0 < _Max_complexity_count && --_Max_complexity_count <= 0) {
        _Xregex_error(regex_constants::error_complexity);
    }

    bool _Failed = false;
    while (_Nx) { 
        switch (_Nx->_Kind) { 
        case _N_nop:
            break;

        case _N_bol:
            if ((_Mflags & regex_constants::match_prev_avail)
                || _Tgt_state._Cur != _Begin) { 
                _Failed = *_Prev_iter(_Tgt_state._Cur) != _Meta_nl;
            } else {
                _Failed = (_Mflags & regex_constants::match_not_bol) != 0;
            }

            break;

        case _N_eol:
            if (_Tgt_state._Cur == _End) {
                _Failed = (_Mflags & regex_constants::match_not_eol) != 0;
            } else {
                _Failed = *_Tgt_state._Cur != _Meta_nl;
            }

            break;

        case _N_wbound:
            _Failed = _Is_wbound() == ((_Nx->_Flags & _Fl_negate) != 0);
            break;

        case _N_dot:
            if (_Tgt_state._Cur == _End || *_Tgt_state._Cur == _Meta_nl || *_Tgt_state._Cur == _Meta_cr) {
                _Failed = true;
            } else {
                ++_Tgt_state._Cur;
            }

            break;

        case _N_str:
            { 
                _Node_str<_Elem>* _Node = static_cast<_Node_str<_Elem>*>(_Nx);
                _It _Res0;
                if ((_Res0 = _Compare(_Tgt_state._Cur, _End, _Node->_Data._Str(),
                         _Node->_Data._Str() + _Node->_Data._Size(), _Traits, _Sflags))
                    != _Tgt_state._Cur) {
                    _Tgt_state._Cur = _Res0;
                } else {
                    _Failed = true;
                }

                break;
            }

        case _N_class:
            { 
                _Failed = _Tgt_state._Cur == _End || !_Do_class(_Nx);
                break;
            }

        case _N_group:
            break;

        case _N_end_group:
            break;

        case _N_neg_assert:
        case _N_assert:
            { 
                _It _Ch              = _Tgt_state._Cur;
                bool _Neg            = _Nx->_Kind == _N_neg_assert;
                _Bt_state_t<_It> _St = _Tgt_state;
                if (_Match_pat(static_cast<_Node_assert*>(_Nx)->_Child) == _Neg) {
                    
                    _Tgt_state = _St;
                    _Failed    = true;
                } else {
                    _Tgt_state._Cur = _Ch;
                }

                break;
            }

        case _N_end_assert:
            _Nx = nullptr;
            break;

        case _N_capture:
            { 
                _Node_capture* _Node                 = static_cast<_Node_capture*>(_Nx);
                _Tgt_state._Grps[_Node->_Idx]._Begin = _Tgt_state._Cur;
                for (size_t _Idx = _Tgt_state._Grp_valid.size(); _Node->_Idx < _Idx;) {
                    _Tgt_state._Grp_valid[--_Idx] = false;
                }

                break;
            }

        case _N_end_capture:
            { 
                _Node_end_group* _Node = static_cast<_Node_end_group*>(_Nx);
                _Node_capture* _Node0  = static_cast<_Node_capture*>(_Node->_Back);
                if (_Cap || _Node0->_Idx != 0) { 
                    _Tgt_state._Grp_valid[_Node0->_Idx] = true;
                    _Tgt_state._Grps[_Node0->_Idx]._End = _Tgt_state._Cur;
                }
                break;
            }

        case _N_back:
            { 
                _Node_back* _Node = static_cast<_Node_back*>(_Nx);
                if (_Tgt_state._Grp_valid[_Node->_Idx]) { 
                    _It _Res0 = _Tgt_state._Cur;
                    _It _Bx   = _Tgt_state._Grps[_Node->_Idx]._Begin;
                    _It _Ex   = _Tgt_state._Grps[_Node->_Idx]._End;
                    if (_Bx != _Ex 
                        && (_Res0 = _Compare(_Tgt_state._Cur, _End, _Bx, _Ex, _Traits, _Sflags)) == _Tgt_state._Cur) {
                        _Failed = true;
                    } else {
                        _Tgt_state._Cur = _Res0;
                    }
                }
                break;
            }

        case _N_if:
            if (!_Do_if(static_cast<_Node_if*>(_Nx))) {
                _Failed = true;
            }

            _Nx = nullptr;
            break;

        case _N_endif:
            break;

        case _N_rep:
            if (!_Do_rep(static_cast<_Node_rep*>(_Nx), (_Nx->_Flags & _Fl_greedy) != 0, 0)) {
                _Failed = true;
            }

            _Nx = nullptr;
            break;

        case _N_end_rep:
            {
                _Node_rep* _Nr      = static_cast<_Node_end_rep*>(_Nx)->_Begin_rep;
                _Loop_vals_t* _Psav = &_Loop_vals[_Nr->_Loop_number];

                if (_Nr->_Simple_loop == 0 && !_Do_rep(_Nr, (_Nr->_Flags & _Fl_greedy) != 0, _Psav->_Loop_idx)) {
                    _Failed = true; 
                }

                _Nx = nullptr;
                break;
            }

        case _N_begin:
            break;

        case _N_end:
            if (((_Mflags & (regex_constants::match_not_null | regex_constants::_Match_not_null))
                    && _Begin == _Tgt_state._Cur)
                || (_Full && _Tgt_state._Cur != _End)) {
                _Failed = true;
            } else if (!_Matched || _Better_match()) { 
                _Res     = _Tgt_state;
                _Matched = true;
            }
            _Nx = nullptr;
            break;

        case _N_none:
        default:
            _Xregex_error(regex_constants::error_parse);
        }

        if (_Failed) {
            _Nx = nullptr;
        } else if (_Nx) {
            _Nx = _Nx->_Next;
        }
    }

    if (0 < _Max_stack_count) {
        ++_Max_stack_count;
    }

    return !_Failed;
}

template <class _BidIt, class _Elem, class _RxTraits, class _It>
_BidIt _Matcher<_BidIt, _Elem, _RxTraits, _It>::_Skip(_BidIt _First_arg, _BidIt _Last, _Node_base* _Node_arg) {
    
    
    _Node_base* _Nx = _Node_arg ? _Node_arg : _Rep;

    while (_First_arg != _Last && _Nx) { 
        switch (_Nx->_Kind) { 
        case _N_nop:
            break;

        case _N_bol:
            { 
              
              
                if (*_Prev_iter(_First_arg) != _Meta_nl) {
                    _First_arg = ::std:: find(_First_arg, _Last, _Meta_nl);
                    if (_First_arg != _Last) {
                        ++_First_arg;
                    }
                }

                return _First_arg;
            }

        case _N_eol:
            return ::std:: find(_First_arg, _Last, _Meta_nl);

        case _N_str:
            { 
                _Node_str<_Elem>* _Node = static_cast<_Node_str<_Elem>*>(_Nx);
                for (; _First_arg != _Last; ++_First_arg) { 
                    _BidIt _Next = _First_arg;
                    if (_Compare(_First_arg, ++_Next, _Node->_Data._Str(), _Node->_Data._Str() + 1, _Traits, _Sflags)
                        != _First_arg) {
                        break;
                    }
                }
                return _First_arg;
            }

        case _N_class:
            { 
                for (; _First_arg != _Last; ++_First_arg) { 
                    using _Uelem = typename _RxTraits::_Uelem;
                    bool _Found;
                    auto _Ch                             = static_cast<_Uelem>(*_First_arg);
                    _Node_class<_Elem, _RxTraits>* _Node = static_cast<_Node_class<_Elem, _RxTraits>*>(_Nx);
                    _It _Next                            = _First_arg;
                    ++_Next;

                    if (_Sflags & regex_constants::icase) {
                        _Ch = static_cast<_Uelem>(_Traits.translate_nocase(static_cast<_Elem>(_Ch)));
                    }

                    if (_Node->_Coll && _Lookup_coll(_First_arg, _Next, _Node->_Coll) != _First_arg) {
                        _Found = true;
                    } else if (_Node->_Ranges
                               && (_Lookup_range(static_cast<_Uelem>(_Sflags & regex_constants::collate
                                                                         ? _Traits.translate(static_cast<_Elem>(_Ch))
                                                                         : static_cast<_Elem>(_Ch)),
                                   _Node->_Ranges))) {
                        _Found = true;
                    } else if (_Ch < _Bmp_max) {
                        _Found = _Node->_Small && _Node->_Small->_Find(_Ch);
                    } else if (_Node->_Large
                               && ::std:: find(_Node->_Large->_Str(), _Node->_Large->_Str() + _Node->_Large->_Size(), _Ch)
                                      != _Node->_Large->_Str() + _Node->_Large->_Size()) {
                        _Found = true;
                    } else if (_Node->_Classes && _Traits.isctype(static_cast<_Elem>(_Ch), _Node->_Classes)) {
                        _Found = true;
                    } else if (_Node->_Equiv && _Lookup_equiv(_Ch, _Node->_Equiv, _Traits)) {
                        _Found = true;
                    } else {
                        _Found = false;
                    }

                    const bool _Negated = (_Node->_Flags & _Fl_negate) != 0;

                    if (_Found != _Negated) {
                        return _First_arg;
                    }
                }
            }
            return _First_arg;

        case _N_group:
            break;

        case _N_end_group:
            break;

        case _N_end_assert:
            _Nx = nullptr;
            break;

        case _N_capture:
            break;

        case _N_end_capture:
            break;

        case _N_if:
            { 
                _Node_if* _Node = static_cast<_Node_if*>(_Nx);

                for (; _First_arg != _Last && _Node; _Node = _Node->_Child) {
                    _Last = _Skip(_First_arg, _Last, _Node->_Next);
                }

                return _Last;
            }

        case _N_begin:
            break;

        case _N_end:
            _Nx = nullptr;
            break;

        case _N_none:
        case _N_wbound:
        case _N_dot:
        case _N_assert:
        case _N_neg_assert:
        case _N_back:
        case _N_endif:
        case _N_rep:
        case _N_end_rep:
        default:
            return _First_arg;
        }
        if (_Nx) {
            _Nx = _Nx->_Next;
        }
    }
    return _First_arg;
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Parser<_FwdIt, _Elem, _RxTraits>::_Error(regex_constants::error_type _Code) { 
    _Xregex_error(_Code);
}

template <class _FwdIt, class _Elem, class _RxTraits>
bool _Parser<_FwdIt, _Elem, _RxTraits>::_Is_esc() const { 
    _FwdIt _Ch0 = _Pat;
    return ++_Ch0 != _End
        && ((!(_L_flags & _L_nex_grp) && (*_Ch0 == _Meta_lpar || *_Ch0 == _Meta_rpar))
            || (!(_L_flags & _L_nex_rep) && (*_Ch0 == _Meta_lbr || *_Ch0 == _Meta_rbr)));
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Parser<_FwdIt, _Elem, _RxTraits>::_Trans() { 
    static constexpr char _Meta_map[] = {_Meta_lpar, _Meta_rpar, _Meta_dlr, _Meta_caret, _Meta_dot, _Meta_star,
        _Meta_plus, _Meta_query, _Meta_lsq, _Meta_rsq, _Meta_bar, _Meta_esc, _Meta_dash, _Meta_lbr, _Meta_rbr,
        _Meta_comma, _Meta_colon, _Meta_equal, _Meta_exc, _Meta_nl, _Meta_cr, _Meta_bsp, 0}; 

    if (_Pat == _End) {
        _Mchar = _Meta_eos;
        _Char  = static_cast<_Elem>(_Meta_eos);
    } else { 
        _Char  = *_Pat;
        _Mchar = :: strchr(_Meta_map, _Char) ? static_cast<_Meta_type>(_Char) : _Meta_chr;
    }
    switch (_Char) { 
    case _Meta_esc:
        if (_Is_esc()) { 
            _FwdIt _Ch0 = _Pat;
            _Mchar      = static_cast<_Meta_type>(_Char = *++_Ch0);
        }
        break;

    case _Meta_nl:
        if ((_L_flags & _L_alt_nl) && _Disj_count == 0) {
            _Mchar = _Meta_bar;
        }

        break;

    case _Meta_lpar:
    case _Meta_rpar:
        if (!(_L_flags & _L_nex_grp)) {
            _Mchar = _Meta_chr;
        }

        break;

    case _Meta_lbr:
    case _Meta_rbr:
        if (!(_L_flags & _L_nex_rep)) {
            _Mchar = _Meta_chr;
        }

        break;

    case _Meta_star:
        if ((_L_flags & _L_star_beg) && _Nfa._Beg_expr()) {
            _Mchar = _Meta_chr;
        }

        break;

    case _Meta_caret:
        if ((_L_flags & _L_anch_rstr) && !_Nfa._Beg_expr()) {
            _Mchar = _Meta_chr;
        }

        break;

    case _Meta_dlr:
        { 
            _FwdIt _Ch0 = _Pat;
            if ((_L_flags & _L_anch_rstr) && ++_Ch0 != _End && *_Ch0 != _Meta_nl) {
                _Mchar = _Meta_chr;
            }

            break;
        }

    case _Meta_plus:
    case _Meta_query:
        if (!(_L_flags & _L_ext_rep)) {
            _Mchar = _Meta_chr;
        }

        break;

    case _Meta_bar:
        if (!(_L_flags & _L_alt_pipe)) {
            _Mchar = _Meta_chr;
        }

        break;
    }
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Parser<_FwdIt, _Elem, _RxTraits>::_Next() { 
    if (_Pat != _End) { 
        if (*_Pat == _Meta_esc && _Is_esc()) {
            ++_Pat;
        }

        ++_Pat;
    }
    _Trans();
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Parser<_FwdIt, _Elem, _RxTraits>::_Expect(_Meta_type _St, regex_constants::error_type _Code) {
    
    if (_Mchar != _St) {
        _Error(_Code);
    }

    _Next();
}

template <class _FwdIt, class _Elem, class _RxTraits>
int _Parser<_FwdIt, _Elem, _RxTraits>::_Do_digits(int _Base, int _Count) { 
    int _Chv;
    _Val = 0;
    while (_Count != 0 && (_Chv = _Traits.value(_Char, _Base)) != -1) { 
        --_Count;
        _Val *= _Base;
        _Val += _Chv;
        _Next();
    }
    return _Count;
}

template <class _FwdIt, class _Elem, class _RxTraits>
bool _Parser<_FwdIt, _Elem, _RxTraits>::_DecimalDigits() { 
    return _Do_digits(10, 2147483647) != 2147483647;
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Parser<_FwdIt, _Elem, _RxTraits>::_HexDigits(int _Count) { 
    if (_Do_digits(16, _Count) != 0) {
        _Error(regex_constants::error_escape);
    }
}

template <class _FwdIt, class _Elem, class _RxTraits>
bool _Parser<_FwdIt, _Elem, _RxTraits>::_OctalDigits() { 
    return _Do_digits(8, 3) != 3;
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Parser<_FwdIt, _Elem, _RxTraits>::_Do_ex_class(
    _Meta_type _End_arg) { 
    regex_constants::error_type _Errtype = (_End_arg == _Meta_colon   ? regex_constants::error_ctype
                                            : _End_arg == _Meta_equal ? regex_constants::error_collate
                                            : _End_arg == _Meta_dot   ? regex_constants::error_collate
                                                                      : regex_constants::error_syntax);
    _FwdIt _Beg                          = _Pat;
    _Iter_diff_t<_FwdIt> _Diff           = 0;

    while (_Mchar != _Meta_colon && _Mchar != _Meta_equal && _Mchar != _Meta_dot && _Mchar != _Meta_eos) {
        
        _Next();
        ++_Diff;
    }
    if (_Mchar != _End_arg) {
        _Error(_Errtype);
    } else if (_End_arg == _Meta_colon) { 
        typename _RxTraits::char_class_type _Cls =
            _Traits.lookup_classname(_Beg, _Pat, (_Flags & regex_constants::icase) != 0);
        if (!_Cls) {
            _Error(regex_constants::error_ctype);
        }

        _Nfa._Add_named_class(_Cls);
    } else if (_End_arg == _Meta_equal) { 
        if (_Beg == _Pat) {
            _Error(regex_constants::error_collate);
        } else {
            _Nfa._Add_equiv(_Beg, _Pat, _Diff);
        }
    } else if (_End_arg == _Meta_dot) { 
        if (_Beg == _Pat) {
            _Error(regex_constants::error_collate);
        } else {
            _Nfa._Add_coll(_Beg, _Pat, _Diff);
        }
    }
    _Next();
    _Expect(_Meta_rsq, _Errtype);
}

template <class _FwdIt, class _Elem, class _RxTraits>
bool _Parser<_FwdIt, _Elem, _RxTraits>::_CharacterClassEscape(bool _Addit) { 
    typename _RxTraits::char_class_type _Cls;
    _FwdIt _Ch0 = _Pat;
    if (_Ch0 == _End || (_Cls = _Traits.lookup_classname(_Pat, ++_Ch0, (_Flags & regex_constants::icase) != 0)) == 0) {
        return false;
    }

    if (_Addit) {
        _Nfa._Add_class();
    }

    _Nfa._Add_named_class(_Cls, _Traits.isctype(_Char, _RxTraits::_Ch_upper));
    _Next();
    return true;
}

template <class _FwdIt, class _Elem, class _RxTraits>
_Prs_ret _Parser<_FwdIt, _Elem, _RxTraits>::_ClassEscape(bool _Addit) { 
    if ((_L_flags & _L_esc_bsl) && _Char == _Esc_bsl) { 
        _Val = _Esc_bsl;
        _Next();
        return _Prs_chr;
    } else if ((_L_flags & _L_esc_wsd) && _CharacterClassEscape(_Addit)) {
        return _Prs_set;
    } else if (_DecimalDigits()) { 
        if (_Val != 0) {
            _Error(regex_constants::error_escape);
        }

        return _Prs_chr;
    }
    return _CharacterEscape() ? _Prs_chr : _Prs_none;
}

template <class _FwdIt, class _Elem, class _RxTraits>
_Prs_ret _Parser<_FwdIt, _Elem, _RxTraits>::_ClassAtom() { 
    if (_Mchar == _Meta_esc) { 
        _Next();
        if (_L_flags & _L_grp_esc) {
            return _ClassEscape(false);
        } else if ((_L_flags & _L_esc_ffn && _Do_ffn(_Char))
                   || (_L_flags & _L_esc_ffnx && _Do_ffnx(_Char))) { 
            _Next();
            return _Prs_chr;
        }
        _Val = _Meta_esc;
        return _Prs_chr;
    } else if (_Mchar == _Meta_lsq) { 
        _Next();
        if (_Mchar == _Meta_colon || _Mchar == _Meta_equal || _Mchar == _Meta_dot) { 
            _Meta_type _St = _Mchar;
            _Next();
            _Do_ex_class(_St);
            return _Prs_set;
        } else { 
            _Val = _Meta_lsq;
            return _Prs_chr;
        }
    } else if (_Mchar == _Meta_rsq || _Mchar == _Meta_eos) {
        return _Prs_none;
    } else { 
        _Val = _Char;
        _Next();
        return _Prs_chr;
    }
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Parser<_FwdIt, _Elem, _RxTraits>::_ClassRanges() { 
    _Prs_ret _Ret;

    for (;;) { 
        if ((_Ret = _ClassAtom()) == _Prs_none) {
            return;
        }

        if (_Ret != _Prs_set) {
            if (_Val == 0 && !(_L_flags & _L_bzr_chr)) {
                _Error(regex_constants::error_escape);
            }

            if (_Mchar == _Meta_dash) { 
                _Next();
                _Elem _Chr1 = static_cast<_Elem>(_Val);
                if ((_Ret = _ClassAtom()) == _Prs_none) { 
                    _Nfa._Add_char_to_class(static_cast<_Elem>(_Val));
                    _Nfa._Add_char_to_class(_Meta_dash);
                    return;
                }

                if (_Ret == _Prs_set) {
                    _Error(regex_constants::error_range); 
                }

                if (_Flags & regex_constants::collate) { 
                    _Val  = _Traits.translate(static_cast<_Elem>(_Val));
                    _Chr1 = _Traits.translate(_Chr1);
                }

                if (static_cast<typename _RxTraits::_Uelem>(_Val) < static_cast<typename _RxTraits::_Uelem>(_Chr1)) {
                    _Error(regex_constants::error_range);
                }

                _Nfa._Add_range(_Chr1, static_cast<_Elem>(_Val));
            } else {
                _Nfa._Add_char_to_class(static_cast<_Elem>(_Val));
            }
        }
    }
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Parser<_FwdIt, _Elem, _RxTraits>::_CharacterClass() { 
    _Nfa._Add_class();
    if (_Mchar == _Meta_caret) { 
        _Nfa._Negate();
        _Next();
    }
    if ((_L_flags & _L_brk_rstr) && _Mchar == _Meta_rsq) { 
        _Nfa._Add_char_to_class(_Meta_rsq);
        _Next();
    }
    _ClassRanges();
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Parser<_FwdIt, _Elem, _RxTraits>::_Do_capture_group() { 
    
    
    _Node_base* _Pos1 = _Nfa._Begin_capture_group(++_Grp_idx);
    _Disjunction();
    _Nfa._End_group(_Pos1);
    _Finished_grps.resize(_Grp_idx + 1);
    _Finished_grps[static_cast<_Node_capture*>(_Pos1)->_Idx] = true;
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Parser<_FwdIt, _Elem, _RxTraits>::_Do_noncapture_group() { 
    _Node_base* _Pos1 = _Nfa._Begin_group();
    _Disjunction();
    _Nfa._End_group(_Pos1);
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Parser<_FwdIt, _Elem, _RxTraits>::_Do_assert_group(bool _Neg) { 
    _Node_base* _Pos1 = _Nfa._Begin_assert_group(_Neg);
    _Disjunction();
    _Nfa._End_assert_group(_Pos1);
}

template <class _FwdIt, class _Elem, class _RxTraits>
bool _Parser<_FwdIt, _Elem, _RxTraits>::_Wrapped_disjunction() { 
    ++_Disj_count;
    if (!(_L_flags & _L_empty_grp) && _Mchar == _Meta_rpar) {
        _Error(regex_constants::error_paren);
    } else if ((_L_flags & _L_nc_grp) && _Mchar == _Meta_query) { 
        _Next();
        _Meta_type _Ch = _Mchar;
        _Next();
        if (_Ch == _Meta_colon) {
            _Do_noncapture_group();
        } else if (_Ch == _Meta_exc) { 
            _Do_assert_group(true);
            --_Disj_count;
            return false;
        } else if (_Ch == _Meta_equal) { 
            _Do_assert_group(false);
            --_Disj_count;
            return false;
        } else {
            _Error(regex_constants::error_syntax);
        }
    } else if (_Flags & regex_constants::nosubs) {
        _Do_noncapture_group();
    } else {
        _Do_capture_group();
    }

    --_Disj_count;
    return true;
}

template <class _FwdIt, class _Elem, class _RxTraits>
bool _Parser<_FwdIt, _Elem, _RxTraits>::_IsIdentityEscape() const { 
    if (_L_flags & _L_ident_ECMA) {
        
        switch (_Char) {
        case 'c': 
        case 'd': 
        case 'D':
        case 's': 
        case 'S':
        case 'w': 
        case 'W':
            return false;
        default:
            return true;
        }
    }

    switch (_Char) {
    case _Meta_dot:
    case _Meta_lsq:
    case _Meta_esc:
    case _Meta_star:
    case _Meta_bar:
    case _Meta_caret:
    case _Meta_dlr:
        
        return true;
    case _Meta_lpar:
    case _Meta_rpar:
    case _Meta_plus:
    case _Meta_query:
    case _Meta_lbr:
    case _Meta_rbr:
        
        return (_L_flags & _L_ident_ERE) != 0;
    case '"':
    case '/':
        
        return (_L_flags & _L_ident_awk) != 0;
    default:
        return false;
    }
}

template <class _FwdIt, class _Elem, class _RxTraits>
bool _Parser<_FwdIt, _Elem, _RxTraits>::_IdentityEscape() { 
    if (_IsIdentityEscape()) {
        _Val = _Char;
        _Next();
        return true;
    } else {
        return false;
    }
}

template <class _FwdIt, class _Elem, class _RxTraits>
bool _Parser<_FwdIt, _Elem, _RxTraits>::_Do_ffn(_Elem _Ch) { 
    if (_Ch == _Esc_ctrl_f) {
        _Val = '\f';
    } else if (_Ch == _Esc_ctrl_n) {
        _Val = '\n';
    } else if (_Ch == _Esc_ctrl_r) {
        _Val = '\r';
    } else if (_Ch == _Esc_ctrl_t) {
        _Val = '\t';
    } else if (_Ch == _Esc_ctrl_v) {
        _Val = '\v';
    } else {
        return false;
    }

    return true;
}

template <class _FwdIt, class _Elem, class _RxTraits>
bool _Parser<_FwdIt, _Elem, _RxTraits>::_Do_ffnx(_Elem _Ch) { 
    if (_Ch == _Esc_ctrl_a) {
        _Val = '\a';
    } else if (_Ch == _Esc_ctrl_b) {
        _Val = '\b';
    } else {
        return false;
    }

    return true;
}

template <class _FwdIt, class _Elem, class _RxTraits>
bool _Parser<_FwdIt, _Elem, _RxTraits>::_CharacterEscape() { 
    if (_Mchar == _Meta_eos) {
        _Error(regex_constants::error_escape);
    }

    if ((_L_flags & _L_esc_ffn && _Do_ffn(_Char)) || (_L_flags & _L_esc_ffnx && _Do_ffnx(_Char))) {
        _Next();
    } else if (_Char == _Esc_ctrl && (_L_flags & _L_esc_ctrl)) { 
        _Next();
        if (!_Traits.isctype(_Char, _RxTraits::_Ch_alpha)) {
            _Error(regex_constants::error_escape);
        }

        _Val = static_cast<char>(_Char % 32);
        _Next();
    } else if (_Char == _Esc_hex && (_L_flags & _L_esc_hex)) { 
        _Next();
        _HexDigits(2);
    } else if (_Char == _Esc_uni && (_L_flags & _L_esc_uni)) { 
        _Next();
        _HexDigits(4);
    } else if ((_L_flags & _L_esc_oct) && _OctalDigits()) { 
        if (_Val == 0) {
            _Error(regex_constants::error_escape);
        }
    } else {
        return _IdentityEscape();
    }

    if ((numeric_limits<typename _RxTraits::_Uelem>::max)() < static_cast<unsigned int>(_Val)) {
        _Error(regex_constants::error_escape);
    }

    _Val = static_cast<_Elem>(_Val);
    return true;
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Parser<_FwdIt, _Elem, _RxTraits>::_AtomEscape() { 
    if ((_L_flags & _L_bckr) && _DecimalDigits()) { 
        if (_Val == 0) { 
            if (!(_L_flags & _L_bzr_chr)) {
                _Error(regex_constants::error_escape);
            } else {
                _Nfa._Add_char(static_cast<_Elem>(_Val));
            }
        } else if (((_L_flags & _L_lim_bckr) && _BRE_MAX_GRP < static_cast<size_t>(_Val))
                   || _Grp_idx < static_cast<size_t>(_Val) || _Finished_grps.size() <= static_cast<size_t>(_Val)
                   || !_Finished_grps[static_cast<size_t>(_Val)]) {
            _Error(regex_constants::error_backref);
        } else {
            _Nfa._Add_backreference(static_cast<size_t>(_Val));
        }
    } else if (_CharacterEscape()) {
        _Nfa._Add_char(static_cast<_Elem>(_Val));
    } else if (!(_L_flags & _L_esc_wsd) || !_CharacterClassEscape(true)) {
        _Error(regex_constants::error_escape);
    }
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Parser<_FwdIt, _Elem, _RxTraits>::_Quantifier() { 
    int _Min = 0;
    int _Max = -1;
    if (_Mchar != _Meta_star) {
        if (_Mchar == _Meta_plus) {
            _Min = 1;
        } else if (_Mchar == _Meta_query) {
            _Max = 1;
        } else if (_Mchar == _Meta_lbr) { 
            _Next();
            if (!_DecimalDigits()) {
                _Error(regex_constants::error_badbrace);
            }

            _Min = _Val;
            if (_Mchar != _Meta_comma) {
                _Max = _Min;
            } else { 
                _Next();
                if (_Mchar != _Meta_rbr) {
                    if (!_DecimalDigits()) {
                        _Error(regex_constants::error_badbrace);
                    }

                    _Max = _Val;
                }
            }

            if (_Mchar != _Meta_rbr || (_Max != -1 && _Max < _Min)) {
                _Error(regex_constants::error_badbrace);
            }
        } else {
            return;
        }
    }

    _Nfa._Mark_final();
    _Next();
    const bool _Greedy = !(_L_flags & _L_ngr_rep) || _Mchar != _Meta_query;
    if (!_Greedy) { 
        _Next();
    }

    _Nfa._Add_rep(_Min, _Max, _Greedy);
}

template <class _FwdIt, class _Elem, class _RxTraits>
bool _Parser<_FwdIt, _Elem, _RxTraits>::_Alternative() { 
    bool _Found = false;
    for (;;) { 
        bool _Quant = true;
        if (_Mchar == _Meta_eos || _Mchar == _Meta_bar || (_Mchar == _Meta_rpar && _Disj_count != 0)) {
            return _Found;
        } else if (_Mchar == _Meta_rpar && !(_L_flags & _L_paren_bal)) {
            _Error(regex_constants::error_paren);
        } else if (_Mchar == _Meta_dot) { 
            _Nfa._Add_dot();
            _Next();
        } else if (_Mchar == _Meta_esc) { 
            _Next();
            if ((_L_flags & _L_asrt_wrd) && _Char == _Esc_word) { 
                _Nfa._Add_wbound();
                _Next();
                _Quant = false;
            } else if ((_L_flags & _L_asrt_wrd) && _Char == _Esc_not_word) { 
                _Nfa._Add_wbound();
                _Nfa._Negate();
                _Next();
                _Quant = false;
            } else {
                _AtomEscape();
            }
        } else if (_Mchar == _Meta_lsq) { 
            _Next();
            _CharacterClass();
            _Expect(_Meta_rsq, regex_constants::error_brack);
        } else if (_Mchar == _Meta_lpar) { 
            _Next();
            _Quant = _Wrapped_disjunction();
            _Expect(_Meta_rpar, regex_constants::error_paren);
        } else if (_Mchar == _Meta_caret) { 
            _Nfa._Add_bol();
            _Next();
            _Quant = false;
        } else if (_Mchar == _Meta_dlr) { 
            _Nfa._Add_eol();
            _Next();
            _Quant = false;
        } else if (_Mchar == _Meta_star || _Mchar == _Meta_plus || _Mchar == _Meta_query || _Mchar == _Meta_lbr) {
            _Error(regex_constants::error_badrepeat);
        } else if (_Mchar == _Meta_rbr && !(_L_flags & _L_paren_bal)) {
            _Error(regex_constants::error_brace);
        } else if (_Mchar == _Meta_rsq && !(_L_flags & _L_paren_bal)) {
            _Error(regex_constants::error_brack);
        } else { 
            _Nfa._Add_char(_Char);
            _Next();
        }

        if (_Quant) {
            _Quantifier();
        }

        _Found = true;
    }
}

template <class _FwdIt, class _Elem, class _RxTraits>
void _Parser<_FwdIt, _Elem, _RxTraits>::_Disjunction() { 
    _Node_base* _Pos1 = _Nfa._Getmark();
    if (!_Alternative()) {
        if (_Mchar != _Meta_bar) {
            return; 
        }

        
        _Node_base* _Pos3 = _Nfa._Begin_group();
        _Nfa._End_group(_Pos3);
    }

    _Node_base* _Pos2 = _Nfa._Begin_if(_Pos1);
    while (_Mchar == _Meta_bar) { 
        _Next();
        if (!_Alternative()) { 
            _Node_base* _Pos3 = _Nfa._Begin_group();
            _Nfa._End_group(_Pos3);
        }

        _Nfa._Else_if(_Pos1, _Pos2);
    }
}

inline void _Calculate_loop_simplicity(_Node_base* _Nx, _Node_base* _Ne, _Node_rep* _Outer_rep) {
    
    for (; _Nx != _Ne && _Nx; _Nx = _Nx->_Next) {
        switch (_Nx->_Kind) {
        case _N_if:
            
            if (_Outer_rep) {
                _Outer_rep->_Simple_loop = 0;
            }

            
            for (_Node_if* _Branch = static_cast<_Node_if*>(_Nx)->_Child; _Branch; _Branch = _Branch->_Child) {
                _Calculate_loop_simplicity(_Branch->_Next, _Branch->_Endif, _Outer_rep);
            }

            break;
        case _N_assert:
        case _N_neg_assert:
            
            
            _Calculate_loop_simplicity(static_cast<_Node_assert*>(_Nx)->_Child, nullptr, nullptr);
            break;
        case _N_rep:
            
            if (_Outer_rep) {
                _Outer_rep->_Simple_loop                   = 0;
                static_cast<_Node_rep*>(_Nx)->_Simple_loop = 0;
            } else {
                _Outer_rep = static_cast<_Node_rep*>(_Nx);
            }
            break;
        case _N_end_rep:
            if (_Outer_rep == static_cast<_Node_end_rep*>(_Nx)->_Begin_rep) {
                
#pragma warning(push)
#pragma warning(disable : 6011) 
                if (_Outer_rep->_Simple_loop == -1) {
                    _Outer_rep->_Simple_loop = 1;
                }
#pragma warning(pop)
                _Outer_rep = nullptr;
            }
            break;
        case _N_none:
        case _N_nop:
        case _N_bol:
        case _N_eol:
        case _N_wbound:
        case _N_dot:
        case _N_str:
        case _N_class:
        case _N_group:
        case _N_end_group:
        case _N_end_assert:
        case _N_capture:
        case _N_end_capture:
        case _N_back:
        case _N_endif:
        case _N_begin:
        case _N_end:
        default:
            break;
        }
    }
}

template <class _FwdIt, class _Elem, class _RxTraits>
_Root_node* _Parser<_FwdIt, _Elem, _RxTraits>::_Compile() { 
    _Root_node* _Res = nullptr;
    _Tidy_guard<decltype(_Nfa)> _Guard{::std:: addressof(_Nfa)};
    _Node_base* _Pos1 = _Nfa._Begin_capture_group(0);
    _Disjunction();
    if (_Pat != _End) {
        _Error(regex_constants::error_syntax);
    }

    _Nfa._End_group(_Pos1);
    _Res         = _Nfa._End_pattern();
    _Res->_Fl    = _Flags;
    _Res->_Marks = _Mark_count();
    _Calculate_loop_simplicity(_Res, nullptr, nullptr);
    _Guard._Target = nullptr;
    return _Res;
}

template <class _FwdIt, class _Elem, class _RxTraits>
_Parser<_FwdIt, _Elem, _RxTraits>::_Parser(
    const _RxTraits& _Tr, _FwdIt _Pfirst, _FwdIt _Plast, regex_constants::syntax_option_type _Fx)
    : _Pat(_Pfirst), _Begin(_Pfirst), _End(_Plast), _Grp_idx(0), _Disj_count(0), _Finished_grps(0), _Nfa(_Tr, _Fx),
      _Traits(_Tr), _Flags(_Fx) {

    constexpr unsigned int _ECMA_flags = _L_ext_rep | _L_alt_pipe | _L_nex_grp | _L_nex_rep | _L_nc_grp | _L_asrt_gen
                                       | _L_asrt_wrd | _L_bckr | _L_ngr_rep | _L_esc_uni | _L_esc_hex | _L_esc_bsl
                                       | _L_esc_ffn | _L_esc_wsd | _L_esc_ctrl | _L_bzr_chr | _L_grp_esc | _L_ident_ECMA
                                       | _L_empty_grp;

    constexpr unsigned int _Basic_flags =
        _L_bckr | _L_lim_bckr | _L_anch_rstr | _L_star_beg | _L_empty_grp | _L_brk_rstr | _L_mtch_long;

    constexpr unsigned int _Grep_flags = _Basic_flags | _L_alt_nl | _L_no_nl;

    constexpr unsigned int _Extended_flags =
        _L_ext_rep | _L_alt_pipe | _L_nex_grp | _L_nex_rep | _L_ident_ERE | _L_paren_bal | _L_brk_rstr | _L_mtch_long;

    constexpr unsigned int _Awk_flags = _Extended_flags | _L_esc_oct | _L_esc_ffn | _L_esc_ffnx | _L_ident_awk;

    constexpr unsigned int _Egrep_flags = _Extended_flags | _L_alt_nl | _L_no_nl;

    const regex_constants::syntax_option_type _Masked = _Flags & regex_constants::_Gmask;

    if (_Masked == regex_constants::ECMAScript || _Masked == 0) {
        _L_flags = _ECMA_flags;
    } else if (_Masked == regex_constants::basic) {
        _L_flags = _Basic_flags;
    } else if (_Masked == regex_constants::extended) {
        _L_flags = _Extended_flags;
    } else if (_Masked == regex_constants::awk) {
        _L_flags = _Awk_flags;
    } else if (_Masked == regex_constants::grep) {
        _L_flags = _Grep_flags;
    } else if (_Masked == regex_constants::egrep) {
        _L_flags = _Egrep_flags;
    } else {
        _L_flags = 0;
    }

    if (_L_flags & _L_mtch_long) {
        _Nfa._Setlong();
    }

    _Trans();
}


#line 4609 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"


namespace pmr {
    template <class _BidIt>
    using match_results = ::std:: match_results<_BidIt, polymorphic_allocator<sub_match<_BidIt>>>;

    using cmatch  = match_results<const char*>;
    using wcmatch = match_results<const wchar_t*>;
    using smatch  = match_results<string::const_iterator>;
    using wsmatch = match_results<wstring::const_iterator>;
} 
#line 4621 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"
}


#pragma warning(pop)
#pragma pack(pop)
#line 4627 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"
#line 4628 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\regex"
#line 98 "all-std.cxx"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\barrier"


#pragma once


#line 19 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\barrier"


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {

struct _No_completion_function {
    void operator()() noexcept {}
};

template <class _Completion_function = _No_completion_function>
class barrier;

inline constexpr ptrdiff_t _Barrier_arrival_token_mask = 1;
inline constexpr ptrdiff_t _Barrier_value_mask         = ~_Barrier_arrival_token_mask;
inline constexpr ptrdiff_t _Barrier_value_shift        = 1;
inline constexpr ptrdiff_t _Barrier_invalid_token      = 0;
inline constexpr ptrdiff_t _Barrier_value_step         = 1 << _Barrier_value_shift;
inline constexpr ptrdiff_t _Barrier_max                = (1ULL << (sizeof(ptrdiff_t) * 8 - 2)) - 1;

template <class _Completion_function>
class _Arrival_token {
public:
    _Arrival_token(_Arrival_token&& _Other) noexcept {
        _Value        = _Other._Value;
        _Other._Value = _Barrier_invalid_token;
    }

    _Arrival_token& operator=(_Arrival_token&& _Other) noexcept {
        _Value        = _Other._Value;
        _Other._Value = _Barrier_invalid_token;
        return *this;
    }

private:
    explicit _Arrival_token(ptrdiff_t _Value_) noexcept : _Value(_Value_) {}
    friend barrier<_Completion_function>;

    ptrdiff_t _Value;
};

template <class _Completion_function>
class barrier {
public:
    static_assert(


            is_nothrow_invocable_v<_Completion_function&>,
        "N4861 [thread.barrier.class]/5: is_nothrow_invocable_v<CompletionFunction&> shall be true");

    using arrival_token = _Arrival_token<_Completion_function>;

    constexpr explicit barrier(
        const ptrdiff_t _Expected, _Completion_function _Fn = _Completion_function()) noexcept 
        : _Val(_One_then_variadic_args_t{}, ::std:: move(_Fn), _Expected << _Barrier_value_shift) {
        do { if (_Val._Myval2._Current.load(memory_order_relaxed) >= 0) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 86 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\barrier"
    }

    barrier(const barrier&) = delete;
    barrier& operator=(const barrier&) = delete;

    [[nodiscard]] static constexpr ptrdiff_t(max)() noexcept {
        return _Barrier_max;
    }

    [[nodiscard]] arrival_token arrive(ptrdiff_t _Update = 1) noexcept  {
        
        _Update <<= _Barrier_value_shift;
        do { if (_Update > 0) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
        
        ptrdiff_t _Current = _Val._Myval2._Current.fetch_sub(_Update) - _Update;
        do { if (_Current >= 0) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 103 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\barrier"
        if ((_Current & _Barrier_value_mask) == 0) {
            
            
            _Completion(_Current);
        }
        
        
        return arrival_token{(_Current & _Barrier_arrival_token_mask) | reinterpret_cast<intptr_t>(this)};
    }

    void wait(arrival_token&& _Arrival) const noexcept  {
        do { if ((_Arrival._Value & _Barrier_value_mask) == reinterpret_cast<intptr_t>(this)) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 118 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\barrier"
        const ptrdiff_t _Arrival_value = _Arrival._Value & _Barrier_arrival_token_mask;
        _Arrival._Value                = _Barrier_invalid_token;
        for (;;) {
            
            const ptrdiff_t _Current = _Val._Myval2._Current.load();
            do { if (_Current >= 0) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 125 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\barrier"
            if ((_Current & _Barrier_arrival_token_mask) != _Arrival_value) {
                break;
            }
            _Val._Myval2._Current.wait(_Current, memory_order_relaxed);
        }
    }

    void arrive_and_wait() noexcept  {
        
        ptrdiff_t _Current       = _Val._Myval2._Current.fetch_sub(_Barrier_value_step) - _Barrier_value_step;
        const ptrdiff_t _Arrival = _Current & _Barrier_arrival_token_mask;
        do { if (_Current >= 0) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 138 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\barrier"
        if ((_Current & _Barrier_value_mask) == 0) {
            _Completion(_Current);
            return;
        }

        for (;;) {
            _Val._Myval2._Current.wait(_Current, memory_order_relaxed);
            
            _Current = _Val._Myval2._Current.load();
            do { if (_Current >= 0) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 149 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\barrier"
            if ((_Current & _Barrier_arrival_token_mask) != _Arrival) {
                break;
            }
        }
    }

    void arrive_and_drop() noexcept  {
        const ptrdiff_t _Rem_count =
            _Val._Myval2._Total.fetch_sub(_Barrier_value_step, memory_order_relaxed) - _Barrier_value_step;
        do { if (_Rem_count >= 0) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 161 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\barrier"
        (void) arrive(1);
    }

private:
    void _Completion(const ptrdiff_t _Current) noexcept {
        const ptrdiff_t _Rem_count = _Val._Myval2._Total.load(memory_order_relaxed);
        do { if (_Rem_count >= 0) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 170 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\barrier"
        _Val._Get_first()();
        const ptrdiff_t _New_phase_count = _Rem_count | ((_Current + 1) & _Barrier_arrival_token_mask);
        
        _Val._Myval2._Current.store(_New_phase_count);
        _Val._Myval2._Current.notify_all();
    }

    struct _Counter_t {
        constexpr explicit _Counter_t(ptrdiff_t _Initial) : _Current(_Initial), _Total(_Initial) {}
        
        
        atomic<ptrdiff_t> _Current;
        atomic<ptrdiff_t> _Total;
    };

    _Compressed_pair<_Completion_function, _Counter_t> _Val;
};

}


#pragma warning(pop)
#pragma pack(pop)
#line 196 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\barrier"

#line 198 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\barrier"
#line 199 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\barrier"
#line 100 "all-std.cxx"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\future"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\pplwin.h"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\pplinterface.h"


#pragma once


namespace Concurrency
{


typedef void (__cdecl * TaskProc_t)(void *);


struct __declspec(novtable) scheduler_interface
{
    virtual void schedule( TaskProc_t, void* ) = 0;
};


struct scheduler_ptr
{
    
    
    explicit scheduler_ptr(::std::shared_ptr<scheduler_interface> _Scheduler) : _M_sharedScheduler(::std::move(_Scheduler))
    {
        _M_scheduler = _M_sharedScheduler.get();
    }

    
    explicit scheduler_ptr(  scheduler_interface * _PScheduler) : _M_scheduler(_PScheduler)
    {
    }

    
    scheduler_interface *operator->() const
    {
        return get();
    }

    
    scheduler_interface * get() const
    {
        return _M_scheduler;
    }

    
    operator bool() const { return get() != nullptr; }

private:

    ::std::shared_ptr<scheduler_interface> _M_sharedScheduler;
    scheduler_interface * _M_scheduler;
};


enum task_group_status
{
    
    
    not_complete,

    
    completed,

    
    canceled
};


class invalid_operation : public ::std::exception
{
public:
    
    
    explicit invalid_operation(  const char* _Message) noexcept
        : exception(_Message)
    { }

    
    invalid_operation() noexcept
        : exception()
    {}
};


class task_canceled : public ::std::exception
{
public:
    
    
    explicit task_canceled(  const char * _Message) noexcept
        : exception(_Message)
    {}

    
    task_canceled() noexcept
        : exception()
    {}
};

namespace details
{


class _Interruption_exception : public ::std::exception
{
public:
    explicit _Interruption_exception(const char * _Message) noexcept
        : exception(_Message)
    {}

    _Interruption_exception() noexcept
        : exception()
    {}
};


enum _TaskInliningMode
{
    
    _NoInline = 0,
    
    _DefaultAutoInline = 16,
    
    _ForceInline = -1,
};


typedef ::std::atomic<long> atomic_long;
typedef ::std::atomic<size_t> atomic_size_t;

template<typename _T>
_T atomic_compare_exchange(::std::atomic<_T>& _Target, _T _Exchange, _T _Comparand)
{
    _T _Result = _Comparand;
    _Target.compare_exchange_strong(_Result, _Exchange);
    return _Result;
}

template<typename _T>
_T atomic_exchange(::std::atomic<_T>& _Target, _T _Value)
{
    return _Target.exchange(_Value);
}

template<typename _T>
_T atomic_increment(::std::atomic<_T>& _Target)
{
    return _Target.fetch_add(1) + 1;
}

template<typename _T>
_T atomic_decrement(::std::atomic<_T>& _Target)
{
    return _Target.fetch_sub(1) - 1;
}

template<typename _T>
_T atomic_add(::std::atomic<_T>& _Target, _T _Value)
{
    return _Target.fetch_add(_Value) + _Value;
}

}} 

#line 272 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\pplinterface.h"
#line 22 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\pplwin.h"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltaskscheduler.h"


#pragma once

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\crtdefs.h"


#line 19 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltaskscheduler.h"

#pragma pack(push,8)
#pragma warning(push,3)

namespace Concurrency { namespace details {
    typedef void(__cdecl *_Threadpool_callback)(void*);

    struct _Threadpool_chore
    {
        void *_M_work; 
        _Threadpool_callback _M_callback;
        void *_M_data;

        _Threadpool_chore(_Threadpool_callback _Callback, void *_Data) : _M_work(nullptr), _M_callback(_Callback), _M_data(_Data) {}
        _Threadpool_chore() : _M_work(nullptr), _M_callback(nullptr), _M_data(nullptr) {}
    };

     int __cdecl _Schedule_chore(_Threadpool_chore*);
     void __cdecl _Release_chore(_Threadpool_chore*);
     int __cdecl _Reschedule_chore(const _Threadpool_chore*);


    class _Threadpool_task
    {
        _Threadpool_chore _M_chore;

        static void __cdecl _Callback(void *_TpTask)
        {
            static_cast<_Threadpool_task*>(_TpTask)->_Invoke();
        }

    public:

        _Threadpool_task(): _M_chore{&_Callback, this} {}

        virtual void _Invoke() noexcept = 0;

        virtual ~_Threadpool_task()
        {
            _Release_chore(&_M_chore);
        }

        void _Schedule()
        {
            _Schedule_chore(&_M_chore);
        }

        void _Reschedule() const
        {
            _Reschedule_chore(&_M_chore);
        }

        bool _Is_scheduled() const noexcept
        {
            return _M_chore._M_work != nullptr;
        }
    };
} }

#pragma warning(pop)
#pragma pack(pop)
#line 27 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\pplwin.h"

#pragma pack(push,8)
#pragma warning(push,3)


namespace Concurrency
{
namespace details
{

class _DefaultPPLTaskScheduler : public scheduler_interface
{
public:

    class _PPLTaskChore
    {
        _Threadpool_chore _M_Chore;
        TaskProc_t _M_proc;
        void *_M_param;

        static void __cdecl _Callback(void *_Args)
        {
            auto _Chore = ::std::unique_ptr<_PPLTaskChore>(static_cast<_PPLTaskChore*>(_Args));
            _Chore->_M_proc(_Chore->_M_param);
        }

    public:
        ~_PPLTaskChore()
        {
            _Release_chore(&_M_Chore);
        }

        _PPLTaskChore(TaskProc_t _Proc, void *_Param) : _M_Chore{&_Callback, this}, _M_proc(_Proc), _M_param(_Param)
        {
        }

        void _Schedule()
        {
            if (_Schedule_chore(&_M_Chore) != 0)
            {
                delete this;
                throw ::std::runtime_error("Fail to schedule the chore!");
            }
        }
    };

    virtual void schedule( TaskProc_t _Proc, void* _Param) override
    {
        (new _PPLTaskChore{ _Proc, _Param })->_Schedule();
    }
};

inline ::std::shared_ptr<scheduler_interface> * _GetStaticAmbientSchedulerStorage()
{
    
#pragma warning(suppress: 4640)
    static ::std::shared_ptr<scheduler_interface> _S_scheduler;
    return &_S_scheduler;
}

inline ::std::shared_ptr<scheduler_interface> & _GetStaticAmbientSchedulerRef()
{
    static ::std::once_flag _Flag;
    static ::std::shared_ptr<scheduler_interface> * _S_scheduler_address;
    ::std::call_once(_Flag, [] {
        _S_scheduler_address = _GetStaticAmbientSchedulerStorage();
    });
    return *_S_scheduler_address;
}

} 

inline const ::std::shared_ptr<scheduler_interface> &get_ambient_scheduler()
{
    return details::_GetStaticAmbientSchedulerRef();
}

inline void set_ambient_scheduler(const ::std::shared_ptr<scheduler_interface>& _Scheduler)
{
    details::_GetStaticAmbientSchedulerRef() = _Scheduler;
}

namespace details
{
    
     void __cdecl _ReportUnobservedException();

    namespace platform
    {
         unsigned int __cdecl GetNextAsyncId();
         size_t __cdecl CaptureCallstack(void **, size_t, size_t);
         long __cdecl GetCurrentThreadId();
    }
}

} 

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\pplcancellation_token.h"


#pragma once


#pragma pack(push,8)


namespace Concurrency
{

namespace details
{

    
    class _RefCounter
    {
    public:

        virtual ~_RefCounter()
        {
            ((void)0);
        }

        
        long _Reference()
        {
            const long _Refcount = _InterlockedIncrement(&_M_refCount);

            
            ((void)0);
            return _Refcount;
        }

        
        long _Release()
        {
            const long _Refcount = _InterlockedDecrement(&_M_refCount);
            ((void)0);

            if (_Refcount == 0)
            {
                _Destroy();
            }

            return _Refcount;
        }

    protected:

        
        virtual void _Destroy()
        {
            delete this;
        }

        
        _RefCounter(long _InitialCount = 1) : _M_refCount(_InitialCount)
        {
            ((void)0);
        }

        
        volatile long _M_refCount;
    };

    class _CancellationTokenState;

    class _CancellationTokenRegistration : public _RefCounter
    {
    private:

        static const long _STATE_CLEAR = 0;
        static const long _STATE_DEFER_DELETE = 1;
        static const long _STATE_SYNCHRONIZE = 2;
        static const long _STATE_CALLED = 3;

    public:

        _CancellationTokenRegistration(long _InitialRefs = 1) :
            _RefCounter(_InitialRefs),
            _M_state(_STATE_CALLED),
            _M_signaled(false),
            _M_pTokenState(nullptr)
        {
        }

        _CancellationTokenState *_GetToken() const
        {
            return _M_pTokenState;
        }

    protected:

        virtual ~_CancellationTokenRegistration()
        {
            ((void)0);
        }

        virtual void _Exec() = 0;

    private:

        friend class _CancellationTokenState;

        void _Invoke()
        {
            const long _Tid = ::Concurrency::details::platform::GetCurrentThreadId();
            ((void)0); 

            long _Result = atomic_compare_exchange(_M_state, _Tid, _STATE_CLEAR);

            if (_Result == _STATE_CLEAR)
            {
                _Exec();

                _Result = atomic_compare_exchange(_M_state, _STATE_CALLED, _Tid);

                if (_Result == _STATE_SYNCHRONIZE)
                {
                    {
                        ::std::lock_guard<::std::mutex> _Lock(_M_Mutex);
                        _M_signaled = true;
                    }
                    _M_CondVar.notify_all();
                }
            }
            _Release();
        }

        atomic_long               _M_state;
        ::std::condition_variable _M_CondVar;
        ::std::mutex              _M_Mutex;
        bool                      _M_signaled;
        _CancellationTokenState * _M_pTokenState;
    };

    template<typename _Function>
    class _CancellationTokenCallback : public _CancellationTokenRegistration
    {
    public:

        _CancellationTokenCallback(const _Function& _Func) :
            _M_function(_Func)
        {
        }

    protected:

        virtual void _Exec() override
        {
            _M_function();
        }

    private:

        _Function _M_function;
    };

    class CancellationTokenRegistration_TaskProc : public _CancellationTokenRegistration
    {
    public:

        CancellationTokenRegistration_TaskProc(TaskProc_t _Proc,   void *_PData, int _InitialRefs) :
            _CancellationTokenRegistration(_InitialRefs), _M_proc(_Proc), _M_pData(_PData)
        {
        }

    protected:

        virtual void _Exec() override
        {
            _M_proc(_M_pData);
        }

    private:

        TaskProc_t _M_proc;
        void *_M_pData;

    };

    
    class _CancellationTokenState : public _RefCounter
    {
    protected:
        class TokenRegistrationContainer
        {
        private:
            typedef struct _Node {
                _CancellationTokenRegistration* _M_token;
                _Node *_M_next;

                _Node(_CancellationTokenRegistration* _Token) : _M_token(_Token), _M_next(nullptr)
                {
                }
            } Node;

        public:
            TokenRegistrationContainer() : _M_begin(nullptr), _M_last(nullptr)
            {
            }

            ~TokenRegistrationContainer()
            {
                auto _Node = _M_begin;
                while (_Node != nullptr)
                {
                    Node* _Tmp = _Node;
                    _Node = _Node->_M_next;
                    delete _Tmp;
                }
            }

            void swap(TokenRegistrationContainer& _List)
            {
                ::std::swap(_List._M_begin, _M_begin);
                ::std::swap(_List._M_last, _M_last);
            }

            bool empty()
            {
                return _M_begin == nullptr;
            }

            template<typename _Ty>
            void for_each(_Ty _Lambda)
            {
                Node* _Node = _M_begin;

                while (_Node != nullptr)
                {
                    _Lambda(_Node->_M_token);
                    _Node = _Node->_M_next;
                }
            }

            void push_back(_CancellationTokenRegistration* _Token)
            {
                auto _Node = new Node(_Token);
                if (_M_begin == nullptr)
                {
                    _M_begin = _Node;
                }
                else
                {
                    _M_last->_M_next = _Node;
                }

                _M_last = _Node;
            }

            void remove(_CancellationTokenRegistration* _Token)
            {
                Node* _Node = _M_begin;
                Node* _Prev = nullptr;

                while (_Node != nullptr)
                {
                    if (_Node->_M_token == _Token) {
                        if (_Prev == nullptr)
                        {
                            _M_begin = _Node->_M_next;
                        }
                        else
                        {
                            _Prev->_M_next = _Node->_M_next;
                        }

                        if (_Node->_M_next == nullptr)
                        {
                            _M_last = _Prev;
                        }

                        delete _Node;
                        break;
                    }

                    _Prev = _Node;
                    _Node = _Node->_M_next;
                }
            }

        private:
            Node *_M_begin;
            Node *_M_last;
        };

    public:
        static _CancellationTokenState * _NewTokenState()
        {
            return new _CancellationTokenState();
        }

        static _CancellationTokenState *_None()
        {
            return reinterpret_cast<_CancellationTokenState *>(2);
        }

        static bool _IsValid(  _CancellationTokenState *_PToken)
        {
            return (_PToken != nullptr && _PToken != _None());
        }

        _CancellationTokenState() :
            _M_stateFlag(0)
        {
        }

        ~_CancellationTokenState()
        {
            TokenRegistrationContainer _RundownList;
            {
                ::std::lock_guard<::std::mutex> _Lock(_M_listLock);
                _M_registrations.swap(_RundownList);
            }

            _RundownList.for_each([](_CancellationTokenRegistration * _PRegistration)
            {
                _PRegistration->_M_state = _CancellationTokenRegistration::_STATE_SYNCHRONIZE;
                _PRegistration->_Release();
            });
        }

        bool _IsCanceled() const
        {
            return (_M_stateFlag != 0);
        }

        void _Cancel()
        {
            if (atomic_compare_exchange(_M_stateFlag, 1l, 0l) == 0)
            {
                TokenRegistrationContainer _RundownList;
                {
                    ::std::lock_guard<::std::mutex> _Lock(_M_listLock);
                    _M_registrations.swap(_RundownList);
                }

                _RundownList.for_each([](_CancellationTokenRegistration * _PRegistration)
                {
                    _PRegistration->_Invoke();
                });

                _M_stateFlag = 2;
            }
        }

        _CancellationTokenRegistration *_RegisterCallback(TaskProc_t _PCallback,   void *_PData, int _InitialRefs = 1)
        {
            _CancellationTokenRegistration *_PRegistration = new CancellationTokenRegistration_TaskProc(_PCallback, _PData, _InitialRefs);
            _RegisterCallback(_PRegistration);
            return _PRegistration;
        }

        void _RegisterCallback(  _CancellationTokenRegistration *_PRegistration)
        {
            _PRegistration->_M_state = _CancellationTokenRegistration::_STATE_CLEAR;
            _PRegistration->_Reference();
            _PRegistration->_M_pTokenState = this;

            bool _Invoke = true;

            if (!_IsCanceled())
            {
                ::std::lock_guard<::std::mutex> _Lock(_M_listLock);

                if (!_IsCanceled())
                {
                    _Invoke = false;
                    _M_registrations.push_back(_PRegistration);
                }
            }

            if (_Invoke)
            {
                _PRegistration->_Invoke();
            }
        }

        void _DeregisterCallback(  _CancellationTokenRegistration *_PRegistration)
        {
            bool _Synchronize = false;

            {
                ::std::lock_guard<::std::mutex> _Lock(_M_listLock);

                
                if (!_M_registrations.empty())
                {
                    _M_registrations.remove(_PRegistration);
                    _PRegistration->_M_state = _CancellationTokenRegistration::_STATE_SYNCHRONIZE;
                    _PRegistration->_Release();
                }
                else
                {
                    _Synchronize = true;
                }
            }

            
            if (_Synchronize)
            {
                const long _Result = atomic_compare_exchange(
                    _PRegistration->_M_state,
                    _CancellationTokenRegistration::_STATE_DEFER_DELETE,
                    _CancellationTokenRegistration::_STATE_CLEAR
                    );

                switch(_Result)
                {
                    case _CancellationTokenRegistration::_STATE_CLEAR:
                    case _CancellationTokenRegistration::_STATE_CALLED:
                        break;
                    case _CancellationTokenRegistration::_STATE_DEFER_DELETE:
                    case _CancellationTokenRegistration::_STATE_SYNCHRONIZE:
                        ((void)0);
                        break;
                    default:
                    {
                        if (_Result == ::Concurrency::details::platform::GetCurrentThreadId())
                        {
                            
                            
                            break;
                        }

                        const long _Result_1 = atomic_exchange(_PRegistration->_M_state, _CancellationTokenRegistration::_STATE_SYNCHRONIZE);

                        if (_Result_1 != _CancellationTokenRegistration::_STATE_CALLED)
                        {
                            ::std::unique_lock<::std::mutex> _Lock(_PRegistration->_M_Mutex);
                            _PRegistration->_M_CondVar.wait(_Lock,
                                [_PRegistration]{ return _PRegistration->_M_signaled; });

                            ((void)0);
                        }

                        break;
                    }
                }
            }
        }

    private:

        
        atomic_long _M_stateFlag;

        
        ::std::mutex _M_listLock;

        
        TokenRegistrationContainer _M_registrations;
    };

} 

class cancellation_token_source;
class cancellation_token;


class cancellation_token_registration
{
public:

    cancellation_token_registration() :
        _M_pRegistration(nullptr)
    {
    }

    ~cancellation_token_registration()
    {
        _Clear();
    }

    cancellation_token_registration(const cancellation_token_registration& _Src)
    {
        _Assign(_Src._M_pRegistration);
    }

    cancellation_token_registration(cancellation_token_registration&& _Src)
    {
        _Move(_Src._M_pRegistration);
    }

    cancellation_token_registration& operator=(const cancellation_token_registration& _Src)
    {
        if (this != &_Src)
        {
            _Clear();
            _Assign(_Src._M_pRegistration);
        }
        return *this;
    }

    cancellation_token_registration& operator=(cancellation_token_registration&& _Src)
    {
        if (this != &_Src)
        {
            _Clear();
            _Move(_Src._M_pRegistration);
        }
        return *this;
    }

    bool operator==(const cancellation_token_registration& _Rhs) const
    {
        return _M_pRegistration == _Rhs._M_pRegistration;
    }

    bool operator!=(const cancellation_token_registration& _Rhs) const
    {
        return !(operator==(_Rhs));
    }

private:

    friend class cancellation_token;

    cancellation_token_registration(  details::_CancellationTokenRegistration *_PRegistration) :
        _M_pRegistration(_PRegistration)
    {
    }

    void _Clear()
    {
        if (_M_pRegistration != nullptr)
        {
            _M_pRegistration->_Release();
        }
        _M_pRegistration = nullptr;
    }

    void _Assign(  details::_CancellationTokenRegistration *_PRegistration)
    {
        if (_PRegistration != nullptr)
        {
            _PRegistration->_Reference();
        }
        _M_pRegistration = _PRegistration;
    }

    void _Move(  details::_CancellationTokenRegistration *&_PRegistration)
    {
        _M_pRegistration = _PRegistration;
        _PRegistration = nullptr;
    }

    details::_CancellationTokenRegistration *_M_pRegistration;
};


class cancellation_token
{
public:

    typedef details::_CancellationTokenState * _ImplType;

    
    static cancellation_token none()
    {
        return cancellation_token();
    }

    cancellation_token(const cancellation_token& _Src)
    {
        _Assign(_Src._M_Impl);
    }

    cancellation_token(cancellation_token&& _Src)
    {
        _Move(_Src._M_Impl);
    }

    cancellation_token& operator=(const cancellation_token& _Src)
    {
        if (this != &_Src)
        {
            _Clear();
            _Assign(_Src._M_Impl);
        }
        return *this;
    }

    cancellation_token& operator=(cancellation_token&& _Src)
    {
        if (this != &_Src)
        {
            _Clear();
            _Move(_Src._M_Impl);
        }
        return *this;
    }

    bool operator==(const cancellation_token& _Src) const
    {
        return _M_Impl == _Src._M_Impl;
    }

    bool operator!=(const cancellation_token& _Src) const
    {
        return !(operator==(_Src));
    }

    ~cancellation_token()
    {
        _Clear();
    }

    
    bool is_cancelable() const
    {
        return (_M_Impl != nullptr);
    }

    
    bool is_canceled() const
    {
        return (_M_Impl != nullptr && _M_Impl->_IsCanceled());
    }

    
    template<typename _Function>
    ::Concurrency::cancellation_token_registration register_callback(const _Function& _Func) const
    {
        if (_M_Impl == nullptr)
        {
            
            throw invalid_operation();
        }
#pragma warning(suppress: 28197)
        details::_CancellationTokenCallback<_Function> *_PCallback = new details::_CancellationTokenCallback<_Function>(_Func);
        _M_Impl->_RegisterCallback(_PCallback);
        return cancellation_token_registration(_PCallback);
    }

    
    void deregister_callback(const cancellation_token_registration& _Registration) const
    {
        _M_Impl->_DeregisterCallback(_Registration._M_pRegistration);
    }

    _ImplType _GetImpl() const
    {
        return _M_Impl;
    }

    _ImplType _GetImplValue() const
    {
        return (_M_Impl == nullptr) ? ::Concurrency::details::_CancellationTokenState::_None() : _M_Impl;
    }

    static cancellation_token _FromImpl(_ImplType _Impl)
    {
        return cancellation_token(_Impl);
    }

private:

    friend class cancellation_token_source;

    _ImplType _M_Impl;

    void _Clear()
    {
        if (_M_Impl != nullptr)
        {
            _M_Impl->_Release();
        }
        _M_Impl = nullptr;
    }

    void _Assign(_ImplType _Impl)
    {
        if (_Impl != nullptr)
        {
            _Impl->_Reference();
        }
        _M_Impl = _Impl;
    }

    void _Move(_ImplType &_Impl)
    {
        _M_Impl = _Impl;
        _Impl = nullptr;
    }

    cancellation_token() :
        _M_Impl(nullptr)
    {
    }

    cancellation_token(_ImplType _Impl) :
        _M_Impl(_Impl)
    {
        if (_M_Impl == ::Concurrency::details::_CancellationTokenState::_None())
        {
            _M_Impl = nullptr;
        }

        if (_M_Impl != nullptr)
        {
            _M_Impl->_Reference();
        }
    }
};


class cancellation_token_source
{
public:

    typedef ::Concurrency::details::_CancellationTokenState * _ImplType;

    
    cancellation_token_source()
    {
        _M_Impl = new ::Concurrency::details::_CancellationTokenState;
    }

    cancellation_token_source(const cancellation_token_source& _Src)
    {
        _Assign(_Src._M_Impl);
    }

    cancellation_token_source(cancellation_token_source&& _Src)
    {
        _Move(_Src._M_Impl);
    }

    cancellation_token_source& operator=(const cancellation_token_source& _Src)
    {
        if (this != &_Src)
        {
            _Clear();
            _Assign(_Src._M_Impl);
        }
        return *this;
    }

    cancellation_token_source& operator=(cancellation_token_source&& _Src)
    {
        if (this != &_Src)
        {
            _Clear();
            _Move(_Src._M_Impl);
        }
        return *this;
    }

    bool operator==(const cancellation_token_source& _Src) const
    {
        return _M_Impl == _Src._M_Impl;
    }

    bool operator!=(const cancellation_token_source& _Src) const
    {
        return !(operator==(_Src));
    }

    ~cancellation_token_source()
    {
        if (_M_Impl != nullptr)
        {
            _M_Impl->_Release();
        }
    }

    
    cancellation_token get_token() const
    {
        return cancellation_token(_M_Impl);
    }

    
    static cancellation_token_source create_linked_source(cancellation_token& _Src)
    {
        cancellation_token_source _NewSource;
        _Src.register_callback( [_NewSource](){ _NewSource.cancel(); } );
        return _NewSource;
    }

    
    template<typename _Iter>
    static cancellation_token_source create_linked_source(_Iter _Begin, _Iter _End)
    {
        cancellation_token_source _NewSource;
        for (_Iter _It = _Begin; _It != _End; ++_It)
        {
            _It->register_callback( [_NewSource](){ _NewSource.cancel(); } );
        }
        return _NewSource;
    }

    
    void cancel() const
    {
        _M_Impl->_Cancel();
    }

    _ImplType _GetImpl() const
    {
        return _M_Impl;
    }

    static cancellation_token_source _FromImpl(_ImplType _Impl)
    {
        return cancellation_token_source(_Impl);
    }

private:

    _ImplType _M_Impl;

    void _Clear()
    {
        if (_M_Impl != nullptr)
        {
            _M_Impl->_Release();
        }
        _M_Impl = nullptr;
    }

    void _Assign(_ImplType _Impl)
    {
        if (_Impl != nullptr)
        {
            _Impl->_Reference();
        }
        _M_Impl = _Impl;
    }

    void _Move(_ImplType &_Impl)
    {
        _M_Impl = _Impl;
        _Impl = nullptr;
    }

    cancellation_token_source(_ImplType _Impl) :
        _M_Impl(_Impl)
    {
        if (_M_Impl == ::Concurrency::details::_CancellationTokenState::_None())
        {
            _M_Impl = nullptr;
        }

        if (_M_Impl != nullptr)
        {
            _M_Impl->_Reference();
        }
    }
};

} 


#pragma pack(pop)

#line 995 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\pplcancellation_token.h"
#line 126 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\pplwin.h"

namespace Concurrency
{

namespace details
{


#line 144 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\pplwin.h"

    struct _TaskProcHandle
    {
        _TaskProcHandle() {}
        virtual ~_TaskProcHandle() {}
        virtual void invoke() const = 0;

        void operator()() const
        {
            this->invoke();
        }

        static void __cdecl _RunChoreBridge(void * _Parameter)
        {
            ::std::unique_ptr<_TaskProcHandle> {static_cast<_TaskProcHandle *>(_Parameter)}->invoke();
        }
    };

    class _TaskCollectionBaseImpl
    {
    protected:
        enum _TaskCollectionState {
            _New,
            _Scheduled,
            _Completed
        };

        void _SetCollectionState(_TaskCollectionState _NewState)
        {
            ((void)0);
            ::std::lock_guard<::std::mutex> _Lock(_M_Cs);
            if (_M_State < _NewState)
            {
                _M_State = _NewState;
            }

            _M_StateChanged.notify_all();
        }

        void WaitUntilStateChangedTo(_TaskCollectionState _State)
        {
            ::std::unique_lock<::std::mutex> _Lock(_M_Cs);

            while(_M_State < _State)
            {
                _M_StateChanged.wait(_Lock);
            }
        }
    public:

        typedef _TaskProcHandle _TaskProcHandle_t;

        _TaskCollectionBaseImpl(::Concurrency::scheduler_ptr _PScheduler)
            : _M_pScheduler(_PScheduler), _M_State(_New)
        {
        }

        void _ScheduleTask(_TaskProcHandle_t* _Parameter, _TaskInliningMode _InliningMode)
        {
            if (_InliningMode == _ForceInline)
            {
                _TaskProcHandle_t::_RunChoreBridge(_Parameter);
            }
            else
            {
                if (_M_pScheduler)
                {
                    _M_pScheduler->schedule(_TaskProcHandle_t::_RunChoreBridge, _Parameter);
                }
                else
                {
                    _DefaultPPLTaskScheduler().schedule(_TaskProcHandle_t::_RunChoreBridge, _Parameter);
                }
            }
        }

        void _Cancel()
        {
            
        }

        void _RunAndWait()
        {
            _Wait();
        }

        void _Wait()
        {
            WaitUntilStateChangedTo(_Completed);
        }

        void _Complete()
        {
            
            _SetCollectionState(_Completed);
        }

        ::Concurrency::scheduler_ptr _GetScheduler() const
        {
            return _M_pScheduler;
        }

        
        static void _RunTask(TaskProc_t _Proc, void * _Parameter, _TaskInliningMode _InliningMode)
        {
            if (_InliningMode == _ForceInline)
            {
                _Proc(_Parameter);
            }
            else
            {
                
                auto _Ptr = get_ambient_scheduler();
                if (_Ptr)
                {
                    _Ptr->schedule(_Proc, _Parameter);
                }
                else
                {
                    _DefaultPPLTaskScheduler().schedule(_Proc, _Parameter);
                }
            }
        }
    protected:
        ::std::condition_variable _M_StateChanged;
        ::std::mutex _M_Cs;
        ::Concurrency::scheduler_ptr _M_pScheduler;
        _TaskCollectionState _M_State;
    };

    typedef _TaskCollectionBaseImpl _TaskCollection_t;

    
    struct _Task_generator_oversubscriber {};

    typedef _TaskInliningMode _TaskInliningMode_t;
    typedef _Task_generator_oversubscriber _Task_generator_oversubscriber_t;

} 
} 

namespace concurrency = ::Concurrency;


#pragma warning(pop)
#pragma pack(pop)
#line 291 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\pplwin.h"
#line 20 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"


#line 32 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"


#line 38 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"


#line 42 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"


#pragma detect_mismatch("_PPLTASK_ASYNC_LOGGING", "1")


#line 49 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"


#line 53 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"

#line 55 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"


#line 58 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"

#line 60 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"

#pragma pack(push,8)

#pragma warning(push)
#pragma warning(disable: 28197)
#pragma warning(disable: 4100) 
#pragma warning(disable: 4127) 


namespace Concurrency
{
    namespace details
    {
        template<class _Ty>
        _Ty&& declval();
    }
}


namespace Concurrency
{


typedef task_group_status task_status;

template <typename _Type> class task;
template <> class task<void>;


#line 108 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"
#line 109 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"


#pragma detect_mismatch("ppltask_saved_frame_numbers", "PPL_TASK_SAVE_FRAME_COUNT")

#line 116 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"


#line 131 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"

#line 133 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"


inline __declspec(noreturn) void __cdecl cancel_current_task()
{
    throw task_canceled{};
}

namespace details
{
    struct _DefaultTaskHelper
    {
        
        
        static void __declspec(noreturn) __cdecl _NoCallOnDefaultTask_ErrorImpl()
        {
            throw invalid_operation("This function cannot be called on a default constructed task");
        }
    };

    
    class _TaskCreationCallstack
    {
    private:
        
        
        void* _M_SingleFrame;
        ::std::vector<void *> _M_frames;
    public:
        _TaskCreationCallstack()
        {
            _M_SingleFrame = nullptr;
        }

        
        static _TaskCreationCallstack _CaptureSingleFrameCallstack(void *_SingleFrame)
        {
            _TaskCreationCallstack _csc;
            _csc._M_SingleFrame = _SingleFrame;
            return _csc;
        }

        
        __declspec(noinline)
        static _TaskCreationCallstack _CaptureMultiFramesCallstack(void *_SingleFrame, size_t _CaptureFrames)
        {
            _TaskCreationCallstack _csc;
            _csc._M_SingleFrame = _SingleFrame;
            if (_CaptureFrames > 1)
            {
            _csc._M_frames.resize(_CaptureFrames);
            
            _csc._M_frames.resize(::Concurrency::details::platform::CaptureCallstack(&_csc._M_frames[0], 2, _CaptureFrames));
            }
            return _csc;
        }
    };
    typedef unsigned char _Unit_type;

    struct _TypeSelectorNoAsync {};
    struct _TypeSelectorAsyncOperationOrTask {};
    struct _TypeSelectorAsyncOperation : public _TypeSelectorAsyncOperationOrTask { };
    struct _TypeSelectorAsyncTask : public _TypeSelectorAsyncOperationOrTask { };
    struct _TypeSelectorAsyncAction {};
    struct _TypeSelectorAsyncActionWithProgress {};
    struct _TypeSelectorAsyncOperationWithProgress {};

    template<typename _Ty>
    struct _NormalizeVoidToUnitType
    {
        typedef _Ty _Type;
    };

    template<>
    struct _NormalizeVoidToUnitType<void>
    {
        typedef _Unit_type _Type;
    };

    template<typename _Ty>
    struct _IsUnwrappedAsyncSelector
    {
        static const bool _Value = true;
    };

    template<>
    struct _IsUnwrappedAsyncSelector<_TypeSelectorNoAsync>
    {
        static const bool _Value = false;
    };

    template <typename _Ty>
    struct _UnwrapTaskType
    {
        typedef _Ty _Type;
    };

    template <typename _Ty>
    struct _UnwrapTaskType<task<_Ty>>
    {
        typedef _Ty _Type;
    };

    template <typename _Ty>
    _TypeSelectorAsyncTask _AsyncOperationKindSelector(task<_Ty>);

    _TypeSelectorNoAsync _AsyncOperationKindSelector(...);


#line 335 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"
    template <typename _Type>
    struct _IsIAsyncInfo
    {
        static const bool _Value = false;
    };

    template <typename _Type, bool _IsAsync = false>
    struct _TaskTypeTraits
    {
        typedef typename _UnwrapTaskType<_Type>::_Type _TaskRetType;
        typedef decltype(_AsyncOperationKindSelector(details::declval<_Type>())) _AsyncKind;
        typedef typename _NormalizeVoidToUnitType<_TaskRetType>::_Type _NormalizedTaskRetType;

        static const bool _IsAsyncTask = false;
        static const bool _IsUnwrappedTaskOrAsync = _IsUnwrappedAsyncSelector<_AsyncKind>::_Value;
    };
#line 352 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"

    template <typename _Function> auto _IsCallable(_Function _Func, int) -> decltype(_Func(), ::std::true_type());
    template <typename _Function> ::std::false_type _IsCallable(_Function, ...);

    template <>
    struct _TaskTypeTraits<void>
    {
        typedef void _TaskRetType;
        typedef _TypeSelectorNoAsync _AsyncKind;
        typedef _Unit_type _NormalizedTaskRetType;

        static const bool _IsAsyncTask = false;
        static const bool _IsUnwrappedTaskOrAsync = false;
    };

    struct _BadContinuationParamType{};

    template <typename _Function, typename _Type> auto _ReturnTypeHelper(_Type _Obj, _Function _Func, int, int) -> decltype(_Func(::std::declval<task<_Type>>()));
    template <typename _Function, typename _Type> auto _ReturnTypeHelper(_Type _Obj, _Function _Func, int, ...) -> decltype(_Func(_Obj));
    template <typename _Function, typename _Type> auto _ReturnTypeHelper(_Type _Obj, _Function _Func, ...) -> _BadContinuationParamType;

    template <typename _Function, typename _Type> auto _IsTaskHelper(_Type _Obj, _Function _Func, int, int) -> decltype(_Func(::std::declval<task<_Type>>()), ::std::true_type());
    template <typename _Function, typename _Type> auto _IsTaskHelper(_Type _Obj, _Function _Func, int, ...) -> ::std::false_type;

    template <typename _Function> auto _VoidReturnTypeHelper(_Function _Func, int, int) -> decltype(_Func(::std::declval<task<void>>()));
    template <typename _Function> auto _VoidReturnTypeHelper(_Function _Func, int, ...) -> decltype(_Func());

    template <typename _Function> auto _VoidIsTaskHelper(_Function _Func, int, int) -> decltype(_Func(::std::declval<task<void>>()), ::std::true_type());
    template <typename _Function> auto _VoidIsTaskHelper(_Function _Func, int, ...) -> ::std::false_type;

    template<typename _Function, typename _ExpectedParameterType>
    struct _FunctionTypeTraits
    {
        typedef decltype(_ReturnTypeHelper(details::declval<_ExpectedParameterType>(),details::declval<_Function>(), 0, 0)) _FuncRetType;
        static_assert(!::std::is_same_v<_FuncRetType, _BadContinuationParamType>, "incorrect parameter type for the callable object in 'then'; consider _ExpectedParameterType or task<_ExpectedParameterType> (see below)");

        typedef decltype(_IsTaskHelper(details::declval<_ExpectedParameterType>(),details::declval<_Function>(), 0, 0)) _Takes_task;
    };

    template<typename _Function>
    struct _FunctionTypeTraits<_Function, void>
    {
        typedef decltype(_VoidReturnTypeHelper(details::declval<_Function>(), 0, 0)) _FuncRetType;
        typedef decltype(_VoidIsTaskHelper(details::declval<_Function>(), 0, 0)) _Takes_task;
    };


    template<typename _Ty, typename _IsTaskType>
    struct _ContinuationArgTypeHelper
    {
        static_assert(::std::is_same_v<_IsTaskType, ::std::false_type>, "_IsTaskType template parameter must be std::true_type or std::false_type");
        typedef _Ty _ArgType;
    };

    template<typename _Ty>
    struct _ContinuationArgTypeHelper<_Ty, ::std::true_type>
    {
        typedef task<_Ty> _ArgType;
    };

    template<typename _RetTypeT, typename _ArgTypeT>
    struct _StdFunctionTypeHelper
    {
        typedef ::std::function<_RetTypeT __cdecl(_ArgTypeT)> _StdFuncT;
    };

    template<typename _RetTypeT>
    struct _StdFunctionTypeHelper<_RetTypeT, void>
    {
        typedef ::std::function<_RetTypeT __cdecl()> _StdFuncT;
    };
#line 424 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"

    template<typename _Function, typename _ReturnType>
    struct _ContinuationTypeTraits
    {
        typedef task<typename _TaskTypeTraits<typename _FunctionTypeTraits<_Function, _ReturnType>::_FuncRetType>::_TaskRetType> _TaskOfType;

        typedef typename _ContinuationArgTypeHelper<_ReturnType, typename details::_FunctionTypeTraits<_Function, _ReturnType>::_Takes_task>::_ArgType _ArgTypeT;
        typedef typename _FunctionTypeTraits<_Function, _ReturnType>::_FuncRetType _RetTypeT;
        typedef typename _StdFunctionTypeHelper<_RetTypeT, _ArgTypeT>::_StdFuncT _StdFuncT;
#line 434 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"
    };
    
    
    template <typename _TaskType, typename _FuncRetType>
    struct _InitFunctorTypeTraits
    {
        typedef typename _TaskTypeTraits<_FuncRetType>::_AsyncKind _AsyncKind;
        static const bool _IsAsyncTask = _TaskTypeTraits<_FuncRetType>::_IsAsyncTask;
        static const bool _IsUnwrappedTaskOrAsync = _TaskTypeTraits<_FuncRetType>::_IsUnwrappedTaskOrAsync;
    };

    template<typename _Ty>
    struct _InitFunctorTypeTraits<_Ty, _Ty>
    {
        typedef _TypeSelectorNoAsync _AsyncKind;
        static const bool _IsAsyncTask = false;
        static const bool _IsUnwrappedTaskOrAsync = false;
    };

    
    struct _TaskProcThunk
    {
        _TaskProcThunk(const ::std::function<void ()> & _Callback) :
            _M_func(_Callback)
        {
        }

        static void __cdecl _Bridge(void *_PData)
        {
            _TaskProcThunk *_PThunk = reinterpret_cast<_TaskProcThunk *>(_PData);
            _Holder _ThunkHolder(_PThunk);
            _PThunk->_M_func();
        }
    private:

        
        struct _Holder
        {
            _Holder(_TaskProcThunk * _PThunk) : _M_pThunk(_PThunk)
            {
            }

            ~_Holder()
            {
                delete _M_pThunk;
            }

            _TaskProcThunk * _M_pThunk;

        private:
            _Holder& operator=(const _Holder&);
        };

        ::std::function<void()> _M_func;
        _TaskProcThunk& operator=(const _TaskProcThunk&);
    };

    
    inline void _ScheduleFuncWithAutoInline(const ::std::function<void ()> & _Func, _TaskInliningMode_t _InliningMode)
    {
        _TaskCollection_t::_RunTask(&_TaskProcThunk::_Bridge, new _TaskProcThunk(_Func), _InliningMode);
    }

    class _ContextCallback
    {
        typedef ::std::function<void __cdecl ()> _CallbackFunction;

    public:

        static _ContextCallback _CaptureCurrent()
        {
            _ContextCallback _Context;
            _Context._Capture();
            return _Context;
        }

        ~_ContextCallback()
        {
            _Reset();
        }

        _ContextCallback(bool _DeferCapture = false)
        {
            if (_DeferCapture)
            {
                _M_context._M_captureMethod = _S_captureDeferred;
            }
            else
            {
                _M_context._M_pContextCallback = nullptr;
            }
        }

        
        void _Resolve(bool _CaptureCurrent)
        {
            if(_M_context._M_captureMethod == _S_captureDeferred)
            {
                _M_context._M_pContextCallback = nullptr;

                if (_CaptureCurrent && _IsCurrentOriginSTA())
                {
                    _Capture();
                }
            }
        }


        _ContextCallback(const _ContextCallback& _Src)
        {
            _Assign(_Src._M_context._M_pContextCallback);
        }

        _ContextCallback(_ContextCallback&& _Src)
        {
            _M_context._M_pContextCallback = _Src._M_context._M_pContextCallback;
            _Src._M_context._M_pContextCallback = nullptr;
        }

        _ContextCallback& operator=(const _ContextCallback& _Src)
        {
            if (this != &_Src)
            {
                _Reset();
                _Assign(_Src._M_context._M_pContextCallback);
            }
            return *this;
        }

        _ContextCallback& operator=(_ContextCallback&& _Src)
        {
            if (this != &_Src)
            {
                _M_context._M_pContextCallback = _Src._M_context._M_pContextCallback;
                _Src._M_context._M_pContextCallback = nullptr;
            }
            return *this;
        }

        bool _HasCapturedContext() const
        {
            ((void)0);
            return (_M_context._M_pContextCallback != nullptr);
        }


        bool operator==(const _ContextCallback& _Rhs) const
        {
            return (_M_context._M_pContextCallback == _Rhs._M_context._M_pContextCallback);
        }

        bool operator != (const _ContextCallback& _Rhs) const
        {
            return !(operator==(_Rhs));
        }

         void __thiscall _CallInContext(_CallbackFunction _Func, bool _IgnoreDisconnect) const;

        void _CallInContext(_CallbackFunction _Func) const
        {
            _CallInContext(_Func, false);
        }

    private:
         void __thiscall _Reset();

         void __thiscall _Assign(void *_PContextCallback);

        
         static bool __cdecl _IsCurrentOriginSTA();

         void __thiscall _Capture();

        union
        {
            void *_M_pContextCallback; 
            size_t _M_captureMethod;
        } _M_context;

        static const size_t _S_captureDeferred = 1;

    };

    template<typename _Type>
    struct _ResultHolder
    {
        _ResultHolder() = default;

        void Set(const _Type& _type)
        {
            _Result = _type;
        }

        _Type Get()
        {
            return _Result;
        }

        _Type _Result;
    };

    
    template<>
    struct _ResultHolder<::std::vector<bool>>
    {
        void Set(const ::std::vector<bool>& _type)
        {
            _Result.resize(_type.size());
            ::std::transform(_type.begin(), _type.end(), _Result.begin(), [](bool _Val) { return static_cast<char>(_Val); });
        }

        ::std::vector<bool> Get()
        {
            ::std::vector<bool> _Ret(_Result.size());
            ::std::transform(_Result.begin(), _Result.end(), _Ret.begin(), [](char _Val) { return _Val != 0; });
            return _Ret;
        }

        ::std::vector<char> _Result;
    };


#line 753 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"

    
    struct _ExceptionHolder
    {
    private:
        
        
#line 765 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"
         void __thiscall ReportUnhandledError();
#line 767 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"

    public:
        explicit _ExceptionHolder(const ::std::exception_ptr& _E, const _TaskCreationCallstack &_stackTrace) :
        _M_exceptionObserved(0), _M_stdException(_E), _M_stackTrace(_stackTrace)
        {
        }

        __declspec(noinline)
        ~_ExceptionHolder()
        {
            if (_M_exceptionObserved == 0)
            {
                
                
                do { ReportUnhandledError(); __debugbreak(); ::Concurrency::details::_ReportUnobservedException(); } while (false);
            }
        }

        void _RethrowUserException()
        {
            if (_M_exceptionObserved == 0)
            {
                atomic_exchange(_M_exceptionObserved, 1l);
            }

            ::std::rethrow_exception(_M_stdException);
        }

        
        atomic_long _M_exceptionObserved;

        
        ::std::exception_ptr _M_stdException;

        
        _TaskCreationCallstack _M_stackTrace;

    };


#line 938 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"
} 


class task_continuation_context : public details::_ContextCallback
{
public:

    
    static task_continuation_context use_default()
    {
        return task_continuation_context{_Tag{}};
    }

    
    static task_continuation_context get_current_winrt_context()
    {
        task_continuation_context _Current{_Tag{}};
        _Current._Resolve(true);
        return _Current;
    }


#line 1035 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"

    
    static task_continuation_context use_synchronous_execution()
    {
        task_continuation_context _Current{_Tag{}};
        _Current._Resolve(false);
        _Current._M_RunInline = true;
        return _Current;
    }

    bool _ForceInline() const
    {
        return _M_RunInline;
    }

private:
     __thiscall task_continuation_context();


#line 1068 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"
    
    
    struct _Tag {};


#line 1074 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"
    explicit task_continuation_context(_Tag) : task_continuation_context() {}
#line 1076 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"

    bool _M_RunInline; 
};

class task_options;
namespace details
{
    struct _Internal_task_options
    {
        bool _M_hasPresetCreationCallstack;
        _TaskCreationCallstack _M_presetCreationCallstack;

        void _set_creation_callstack(const _TaskCreationCallstack &_callstack)
        {
            _M_hasPresetCreationCallstack = true;
            _M_presetCreationCallstack = _callstack;
        }
        _Internal_task_options()
        {
            _M_hasPresetCreationCallstack = false;
        }
    };

    inline _Internal_task_options &_get_internal_task_options(task_options &_Options);
    inline const _Internal_task_options &_get_internal_task_options(const task_options &_Options);
}


class task_options
{
public:


    task_options()
        : _M_Scheduler(get_ambient_scheduler()),
          _M_CancellationToken(cancellation_token::none()),
          _M_ContinuationContext(task_continuation_context::use_default()),
          _M_HasCancellationToken(false),
          _M_HasScheduler(false)
    {
    }

    
    task_options(cancellation_token _Token)
        : _M_Scheduler(get_ambient_scheduler()),
          _M_CancellationToken(_Token),
          _M_ContinuationContext(task_continuation_context::use_default()),
          _M_HasCancellationToken(true),
          _M_HasScheduler(false)
    {
    }

    
    task_options(task_continuation_context _ContinuationContext)
        : _M_Scheduler(get_ambient_scheduler()),
          _M_CancellationToken(cancellation_token::none()),
          _M_ContinuationContext(_ContinuationContext),
          _M_HasCancellationToken(false),
          _M_HasScheduler(false)
    {
    }

    
    task_options(cancellation_token _Token, task_continuation_context _ContinuationContext)
        : _M_Scheduler(get_ambient_scheduler()),
          _M_CancellationToken(_Token),
          _M_ContinuationContext(_ContinuationContext),
          _M_HasCancellationToken(true),
          _M_HasScheduler(false)
    {
    }

    
    template<typename _SchedType>
    task_options(::std::shared_ptr<_SchedType> _Scheduler)
        : _M_Scheduler(::std::move(_Scheduler)),
          _M_CancellationToken(cancellation_token::none()),
          _M_ContinuationContext(task_continuation_context::use_default()),
          _M_HasCancellationToken(false),
          _M_HasScheduler(true)
    {
    }

    
    task_options(scheduler_interface& _Scheduler)
        : _M_Scheduler(&_Scheduler),
          _M_CancellationToken(cancellation_token::none()),
          _M_ContinuationContext(task_continuation_context::use_default()),
          _M_HasCancellationToken(false),
          _M_HasScheduler(true)
    {
    }

    
    task_options(scheduler_ptr _Scheduler)
        : _M_Scheduler(::std::move(_Scheduler)),
          _M_CancellationToken(cancellation_token::none()),
          _M_ContinuationContext(task_continuation_context::use_default()),
          _M_HasCancellationToken(false),
          _M_HasScheduler(true)
    {
    }

    
    task_options(const task_options& _TaskOptions)
        : _M_Scheduler(_TaskOptions.get_scheduler()),
          _M_CancellationToken(_TaskOptions.get_cancellation_token()),
          _M_ContinuationContext(_TaskOptions.get_continuation_context()),
          _M_HasCancellationToken(_TaskOptions.has_cancellation_token()),
          _M_HasScheduler(_TaskOptions.has_scheduler())
    {
    }

    
    void set_cancellation_token(cancellation_token _Token)
    {
        _M_CancellationToken = _Token;
       _M_HasCancellationToken = true;
    }

    
    void set_continuation_context(task_continuation_context _ContinuationContext)
    {
        _M_ContinuationContext = _ContinuationContext;
    }

    
    bool has_cancellation_token() const
    {
        return _M_HasCancellationToken;
    }

    
    cancellation_token get_cancellation_token() const
    {
        return _M_CancellationToken;
    }

    
    task_continuation_context get_continuation_context() const
    {
        return _M_ContinuationContext;
    }

    
    bool has_scheduler() const
    {
        return _M_HasScheduler;
    }

    
    scheduler_ptr get_scheduler() const
    {
        return _M_Scheduler;
    }

private:

    task_options const& operator=(task_options const& _Right);
    friend details::_Internal_task_options &details::_get_internal_task_options(task_options &);
    friend const details::_Internal_task_options &details::_get_internal_task_options(const task_options &);

    scheduler_ptr _M_Scheduler;
    cancellation_token _M_CancellationToken;
    task_continuation_context _M_ContinuationContext;
    details::_Internal_task_options _M_InternalTaskOptions;
    bool _M_HasCancellationToken;
    bool _M_HasScheduler;
};

namespace details
{

    
    struct _ThenImplOptions
    {
        _ThenImplOptions(_CancellationTokenState *_Token_state, const task_continuation_context* _Continuation_context,
            scheduler_ptr _PScheduler, _TaskCreationCallstack _Creation_stack, _TaskInliningMode_t _Inlining_mode = _NoInline) :
            _PTokenState(_Token_state), _Scheduler(_PScheduler), _CreationStack(_Creation_stack), _InliningMode(_Inlining_mode),
            _PContinuationContext(const_cast<task_continuation_context*>(_Continuation_context)) {}

        _CancellationTokenState *_PTokenState;
        scheduler_ptr _Scheduler;
        _TaskCreationCallstack _CreationStack;
        _TaskInliningMode_t _InliningMode;
        task_continuation_context* _PContinuationContext;

        static _ThenImplOptions _CreateOptions(const task_options& _Task_Options, const task_continuation_context& _ContinuationContext,
            const scheduler_ptr& impl_scheduler)
        {
            _CancellationTokenState *_TokenState = _Task_Options.has_cancellation_token() ?
                _Task_Options.get_cancellation_token()._GetImplValue() : nullptr;
            auto _Scheduler = _Task_Options.has_scheduler() ? _Task_Options.get_scheduler() : impl_scheduler;
            auto _InliningMode = _Task_Options.get_continuation_context()._ForceInline() ? details::_ForceInline : details::_NoInline;

            auto _Task_Options_Int = details::_get_internal_task_options(_Task_Options);
            auto _CreationStack = _Task_Options_Int._M_hasPresetCreationCallstack ?
                _Task_Options_Int._M_presetCreationCallstack : details::_TaskCreationCallstack();

            return _ThenImplOptions(_TokenState, &_ContinuationContext, _Scheduler, _CreationStack,_InliningMode);
        }
    };

    inline _Internal_task_options & _get_internal_task_options(task_options &_Options)
    {
        return _Options._M_InternalTaskOptions;
    }
    inline const _Internal_task_options & _get_internal_task_options(const task_options &_Options)
    {
        return _Options._M_InternalTaskOptions;
    }

    struct _Task_impl_base;
    template<typename _ReturnType> struct _Task_impl;

    template<typename _ReturnType>
    struct _Task_ptr
    {
        typedef ::std::shared_ptr<_Task_impl<_ReturnType>> _Type;
        static _Type _Make(_CancellationTokenState * _Ct, scheduler_ptr _Scheduler_arg) { return ::std::make_shared<_Task_impl<_ReturnType>>(_Ct, _Scheduler_arg); }
    };

    typedef _TaskCollection_t::_TaskProcHandle_t _UnrealizedChore_t;
    typedef ::std::shared_ptr<_Task_impl_base> _Task_ptr_base;

    
    struct _ContinuationTaskHandleBase : _UnrealizedChore_t
    {
        _ContinuationTaskHandleBase * _M_next;
        task_continuation_context _M_continuationContext;
        bool _M_isTaskBasedContinuation;

        
        _TaskInliningMode_t _M_inliningMode;

        virtual _Task_ptr_base _GetTaskImplBase() const = 0;

        _ContinuationTaskHandleBase() :
            _M_next(nullptr), _M_continuationContext(task_continuation_context::use_default()), _M_isTaskBasedContinuation(false), _M_inliningMode(details::_NoInline)
        {
        }

        virtual ~_ContinuationTaskHandleBase() {}
    };


    struct _TaskEventLogger
    {
        _Task_impl_base *_M_task;
        bool _M_scheduled;
        bool _M_taskPostEventStarted;

        
         void __thiscall _LogScheduleTask(bool _isContinuation);

        
         void __thiscall _LogCancelTask();

        
         void __thiscall _LogTaskCompleted();

        
        void _LogTaskExecutionStarted() { }

        
         void __thiscall _LogTaskExecutionCompleted();

        
         void __thiscall _LogWorkItemStarted();

        
         void __thiscall _LogWorkItemCompleted();

        _TaskEventLogger(_Task_impl_base *_task): _M_task(_task)
        {
            _M_scheduled = false;
            _M_taskPostEventStarted = false;
        }
    };

    
    struct _TaskWorkItemRAIILogger
    {
        _TaskEventLogger &_M_logger;
        _TaskWorkItemRAIILogger(_TaskEventLogger &_taskHandleLogger): _M_logger(_taskHandleLogger)
        {
            _M_logger._LogWorkItemStarted();
        }

        ~_TaskWorkItemRAIILogger()
        {
            _M_logger._LogWorkItemCompleted();
        }
        _TaskWorkItemRAIILogger &operator =(const _TaskWorkItemRAIILogger &); 
    };


#line 1425 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"

    
    template<typename _ReturnType, typename _DerivedTaskHandle, typename _BaseTaskHandle>
    struct _PPLTaskHandle : _BaseTaskHandle
    {
        _PPLTaskHandle(const typename _Task_ptr<_ReturnType>::_Type & _PTask) : _M_pTask(_PTask)
        {
        }

        virtual ~_PPLTaskHandle()
        {
            
            _M_pTask->_M_taskEventLogger._LogTaskCompleted();
        }

        virtual void invoke() const
        {
            
            
            ((void)0);
            if (!_M_pTask->_TransitionedToStarted())
            {
                static_cast<const _DerivedTaskHandle *>(this)->_SyncCancelAndPropagateException();
                return;
            }

            _M_pTask->_M_taskEventLogger._LogTaskExecutionStarted();

            try {
            
            static_cast<const _DerivedTaskHandle *>(this)->_Perform();
            } catch (const task_canceled &) {
            _M_pTask->_Cancel(true);
            } catch (const _Interruption_exception &) {
            _M_pTask->_Cancel(true);
            } catch (...) {
            _M_pTask->_CancelWithException(::std::current_exception());
            }
            _M_pTask->_M_taskEventLogger._LogTaskExecutionCompleted();
        }

        
        _Task_ptr_base _GetTaskImplBase() const
        {
            return _M_pTask;
        }

        typename _Task_ptr<_ReturnType>::_Type _M_pTask;
    private:
        _PPLTaskHandle const & operator=(_PPLTaskHandle const&);    
    };

    
    struct _Task_impl_base
    {
        enum _TaskInternalState
        {
            
            _Created,
            _Started,
            _PendingCancel,
            _Completed,
            _Canceled
        };

        _Task_impl_base(_CancellationTokenState * _PTokenState, scheduler_ptr _Scheduler_arg)
                          : _M_TaskState(_Created),
                            _M_fFromAsync(false), _M_fUnwrappedTask(false),
                            _M_Continuations(nullptr), _M_pRegistration(nullptr), _M_TaskCollection(_Scheduler_arg),
                            _M_taskEventLogger(this)
        {
            
            _M_pTokenState = _PTokenState;
            ((void)0);
            if (_M_pTokenState != _CancellationTokenState::_None())
                _M_pTokenState->_Reference();
        }

        virtual ~_Task_impl_base()
        {
            ((void)0);
            if (_M_pTokenState != _CancellationTokenState::_None())
            {
                _M_pTokenState->_Release();
            }
        }

        task_status _Wait()
        {
            bool _DoWait = true;


#line 1556 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"

            if (_DoWait)
            {
                
                
                if (_M_fFromAsync)
                {
                    _M_TaskCollection._Wait();
                }
                else
                {
                    
                    
                    try {
                    
                    
                    _M_TaskCollection._RunAndWait();
                    } catch (details::_Interruption_exception&) {
                    
                    ((void)0);
                    } catch (task_canceled&) {
                    
                    
                    ((void)0);
                    } catch (...) {
                    
                    if(!_HasUserException())
                    {
                        _CancelWithException(::std::current_exception());
                    }
                    
                    _M_exceptionHolder->_RethrowUserException();
                    }

                    
                    if (_M_fUnwrappedTask)
                    {
                        _M_TaskCollection._Wait();
                    }
                }
            }

            if (_HasUserException())
            {
                _M_exceptionHolder->_RethrowUserException();
            }
            else if (_IsCanceled())
            {
                return canceled;
            }
            ((void)0);
            return completed;
        }

        
        virtual bool _CancelAndRunContinuations(bool _SynchronousCancel, bool _UserException, bool _PropagatedFromAncestor, const ::std::shared_ptr<_ExceptionHolder>& _ExHolder) = 0;

        bool _Cancel(bool _SynchronousCancel)
        {
            
            return _CancelAndRunContinuations(_SynchronousCancel, false, false, _M_exceptionHolder);
        }

        bool _CancelWithExceptionHolder(const ::std::shared_ptr<_ExceptionHolder>& _ExHolder, bool _PropagatedFromAncestor)
        {
            
            return _CancelAndRunContinuations(true, true, _PropagatedFromAncestor, _ExHolder);
        }

        bool _CancelWithException(const ::std::exception_ptr& _Exception)
        {
            
            ((void)0);
            return _CancelAndRunContinuations(true, true, false, ::std::make_shared<_ExceptionHolder>(_Exception, _GetTaskCreationCallstack()));
        }

        void _RegisterCancellation(::std::weak_ptr<_Task_impl_base> _WeakPtr)
        {
            ((void)0);

            auto _CancellationCallback = [_WeakPtr](){
                
                
                auto _task = _WeakPtr.lock();
                if (_task != nullptr)
                    _task->_Cancel(false);
            };

            _M_pRegistration = new details::_CancellationTokenCallback<decltype(_CancellationCallback)>(_CancellationCallback);
            _M_pTokenState->_RegisterCallback(_M_pRegistration);
        }

        void _DeregisterCancellation()
        {
            if (_M_pRegistration != nullptr)
            {
                _M_pTokenState->_DeregisterCallback(_M_pRegistration);
                _M_pRegistration->_Release();
                _M_pRegistration = nullptr;
            }
        }

        bool _IsCreated()
        {
            return (_M_TaskState == _Created);
        }

        bool _IsStarted()
        {
            return (_M_TaskState == _Started);
        }

        bool _IsPendingCancel()
        {
            return (_M_TaskState == _PendingCancel);
        }

        bool _IsCompleted()
        {
            return (_M_TaskState == _Completed);
        }

        bool _IsCanceled()
        {
            return (_M_TaskState == _Canceled);
        }

        bool _HasUserException()
        {
            return static_cast<bool>(_M_exceptionHolder);
        }

        const ::std::shared_ptr<_ExceptionHolder>& _GetExceptionHolder()
        {
            ((void)0);
            return _M_exceptionHolder;
        }

        bool _IsApartmentAware()
        {
            return _M_fFromAsync;
        }

        void _SetAsync(bool _Async = true)
        {
            _M_fFromAsync = _Async;
        }

        _TaskCreationCallstack _GetTaskCreationCallstack()
        {
            return _M_pTaskCreationCallstack;
        }

        void _SetTaskCreationCallstack(const _TaskCreationCallstack &_Callstack)
        {
            _M_pTaskCreationCallstack = _Callstack;
        }

        
        void _ScheduleTask(_UnrealizedChore_t * _PTaskHandle, _TaskInliningMode_t _InliningMode)
        {
            try {
            _M_TaskCollection._ScheduleTask(_PTaskHandle, _InliningMode);
            } catch (const task_canceled &) {
            
            
            ((void)0);
            } catch (const _Interruption_exception &) {
            
            ((void)0);
            } catch (...) {
            
            
            if (!_HasUserException())
            {
                _CancelWithException(::std::current_exception());
            }
            }
        }

        
        void _RunContinuation(_ContinuationTaskHandleBase * _PTaskHandle)
        {
            _Task_ptr_base _ImplBase = _PTaskHandle->_GetTaskImplBase();
            if (_IsCanceled() && !_PTaskHandle->_M_isTaskBasedContinuation)
            {
                if (_HasUserException())
                {
                    
                    
                    _ImplBase->_CancelWithExceptionHolder(_GetExceptionHolder(), true);
                }
                else
                {
                    
                    
                    _ImplBase->_Cancel(true);
                }
            }
            else
            {
                
                
                ((void)0);
                ((void)0);
                return _ImplBase->_ScheduleContinuationTask(_PTaskHandle);
            }

            
            delete _PTaskHandle;
        }

        
        void _ScheduleContinuationTask(_ContinuationTaskHandleBase * _PTaskHandle)
        {

            _M_taskEventLogger._LogScheduleTask(true);
            
            if (_PTaskHandle->_M_continuationContext._HasCapturedContext())
            {
                
                
                if (_PTaskHandle->_M_inliningMode != details::_ForceInline)
                {
                    _PTaskHandle->_M_inliningMode = details::_DefaultAutoInline;
                }
                _ScheduleFuncWithAutoInline([_PTaskHandle]() {
                    
                    
                    auto _TaskImplPtr = _PTaskHandle->_GetTaskImplBase();
                    if (details::_ContextCallback::_CaptureCurrent() == _PTaskHandle->_M_continuationContext)
                    {
                        _TaskImplPtr->_ScheduleTask(_PTaskHandle, details::_ForceInline);
                    }
                    else
                    {
                        
                        
                        try {
                        _PTaskHandle->_M_continuationContext._CallInContext( [_PTaskHandle, _TaskImplPtr](){
                            _TaskImplPtr->_ScheduleTask(_PTaskHandle, details::_ForceInline);
                        });
                        } catch (...) {
                        _TaskImplPtr->_CancelWithException(::std::current_exception());
                        }
                    }
                }, _PTaskHandle->_M_inliningMode);
            }
            else
            {
                _ScheduleTask(_PTaskHandle, _PTaskHandle->_M_inliningMode);
            }
        }

        
        void _ScheduleContinuation(_ContinuationTaskHandleBase * _PTaskHandle)
        {
            enum { _Nothing, _Schedule, _Cancel, _CancelWithException } _Do = _Nothing;

            
            {
                ::std::lock_guard<::std::mutex> _LockHolder(_M_ContinuationsCritSec);
                if (_IsCompleted() || (_IsCanceled() && _PTaskHandle->_M_isTaskBasedContinuation))
                {
                    _Do = _Schedule;
                }
                else if (_IsCanceled())
                {
                    if (_HasUserException())
                    {
                        _Do = _CancelWithException;
                    }
                    else
                    {
                        _Do = _Cancel;
                    }
                }
                else
                {
                    
                    _PTaskHandle->_M_next = _M_Continuations;
                    _M_Continuations = _PTaskHandle;
                }
            }

            
            switch (_Do)
            {
                case _Schedule:
                {
                    _PTaskHandle->_GetTaskImplBase()->_ScheduleContinuationTask(_PTaskHandle);
                    break;
                }
                case _Cancel:
                {
                    
                    
                    _PTaskHandle->_GetTaskImplBase()->_Cancel(true);

                    delete _PTaskHandle;
                    break;
                }
                case _CancelWithException:
                {
                    
                    
                    _PTaskHandle->_GetTaskImplBase()->_CancelWithExceptionHolder(_GetExceptionHolder(), true);

                    delete _PTaskHandle;
                    break;
                }
                case _Nothing:
                default:
                    
                    
                    break;
            }
        }

        void _RunTaskContinuations()
        {
            
            
            _ContinuationList _Cur = _M_Continuations, _Next;
            _M_Continuations = nullptr;
            while (_Cur)
            {
                
                
                _Next = _Cur->_M_next;
                _RunContinuation(_Cur);
                _Cur = _Next;
            }
        }

         static bool __cdecl _IsNonBlockingThread();


#line 2021 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"

        template<typename _ReturnType, typename _InternalReturnType>
        static void _AsyncInit(const typename _Task_ptr<_ReturnType>::_Type& _OuterTask, const task<_InternalReturnType> & _UnwrappedTask)
        {
            ((void)0);

            
            _UnwrappedTask._Then([_OuterTask] (task<_InternalReturnType> _AncestorTask) {

                if (_AncestorTask._GetImpl()->_IsCompleted())
                {
                    _OuterTask->_FinalizeAndRunContinuations(_AncestorTask._GetImpl()->_GetResult());
                }
                else
                {
                    ((void)0);
                    if (_AncestorTask._GetImpl()->_HasUserException())
                    {
                        
                        
                        _OuterTask->_CancelWithExceptionHolder(_AncestorTask._GetImpl()->_GetExceptionHolder(), false);
                    }
                    else
                    {
                        _OuterTask->_Cancel(true);
                    }
                }
            }, nullptr, details::_DefaultAutoInline);

        }

        scheduler_ptr _GetScheduler() const
        {
            return _M_TaskCollection._GetScheduler();
        }

        
        volatile _TaskInternalState _M_TaskState;
        
        
        bool _M_fFromAsync;
        
        bool _M_fUnwrappedTask;

        
        ::std::shared_ptr<_ExceptionHolder> _M_exceptionHolder;

        typedef _ContinuationTaskHandleBase * _ContinuationList;

        ::std::mutex _M_ContinuationsCritSec;
        _ContinuationList _M_Continuations;

        
        _CancellationTokenState * _M_pTokenState;

        
        _CancellationTokenRegistration * _M_pRegistration;

        
        ::Concurrency::details::_TaskCollection_t _M_TaskCollection;

        
        _TaskCreationCallstack _M_pTaskCreationCallstack;

        _TaskEventLogger _M_taskEventLogger;
   private:
        
        _Task_impl_base(const _Task_impl_base&);
        _Task_impl_base const & operator=(_Task_impl_base const&);
    };

    
    template<typename _ReturnType>
    struct _Task_impl : public _Task_impl_base
    {
        _Task_impl(_CancellationTokenState * _Ct, scheduler_ptr _Scheduler_arg)
            : _Task_impl_base(_Ct, _Scheduler_arg)
        {
        }

        virtual ~_Task_impl()
        {
            
            
            _DeregisterCancellation();
        }

        virtual bool _CancelAndRunContinuations(bool _SynchronousCancel, bool _UserException, bool _PropagatedFromAncestor, const ::std::shared_ptr<_ExceptionHolder> & _ExceptionHolder_arg) override
        {
            enum { _Nothing, _RunContinuations, _Cancel } _Do = _Nothing;
            {
                ::std::lock_guard<::std::mutex> _LockHolder(_M_ContinuationsCritSec);
                if (_UserException)
                {
                    ((void)0);
                    
                    ((void)0);

                    
                    ((void)0);

                    if (_M_TaskState == _Canceled)
                    {
                        
                        return false;
                    }
                    else
                    {
                        ((void)0);
                        _M_exceptionHolder = _ExceptionHolder_arg;
                    }
                }
                else
                {
                    
                    
                    if (_IsCompleted() || _IsCanceled() || (_IsPendingCancel() && !_SynchronousCancel))
                    {
                        ((void)0);
                        return false;
                    }
                    ((void)0);
                }

                if (_SynchronousCancel)
                {
                    
                    _M_TaskState = _Canceled;
                    
                    
                    _Do = _RunContinuations;
                }
                else
                {
                    ((void)0);

                    if (_IsStarted())
                    {
                        
                        _Do = _Cancel;
                    }

                    
                    _M_TaskState = _PendingCancel;

                    _M_taskEventLogger._LogCancelTask();
                }
            }

            switch (_Do)
            {
                case _Cancel:
                {
                    if (_M_InternalCancellation)
                    {
                        
                        _M_InternalCancellation();
                    }
                    _M_TaskCollection._Cancel();
                    break;
                }
                case _RunContinuations:
                {
                    
                    _M_TaskCollection._Complete();

                    if (_M_Continuations)
                    {
                        
                        _ScheduleFuncWithAutoInline([this](){ _RunTaskContinuations(); }, details::_DefaultAutoInline);
                    }

                    break;
                }
                case _Nothing:
                default:
                    break;
            }
            return true;
        }

        void _FinalizeAndRunContinuations(_ReturnType _Result)
        {
            _M_Result.Set(_Result);

            {
                
                
                ::std::lock_guard<::std::mutex> _LockHolder(_M_ContinuationsCritSec);

                
                ((void)0);
                if (_IsCanceled())
                {
                    return;
                }

                
                _M_TaskState = _Completed;
            }
            _M_TaskCollection._Complete();
            _RunTaskContinuations();
        }

        
        bool _TransitionedToStarted()
        {
            ::std::lock_guard<::std::mutex> _LockHolder(_M_ContinuationsCritSec);
            
            ((void)0);
            if (_IsPendingCancel())
                return false;

            ((void)0);
            _M_TaskState = _Started;
            return true;
        }


#line 2289 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"

        
        bool _IsDone()
        {
            return _IsCompleted() || _IsCanceled();
        }

        _ReturnType _GetResult()
        {
            return _M_Result.Get();
        }

        _ResultHolder<_ReturnType> _M_Result;        
        ::std::function<void()>    _M_InternalCancellation;
    };

    template<typename _ResultType>
    struct _Task_completion_event_impl
    {
    private:
        _Task_completion_event_impl(const _Task_completion_event_impl&);
        _Task_completion_event_impl& operator=(const _Task_completion_event_impl&);

    public:

        typedef ::std::vector<typename _Task_ptr<_ResultType>::_Type> _TaskList;

        _Task_completion_event_impl() :
            _M_fHasValue(false), _M_fIsCanceled(false)
        {
        }

        bool _HasUserException()
        {
            return _M_exceptionHolder != nullptr;
        }

        ~_Task_completion_event_impl()
        {
            for( auto _TaskIt = _M_tasks.begin(); _TaskIt != _M_tasks.end(); ++_TaskIt )
            {
                ((void)0);
                
                (*_TaskIt)->_Cancel(true);
            }
        }

        
        _TaskList                           _M_tasks;
        ::std::mutex                        _M_taskListCritSec;
        _ResultHolder<_ResultType>          _M_value;
        ::std::shared_ptr<_ExceptionHolder> _M_exceptionHolder;
        bool                                _M_fHasValue;
        bool                                _M_fIsCanceled;
    };

    
    inline ::std::function<_Unit_type()> _MakeVoidToUnitFunc(const ::std::function<void()>& _Func)
    {
        return [=]() -> _Unit_type { _Func(); return _Unit_type(); };
    }

    template <typename _Type>
    ::std::function<_Type(_Unit_type)> _MakeUnitToTFunc(const ::std::function<_Type()>& _Func)
    {
        return [=](_Unit_type) -> _Type { return _Func(); };
    }

    template <typename _Type>
    ::std::function<_Unit_type(_Type)> _MakeTToUnitFunc(const ::std::function<void(_Type)>& _Func)
    {
        return [=](_Type _Obj) -> _Unit_type { _Func(_Obj); return _Unit_type(); };
    }

    inline ::std::function<_Unit_type(_Unit_type)> _MakeUnitToUnitFunc(const ::std::function<void()>& _Func)
    {
        return [=](_Unit_type) -> _Unit_type { _Func(); return _Unit_type(); };
    }
} 


template<typename _ResultType>
class task_completion_event
{
public:
    
    
    task_completion_event()
        : _M_Impl(::std::make_shared<details::_Task_completion_event_impl<_ResultType>>())
    {
    }

    
    bool set(_ResultType _Result) const 
    {
        
        if (_IsTriggered())
        {
            return false;
        }

        _TaskList _Tasks;
        bool _RunContinuations = false;
        {
            ::std::lock_guard<::std::mutex> _LockHolder(_M_Impl->_M_taskListCritSec);

            if (!_IsTriggered())
            {
                _M_Impl->_M_value.Set(_Result);
                _M_Impl->_M_fHasValue = true;

                _Tasks.swap(_M_Impl->_M_tasks);
                _RunContinuations = true;
            }
        }

        if (_RunContinuations)
        {
            for( auto _TaskIt = _Tasks.begin(); _TaskIt != _Tasks.end(); ++_TaskIt )
            {
                
                if ((*_TaskIt)->_IsPendingCancel())
                    (*_TaskIt)->_Cancel(true);
                else
                {
                    
                    
                    (*_TaskIt)->_FinalizeAndRunContinuations(_M_Impl->_M_value.Get());
                }
            }

            return true;
        }

        return false;
    }

    template<typename _E>
    __declspec(noinline) 
    bool set_exception(_E _Except) const 
    {
        
        return _Cancel(::std::make_exception_ptr(_Except), ::Concurrency::details::_TaskCreationCallstack::_CaptureSingleFrameCallstack(_ReturnAddress()));
    }

    
    __declspec(noinline) 
    bool set_exception(::std::exception_ptr _ExceptionPtr) const 
    {
        
        return _Cancel(_ExceptionPtr, ::Concurrency::details::_TaskCreationCallstack::_CaptureSingleFrameCallstack(_ReturnAddress()));
    }

    
    bool _Cancel() const
    {
        
        return _CancelInternal();
    }

    
    template<typename _ExHolderType>
    bool _Cancel(_ExHolderType _ExHolder, const details::_TaskCreationCallstack &_SetExceptionAddressHint = details::_TaskCreationCallstack ()) const
    {
        bool _Canceled;
        if(_StoreException(_ExHolder, _SetExceptionAddressHint))
        {
            _Canceled = _CancelInternal();
            ((void)0);
        }
        else
        {
            _Canceled = false;
        }
        return _Canceled;
    }

    
    template<typename _ExHolderType>
    bool _StoreException(_ExHolderType _ExHolder, const details::_TaskCreationCallstack &_SetExceptionAddressHint = details::_TaskCreationCallstack ()) const
    {
        ::std::lock_guard<::std::mutex> _LockHolder(_M_Impl->_M_taskListCritSec);
        if (!_IsTriggered() && !_M_Impl->_HasUserException())
        {
            
            
            _M_Impl->_M_exceptionHolder = _ToExceptionHolder(_ExHolder, _SetExceptionAddressHint);
            return true;
        }
        return false;
    }
    
    
    void _ClearStoredException() const
    {
        ::std::lock_guard<::std::mutex> _LockHolder(_M_Impl->_M_taskListCritSec);
        if (_M_Impl->_M_exceptionHolder)
        {
            details::atomic_exchange(_M_Impl->_M_exceptionHolder->_M_exceptionObserved, 1l);
            _M_Impl->_M_exceptionHolder.reset();
        }
    }

    
    bool _IsTriggered() const
    {
        return _M_Impl->_M_fHasValue || _M_Impl->_M_fIsCanceled;
    }

private:

    static ::std::shared_ptr<details::_ExceptionHolder> _ToExceptionHolder(const ::std::shared_ptr<details::_ExceptionHolder>& _ExHolder, const details::_TaskCreationCallstack&)
    {
        return _ExHolder;
    }

    static ::std::shared_ptr<details::_ExceptionHolder> _ToExceptionHolder(::std::exception_ptr _ExceptionPtr, const details::_TaskCreationCallstack &_SetExceptionAddressHint)
    {
        return ::std::make_shared<details::_ExceptionHolder>(_ExceptionPtr, _SetExceptionAddressHint);
    }


    template <typename _Ty> friend class task; 
    template <typename _Ty> friend class task_completion_event;

    typedef typename details::_Task_completion_event_impl<_ResultType>::_TaskList _TaskList;

    
    bool _CancelInternal() const
    {
        
        
        ((void)0);
        if (_M_Impl->_M_fIsCanceled)
        {
            return false;
        }

        _TaskList _Tasks;
        bool _Cancel = false;
        {
            ::std::lock_guard<::std::mutex> _LockHolder(_M_Impl->_M_taskListCritSec);
            ((void)0);
            if (!_M_Impl->_M_fIsCanceled)
            {
                _M_Impl->_M_fIsCanceled = true;
                _Tasks.swap(_M_Impl->_M_tasks);
                _Cancel = true;
            }
        }

        const bool _UserException = _M_Impl->_HasUserException();

        if (_Cancel)
        {
            for( auto _TaskIt = _Tasks.begin(); _TaskIt != _Tasks.end(); ++_TaskIt )
            {
                
                if (_UserException)
                {
                    (*_TaskIt)->_CancelWithExceptionHolder(_M_Impl->_M_exceptionHolder, true);
                }
                else
                {
                    (*_TaskIt)->_Cancel(true);
                }
            }
        }
        return _Cancel;
    }

    
    void _RegisterTask(const typename details::_Task_ptr<_ResultType>::_Type & _TaskParam)
    {
        enum { _Nothing, _Trigger, _Cancel } _Action = _Nothing;
        {
            ::std::lock_guard<::std::mutex> _LockHolder(_M_Impl->_M_taskListCritSec);

            
            if (_M_Impl->_HasUserException())
            {
                _Action = _Cancel;
            }
            else if (_M_Impl->_M_fHasValue)
            {
                _Action = _Trigger;
            }
            else
            {
                _M_Impl->_M_tasks.push_back(_TaskParam);
            }
        }

        switch (_Action)
        {
        case _Trigger:
            _TaskParam->_FinalizeAndRunContinuations(_M_Impl->_M_value.Get());
            break;
        case _Cancel:
            _TaskParam->_CancelWithExceptionHolder(_M_Impl->_M_exceptionHolder, true);
            break;
        case _Nothing:
        default:
            break;
        }
    }

    ::std::shared_ptr<details::_Task_completion_event_impl<_ResultType>> _M_Impl;
};


template<>
class task_completion_event<void>
{
public:
    
    
    bool set() const 
    {
        return _M_unitEvent.set(details::_Unit_type());
    }

    template<typename _E>
    __declspec(noinline) 
    bool set_exception(_E _Except) const 
    {
        return _M_unitEvent._Cancel(::std::make_exception_ptr(_Except), ::Concurrency::details::_TaskCreationCallstack::_CaptureSingleFrameCallstack(_ReturnAddress()));
    }

    
    __declspec(noinline) 
    bool set_exception(::std::exception_ptr _ExceptionPtr) const 
    {
        
        return _M_unitEvent._Cancel(_ExceptionPtr, ::Concurrency::details::_TaskCreationCallstack::_CaptureSingleFrameCallstack(_ReturnAddress()));
    }

    
    void _Cancel() const 
    {
        _M_unitEvent._Cancel();
    }

    
    void _Cancel(const ::std::shared_ptr<details::_ExceptionHolder>& _ExHolder) const
    {
        _M_unitEvent._Cancel(_ExHolder);
    }

    
    bool _StoreException(const ::std::shared_ptr<details::_ExceptionHolder>& _ExHolder) const
    {
        return _M_unitEvent._StoreException(_ExHolder);
    }

    
    void _ClearStoredException() const
    {
        _M_unitEvent._ClearStoredException();
    }

    
    bool _IsTriggered() const
    {
        return _M_unitEvent._IsTriggered();
    }

private:
    template <typename _Ty> friend class task; 

    
    void _RegisterTask(details::_Task_ptr<details::_Unit_type>::_Type _TaskParam)
    {
        _M_unitEvent._RegisterTask(_TaskParam);
    }

    
    task_completion_event<details::_Unit_type> _M_unitEvent;
};

namespace details
{
    
    
    template<typename _ReturnType, typename _Ty>
    auto _IsValidTaskCtor(_Ty _Param, int,int,int,int) -> decltype(_Param(), ::std::true_type());


#line 2793 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"

    
    template<typename _ReturnType, typename _Ty>
    auto _IsValidTaskCtor(_Ty _Param, int, int, ...) -> decltype(_Param.set(details::declval<_ReturnType>()), ::std::true_type());

    template<typename _ReturnType, typename _Ty>
    auto _IsValidTaskCtor(_Ty _Param, int, ...) -> decltype(_Param.set(), ::std::true_type());

    
    template<typename _ReturnType, typename _Ty>
    ::std::false_type _IsValidTaskCtor(_Ty _Param, ...);

    template<typename _ReturnType, typename _Ty>
    void _ValidateTaskConstructorArgs(const _Ty& _Param)
    {
        static_assert(::std::is_same_v<decltype(_IsValidTaskCtor<_ReturnType, _Ty>(_Param,0,0,0,0)), ::std::true_type>,


#line 2812 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"
            "incorrect argument for task constructor; must be either a callable object or a task_completion_event"
#line 2814 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"
            );


#line 2819 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"
    }

    class _ProgressReporterCtorArgType{};


#line 2846 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"
}


template<typename _InpType, typename _OutType>
class _Continuation_func_transformer
{
public:
    static auto _Perform(::std::function<_OutType(_InpType)> _Func) -> decltype(_Func)
    {
        return _Func;
    }
};

template<typename _OutType>
class _Continuation_func_transformer<void, _OutType>
{
public:
    static auto _Perform(::std::function<_OutType()> _Func) -> decltype(details::_MakeUnitToTFunc<_OutType>(_Func))
    {
        return details::_MakeUnitToTFunc<_OutType>(_Func);
    }
};

template<typename _InType>
class _Continuation_func_transformer<_InType, void>
{
public:
    static auto _Perform(::std::function<void(_InType)> _Func) -> decltype(details::_MakeTToUnitFunc<_InType>(_Func))
    {
        return details::_MakeTToUnitFunc<_InType>(_Func);
    }
};

template<>
class _Continuation_func_transformer<void, void>
{
public:
    static auto _Perform(::std::function<void()> _Func) -> decltype(details::_MakeUnitToUnitFunc(_Func))
    {
        return details::_MakeUnitToUnitFunc(_Func);
    }
};


template<typename _RetType>
class _Init_func_transformer
{
public:
    static auto _Perform(::std::function<_RetType()> _Func) -> decltype(_Func)
    {
        return _Func;
    }
};

template<>
class _Init_func_transformer<void>
{
public:
    static auto _Perform(::std::function<void()> _Func) -> decltype(details::_MakeVoidToUnitFunc(_Func))
    {
        return details::_MakeVoidToUnitFunc(_Func);
    }
};


template<typename _ReturnType>
class task
{
public:
    
    
    typedef _ReturnType result_type;

    
    task() : _M_Impl(nullptr)
    {
        
        
    }

    
    template<typename _Ty>
    __declspec(noinline) 
    explicit task(_Ty _Param)
    {
        task_options _TaskOptions;
        details::_ValidateTaskConstructorArgs<_ReturnType,_Ty>(_Param);

        _CreateImpl(_TaskOptions.get_cancellation_token()._GetImplValue(), _TaskOptions.get_scheduler());
        
        _SetTaskCreationCallstack(::Concurrency::details::_TaskCreationCallstack::_CaptureSingleFrameCallstack(_ReturnAddress()));

        _TaskInitMaybeFunctor(_Param, decltype(details::_IsCallable(_Param,0))());
    }

    
    template<typename _Ty>
    __declspec(noinline) 
    explicit task(_Ty _Param, const task_options &_TaskOptions)
    {
        details::_ValidateTaskConstructorArgs<_ReturnType,_Ty>(_Param);

        _CreateImpl(_TaskOptions.get_cancellation_token()._GetImplValue(), _TaskOptions.get_scheduler());
        
        _SetTaskCreationCallstack(details::_get_internal_task_options(_TaskOptions)._M_hasPresetCreationCallstack ? details::_get_internal_task_options(_TaskOptions)._M_presetCreationCallstack : ::Concurrency::details::_TaskCreationCallstack::_CaptureSingleFrameCallstack(_ReturnAddress()));

        _TaskInitMaybeFunctor(_Param, decltype(details::_IsCallable(_Param,0))());
    }

    
    task(const task& _Other): _M_Impl(_Other._M_Impl) {}

    
    task(task&& _Other): _M_Impl(::std::move(_Other._M_Impl)) {}

    
    task& operator=(const task& _Other)
    {
        if (this != &_Other)
        {
            _M_Impl = _Other._M_Impl;
        }
        return *this;
    }

    
    task& operator=(task&& _Other)
    {
        if (this != &_Other)
        {
            _M_Impl = ::std::move(_Other._M_Impl);
        }
        return *this;
    }

    
    template<typename _Function>
    __declspec(noinline) 
    auto then(const _Function& _Func) const -> typename details::_ContinuationTypeTraits<_Function, _ReturnType>::_TaskOfType
    {
        task_options _TaskOptions;
        details::_get_internal_task_options(_TaskOptions)._set_creation_callstack(::Concurrency::details::_TaskCreationCallstack::_CaptureSingleFrameCallstack(_ReturnAddress()));

        
        auto _ContinuationContext = _TaskOptions.get_continuation_context();
        auto _Options = details::_ThenImplOptions::_CreateOptions(_TaskOptions, _ContinuationContext, _ThenGetImpl()->_GetScheduler());


        return _ThenImpl<_ReturnType>(typename details::_ContinuationTypeTraits<_Function, _ReturnType>::_StdFuncT(_Func), _Options);


#line 3192 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"
    }

    
    template<typename _Function>
    __declspec(noinline) 
    auto then(const _Function& _Func, task_options _TaskOptions) const -> typename details::_ContinuationTypeTraits<_Function, _ReturnType>::_TaskOfType
    {
        details::_get_internal_task_options(_TaskOptions)._set_creation_callstack(::Concurrency::details::_TaskCreationCallstack::_CaptureSingleFrameCallstack(_ReturnAddress()));

        
        auto _ContinuationContext = _TaskOptions.get_continuation_context();
        auto _Options = details::_ThenImplOptions::_CreateOptions(_TaskOptions, _ContinuationContext, _ThenGetImpl()->_GetScheduler());


        return _ThenImpl<_ReturnType>(typename details::_ContinuationTypeTraits<_Function, _ReturnType>::_StdFuncT(_Func), _Options);


#line 3234 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"
    }

    
    template<typename _Function>
    __declspec(noinline) 
    auto then(const _Function& _Func, cancellation_token _CancellationToken, task_continuation_context _ContinuationContext) const -> typename details::_ContinuationTypeTraits<_Function, _ReturnType>::_TaskOfType
    {

        task_options _TaskOptions(_CancellationToken, _ContinuationContext);
        details::_get_internal_task_options(_TaskOptions)._set_creation_callstack(::Concurrency::details::_TaskCreationCallstack::_CaptureSingleFrameCallstack(_ReturnAddress()));

        auto _Options = details::_ThenImplOptions::_CreateOptions(_TaskOptions, _ContinuationContext, _ThenGetImpl()->_GetScheduler());


        return _ThenImpl<_ReturnType>(typename details::_ContinuationTypeTraits<_Function, _ReturnType>::_StdFuncT(_Func), _Options);


#line 3279 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"
    }

    
    task_status wait() const
    {
        if (!_M_Impl)
        {
            details::_DefaultTaskHelper::_NoCallOnDefaultTask_ErrorImpl();
        }

        return _M_Impl->_Wait();
    }

    
    _ReturnType get() const
    {
        if (!_M_Impl)
        {
            details::_DefaultTaskHelper::_NoCallOnDefaultTask_ErrorImpl();
        }

        if (_M_Impl->_Wait() == canceled)
        {
            throw task_canceled{};
        }

        return _M_Impl->_GetResult();
    }

    
    bool is_done() const
    {
        if (!_M_Impl)
        {
            details::_DefaultTaskHelper::_NoCallOnDefaultTask_ErrorImpl();
        }

        return _M_Impl->_IsDone();
    }

    
    scheduler_ptr scheduler() const
    {
        if (!_M_Impl)
        {
            details::_DefaultTaskHelper::_NoCallOnDefaultTask_ErrorImpl();
        }

        return _M_Impl->_GetScheduler();
    }

    
    bool is_apartment_aware() const
    {
        if (!_M_Impl)
        {
            details::_DefaultTaskHelper::_NoCallOnDefaultTask_ErrorImpl();
        }
        return _M_Impl->_IsApartmentAware();
    }

    
    bool operator==(const task<_ReturnType>& _Rhs) const
    {
        return (_M_Impl == _Rhs._M_Impl);
    }

    
    bool operator!=(const task<_ReturnType>& _Rhs) const
    {
        return !operator==(_Rhs);
    }

    
    void _CreateImpl(details::_CancellationTokenState * _Ct, scheduler_ptr _Scheduler)
    {
        ((void)0);
        _M_Impl = details::_Task_ptr<_ReturnType>::_Make(_Ct, _Scheduler);
        if (_Ct != details::_CancellationTokenState::_None())
        {
            _M_Impl->_RegisterCancellation(_M_Impl);
        }
    }

    
    const typename details::_Task_ptr<_ReturnType>::_Type & _GetImpl() const
    {
        return _M_Impl;
    }

    const typename details::_Task_ptr<_ReturnType>::_Type & _ThenGetImpl() const
    {
        if (!_M_Impl)
        {
            details::_DefaultTaskHelper::_NoCallOnDefaultTask_ErrorImpl();
        }

        return _M_Impl;
    }

    
    void _SetImpl(const typename details::_Task_ptr<_ReturnType>::_Type & _Impl)
    {
        ((void)0);
        _M_Impl = _Impl;
    }

    
    void _SetImpl(typename details::_Task_ptr<_ReturnType>::_Type && _Impl)
    {
        ((void)0);
        _M_Impl = ::std::move(_Impl);
    }

    
    void _SetAsync(bool _Async = true)
    {
        _GetImpl()->_SetAsync(_Async);
    }

    
    void _SetTaskCreationCallstack(const details::_TaskCreationCallstack &_callstack)
    {
        _GetImpl()->_SetTaskCreationCallstack(_callstack);
    }

    
    template<typename _Function>
    auto _Then(const _Function& _Func, details::_CancellationTokenState *_PTokenState,
        details::_TaskInliningMode_t _InliningMode = details::_ForceInline) const -> typename details::_ContinuationTypeTraits<_Function, _ReturnType>::_TaskOfType
    {
        
        auto _Scheduler = _GetImpl()->_GetScheduler();

        
        auto _Default_Context = task_continuation_context::use_default();
        details::_ThenImplOptions _Options (_PTokenState, &_Default_Context, _Scheduler, ::Concurrency::details::_TaskCreationCallstack::_CaptureSingleFrameCallstack(_ReturnAddress()), _InliningMode);


        return _ThenImpl<_ReturnType>(typename details::_ContinuationTypeTraits<_Function, _ReturnType>::_StdFuncT(_Func), _Options);


#line 3489 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"
    }

private:
    template <typename _Ty> friend class task;


    template <typename _InternalReturnType, typename _Function, typename _TypeSelection>
    struct _InitialTaskHandle :
        details::_PPLTaskHandle<_ReturnType, _InitialTaskHandle<_InternalReturnType, _Function, _TypeSelection>, details::_UnrealizedChore_t>
    {
        _Function _M_function;
        _InitialTaskHandle(const typename details::_Task_ptr<_ReturnType>::_Type & _TaskImpl, const _Function & _func)
            : details::_PPLTaskHandle<_ReturnType, _InitialTaskHandle<_InternalReturnType, _Function, _TypeSelection>, details::_UnrealizedChore_t>::_PPLTaskHandle(_TaskImpl)
            , _M_function(_func)
        {
        }

        virtual ~_InitialTaskHandle() {}

        template <typename _Func>
        auto _LogWorkItemAndInvokeUserLambda(_Func _func) const -> decltype(_func())
        {
            details::_TaskWorkItemRAIILogger _LogWorkItem(this->_M_pTask->_M_taskEventLogger);
            return _func();
        }

        void _Perform() const
        {
            _Init(_TypeSelection());
        }

        void _SyncCancelAndPropagateException() const
        {
            this->_M_pTask->_Cancel(true);
        }

        
        void _Init(details::_TypeSelectorNoAsync) const
        {
            this->_M_pTask->_FinalizeAndRunContinuations(_LogWorkItemAndInvokeUserLambda(_Init_func_transformer<_InternalReturnType>::_Perform(_M_function)));
        }

        
        void _Init(details::_TypeSelectorAsyncOperationOrTask) const
        {
            details::_Task_impl_base::_AsyncInit<_ReturnType, _InternalReturnType>(this->_M_pTask, _LogWorkItemAndInvokeUserLambda(_M_function));
        }


#line 3586 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"
    };


    template <typename _InternalReturnType, typename _ContinuationReturnType, typename _Function, typename _IsTaskBased, typename _TypeSelection>
    struct _ContinuationTaskHandle :
        details::_PPLTaskHandle<typename details::_NormalizeVoidToUnitType<_ContinuationReturnType>::_Type,
        _ContinuationTaskHandle<_InternalReturnType, _ContinuationReturnType, _Function, _IsTaskBased, _TypeSelection>, details::_ContinuationTaskHandleBase>
    {
        typedef typename details::_NormalizeVoidToUnitType<_ContinuationReturnType>::_Type _NormalizedContinuationReturnType;

        typename details::_Task_ptr<_ReturnType>::_Type _M_ancestorTaskImpl;
        _Function _M_function;

        _ContinuationTaskHandle(const typename details::_Task_ptr<_ReturnType>::_Type & _AncestorImpl,
            const typename details::_Task_ptr<_NormalizedContinuationReturnType>::_Type & _ContinuationImpl,
            const _Function & _Func, const task_continuation_context & _Context, details::_TaskInliningMode_t _InliningMode)
                : details::_PPLTaskHandle<typename details::_NormalizeVoidToUnitType<_ContinuationReturnType>::_Type,
                    _ContinuationTaskHandle<_InternalReturnType, _ContinuationReturnType, _Function, _IsTaskBased, _TypeSelection>, details::_ContinuationTaskHandleBase>
                    ::_PPLTaskHandle(_ContinuationImpl)
                , _M_ancestorTaskImpl(_AncestorImpl)
                , _M_function(_Func)
        {
            this->_M_isTaskBasedContinuation = _IsTaskBased::value;
            this->_M_continuationContext = _Context;
            this->_M_continuationContext._Resolve(_AncestorImpl->_IsApartmentAware());
            this->_M_inliningMode = _InliningMode;
        }

        virtual ~_ContinuationTaskHandle() {}

        template <typename _Func, typename _Arg>
        auto _LogWorkItemAndInvokeUserLambda(_Func && _func, _Arg && _value) const -> decltype(_func(::std::forward<_Arg>(_value)))
        {
            details::_TaskWorkItemRAIILogger _LogWorkItem(this->_M_pTask->_M_taskEventLogger);
            return _func(::std::forward<_Arg>(_value));
        }

        void _Perform() const
        {
            _Continue(_IsTaskBased(), _TypeSelection());
        }

        void _SyncCancelAndPropagateException() const
        {
            if (_M_ancestorTaskImpl->_HasUserException())
            {
                
                
                this->_M_pTask->_CancelWithExceptionHolder(_M_ancestorTaskImpl->_GetExceptionHolder(), true);
            }
            else
            {
                
                
                this->_M_pTask->_Cancel(true);
            }
        }

        
        void _Continue(::std::false_type, details::_TypeSelectorNoAsync) const
        {
            this->_M_pTask->_FinalizeAndRunContinuations(
                _LogWorkItemAndInvokeUserLambda(_Continuation_func_transformer<_InternalReturnType, _ContinuationReturnType>::_Perform(_M_function), _M_ancestorTaskImpl->_GetResult()));
        }

        
        void _Continue(::std::false_type, details::_TypeSelectorAsyncOperationOrTask) const
        {
            typedef typename details::_FunctionTypeTraits<_Function, _InternalReturnType>::_FuncRetType _FuncOutputType;

            details::_Task_impl_base::_AsyncInit<_NormalizedContinuationReturnType, _ContinuationReturnType>(
                this->_M_pTask,
                _LogWorkItemAndInvokeUserLambda(_Continuation_func_transformer<_InternalReturnType, _FuncOutputType>::_Perform(_M_function), _M_ancestorTaskImpl->_GetResult())
            );
        }


#line 3727 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"

        
        void _Continue(::std::true_type, details::_TypeSelectorNoAsync) const
        {
            typedef task<_InternalReturnType> _FuncInputType;
            task<_InternalReturnType> _ResultTask;
            _ResultTask._SetImpl(::std::move(_M_ancestorTaskImpl));
            this->_M_pTask->_FinalizeAndRunContinuations(
                _LogWorkItemAndInvokeUserLambda(_Continuation_func_transformer<_FuncInputType, _ContinuationReturnType>::_Perform(_M_function), ::std::move(_ResultTask)));
        }

        
        void _Continue(::std::true_type, details::_TypeSelectorAsyncOperationOrTask) const
        {
            
            task<_InternalReturnType> _ResultTask;
            _ResultTask._SetImpl(::std::move(_M_ancestorTaskImpl));
            details::_Task_impl_base::_AsyncInit<_NormalizedContinuationReturnType, _ContinuationReturnType>(this->_M_pTask,
                _LogWorkItemAndInvokeUserLambda(_M_function, ::std::move(_ResultTask)));
        }


#line 3817 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"
    };

    
    template<typename _InternalReturnType, typename _Function>
    void _TaskInitWithFunctor(const _Function& _Func)
    {
        typedef typename details::_InitFunctorTypeTraits<_InternalReturnType, decltype(::std::declval<_Function>()())> _Async_type_traits;

        _M_Impl->_M_fFromAsync = _Async_type_traits::_IsAsyncTask;
        _M_Impl->_M_fUnwrappedTask = _Async_type_traits::_IsUnwrappedTaskOrAsync;
        _M_Impl->_M_taskEventLogger._LogScheduleTask(false);
        _M_Impl->_ScheduleTask(new _InitialTaskHandle<_InternalReturnType, _Function, typename _Async_type_traits::_AsyncKind>(_GetImpl(), _Func), details::_NoInline);
    }

    
    void _TaskInitNoFunctor(task_completion_event<_ReturnType>& _Event)
    {
        _Event._RegisterTask(_M_Impl);
    }


#line 3870 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"

    
    template<typename _Function>
    void _TaskInitMaybeFunctor(_Function& _Func, ::std::true_type)
    {
        _TaskInitWithFunctor<_ReturnType, _Function>(_Func);
    }

    
    template<typename _Ty>
    void _TaskInitMaybeFunctor(_Ty& _Param, ::std::false_type)
    {
        _TaskInitNoFunctor(_Param);
    }

    
    template<typename _InternalReturnType, typename _Function>
    auto _ThenImpl(const _Function& _Func, details::_ThenImplOptions& _Options) const -> typename details::_ContinuationTypeTraits<_Function, _InternalReturnType>::_TaskOfType
    {

        typedef details::_FunctionTypeTraits<_Function, _InternalReturnType> _Function_type_traits;
        typedef details::_TaskTypeTraits<typename _Function_type_traits::_FuncRetType> _Async_type_traits;
        typedef typename _Async_type_traits::_TaskRetType _TaskType;

        
        if (_Options._PTokenState == nullptr)
        {
            if (_Function_type_traits::_Takes_task::value)
            {
                _Options._PTokenState = details::_CancellationTokenState::_None();
            }
            else
            {
                _Options._PTokenState = _GetImpl()->_M_pTokenState;
            }
        }

        task<_TaskType> _ContinuationTask;
        _ContinuationTask._CreateImpl(_Options._PTokenState, _Options._Scheduler);

        _ContinuationTask._GetImpl()->_M_fFromAsync = (_GetImpl()->_M_fFromAsync || _Async_type_traits::_IsAsyncTask);
        _ContinuationTask._GetImpl()->_M_fUnwrappedTask = _Async_type_traits::_IsUnwrappedTaskOrAsync;
        _ContinuationTask._SetTaskCreationCallstack(_Options._CreationStack);

        _GetImpl()->_ScheduleContinuation(new _ContinuationTaskHandle<_InternalReturnType, _TaskType, _Function, typename _Function_type_traits::_Takes_task, typename _Async_type_traits::_AsyncKind>(
            _GetImpl(), _ContinuationTask._GetImpl(), _Func, *_Options._PContinuationContext, _Options._InliningMode));

        return _ContinuationTask;
    }

    
    typename details::_Task_ptr<_ReturnType>::_Type _M_Impl;
};


template<>
class task<void>
{
public:
    
    
    typedef void result_type;

    
    task() : _M_unitTask()
    {
        
        
    }

    
    template<typename _Ty>
    __declspec(noinline) 
    explicit task(_Ty _Param, const task_options& _TaskOptions = task_options())
    {
        details::_ValidateTaskConstructorArgs<void,_Ty>(_Param);

        _M_unitTask._CreateImpl(_TaskOptions.get_cancellation_token()._GetImplValue(), _TaskOptions.get_scheduler());
        
        _M_unitTask._SetTaskCreationCallstack(details::_get_internal_task_options(_TaskOptions)._M_hasPresetCreationCallstack ? details::_get_internal_task_options(_TaskOptions)._M_presetCreationCallstack : ::Concurrency::details::_TaskCreationCallstack::_CaptureSingleFrameCallstack(_ReturnAddress()));

        _TaskInitMaybeFunctor(_Param, decltype(details::_IsCallable(_Param,0))());
    }

    
    task(const task& _Other): _M_unitTask(_Other._M_unitTask){}

    
    task(task&& _Other) : _M_unitTask(::std::move(_Other._M_unitTask)) {}

    
    task& operator=(const task& _Other)
    {
        if (this != &_Other)
        {
            _M_unitTask = _Other._M_unitTask;
        }
        return *this;
    }

    
    task& operator=(task&& _Other)
    {
        if (this != &_Other)
        {
            _M_unitTask = ::std::move(_Other._M_unitTask);
        }
        return *this;
    }

    
    template<typename _Function>
    __declspec(noinline) 
    auto then(const _Function& _Func, task_options _TaskOptions = task_options()) const -> typename details::_ContinuationTypeTraits<_Function, void>::_TaskOfType
    {
        details::_get_internal_task_options(_TaskOptions)._set_creation_callstack(::Concurrency::details::_TaskCreationCallstack::_CaptureSingleFrameCallstack(_ReturnAddress()));

        
        auto _ContinuationContext = _TaskOptions.get_continuation_context();
        auto _Options = details::_ThenImplOptions::_CreateOptions(_TaskOptions, _ContinuationContext, _ThenGetImpl()->_GetScheduler());


        return _M_unitTask._ThenImpl<void>(typename details::_ContinuationTypeTraits<_Function, void>::_StdFuncT(_Func), _Options);


#line 4161 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"
    }

    
    template<typename _Function>
    __declspec(noinline) 
    auto then(const _Function& _Func, cancellation_token _CancellationToken, task_continuation_context _ContinuationContext) const -> typename details::_ContinuationTypeTraits<_Function, void>::_TaskOfType
    {

        task_options _TaskOptions(_CancellationToken, _ContinuationContext);
        details::_get_internal_task_options(_TaskOptions)._set_creation_callstack(::Concurrency::details::_TaskCreationCallstack::_CaptureSingleFrameCallstack(_ReturnAddress()));

        auto _Options = details::_ThenImplOptions::_CreateOptions(_TaskOptions, _ContinuationContext, _ThenGetImpl()->_GetScheduler());


        return _M_unitTask._ThenImpl<void>(typename details::_ContinuationTypeTraits<_Function, void>::_StdFuncT(_Func), _Options);


#line 4206 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"
    }

    
    task_status wait() const
    {
        return _M_unitTask.wait();
    }

    
    void get() const
    {
        _M_unitTask.get();
    }

    
    bool is_done() const
    {
        return _M_unitTask.is_done();
    }

    
    scheduler_ptr scheduler() const
    {
        return _M_unitTask.scheduler();
    }

    
    bool is_apartment_aware() const
    {
        return _M_unitTask.is_apartment_aware();
    }

    
    bool operator==(const task<void>& _Rhs) const
    {
        return (_M_unitTask == _Rhs._M_unitTask);
    }

    
    bool operator!=(const task<void>& _Rhs) const
    {
        return !operator==(_Rhs);
    }

    
    void _CreateImpl(details::_CancellationTokenState * _Ct, scheduler_ptr _Scheduler)
    {
        _M_unitTask._CreateImpl(_Ct, _Scheduler);
    }

    
    const details::_Task_ptr<details::_Unit_type>::_Type & _GetImpl() const
    {
        return _M_unitTask._M_Impl;
    }

    const details::_Task_ptr<details::_Unit_type>::_Type & _ThenGetImpl() const
    {
        if (!_M_unitTask._M_Impl)
        {
            details::_DefaultTaskHelper::_NoCallOnDefaultTask_ErrorImpl();
        }

        return _M_unitTask._M_Impl;
    }

    
    void _SetImpl(const details::_Task_ptr<details::_Unit_type>::_Type & _Impl)
    {
        _M_unitTask._SetImpl(_Impl);
    }

    
    void _SetImpl(details::_Task_ptr<details::_Unit_type>::_Type && _Impl)
    {
        _M_unitTask._SetImpl(::std::move(_Impl));
    }

    
    void _SetAsync(bool _Async = true)
    {
        _M_unitTask._SetAsync(_Async);
    }

    
    void _SetTaskCreationCallstack(const details::_TaskCreationCallstack &_callstack)
    {
        _M_unitTask._SetTaskCreationCallstack(_callstack);
    }

    
    template<typename _Function>
    auto _Then(const _Function& _Func, details::_CancellationTokenState *_PTokenState,
        details::_TaskInliningMode_t _InliningMode = details::_ForceInline) const -> typename details::_ContinuationTypeTraits<_Function, void>::_TaskOfType
    {

        
        auto _Scheduler = _ThenGetImpl()->_GetScheduler();

        
        auto _Default_Context = task_continuation_context::use_default();
        details::_ThenImplOptions _Options{ _PTokenState, &_Default_Context, _Scheduler, ::Concurrency::details::_TaskCreationCallstack::_CaptureSingleFrameCallstack(_ReturnAddress()), _InliningMode };


        return _M_unitTask._ThenImpl<void>(typename details::_ContinuationTypeTraits<_Function, void>::_StdFuncT(_Func), _Options);


#line 4376 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"
    }

private:
    template <typename _Ty> friend class task;
    template <typename _Ty> friend class task_completion_event;

    
    void _TaskInitNoFunctor(task_completion_event<void>& _Event)
    {
        _M_unitTask._TaskInitNoFunctor(_Event._M_unitEvent);
    }


#line 4408 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"

    
    template<typename _Function>
    void _TaskInitMaybeFunctor(_Function& _Func, ::std::true_type)
    {
        _M_unitTask._TaskInitWithFunctor<void, _Function>(_Func);
    }

    
    template<typename _Ty>
    void _TaskInitMaybeFunctor(_Ty& _Param, ::std::false_type)
    {
        _TaskInitNoFunctor(_Param);
    }

    
    task<details::_Unit_type> _M_unitTask;
};

namespace details
{
    
    
#line 4450 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"

    
    template<typename _Ty>
    _Ty _GetUnwrappedType(task<_Ty>);

    
    template<typename _Ty>
    auto _GetUnwrappedReturnType(_Ty _Arg, int) -> decltype(_GetUnwrappedType(_Arg));
    
    template<typename _Ty>
    _Ty _GetUnwrappedReturnType(_Ty, ...);

    
    template<typename _Ty>
    _Ty _GetTaskType(task_completion_event<_Ty>, ::std::false_type);

    
    template<typename _Ty>
    auto _GetTaskType(_Ty _NonFunc, ::std::false_type) -> decltype(_GetUnwrappedType(_NonFunc));

    
    template<typename _Ty>
    auto _GetTaskType(_Ty _Func, ::std::true_type) -> decltype(_GetUnwrappedReturnType(_Func(), 0));

    
    void _GetTaskType(::std::function<void()>, ::std::true_type);
    struct _BadArgType{};

    template<typename _Ty>
    auto _FilterValidTaskType(_Ty _Param, int) -> decltype(_GetTaskType(_Param, _IsCallable(_Param, 0)));

    template<typename _Ty>
    _BadArgType _FilterValidTaskType(_Ty _Param, ...);

    template<typename _Ty>
    struct _TaskTypeFromParam
    {
        typedef decltype(_FilterValidTaskType(details::declval<_Ty>(), 0)) _Type;
    };

    inline bool _IsHRCOMDisconnected(int __hr)
    {
        return static_cast<unsigned int>(__hr) == 0x800706BAU 
        || static_cast<unsigned int>(__hr) == 0x80010108U 
        || static_cast<unsigned int>(__hr) == 0x89020001U; 
    }
} 


template<typename _Ty>
__declspec(noinline)
auto create_task(_Ty _Param, task_options _TaskOptions = task_options()) -> task<typename details::_TaskTypeFromParam<_Ty>::_Type>
{
    static_assert(!::std::is_same_v<typename details::_TaskTypeFromParam<_Ty>::_Type, details::_BadArgType>,


#line 4540 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"
            "incorrect argument for create_task; must be either a callable object or a task_completion_event"
#line 4542 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"
    );
    details::_get_internal_task_options(_TaskOptions)._set_creation_callstack(::Concurrency::details::_TaskCreationCallstack::_CaptureSingleFrameCallstack(_ReturnAddress()));
    task<typename details::_TaskTypeFromParam<_Ty>::_Type> _CreatedTask(_Param, _TaskOptions);
    return _CreatedTask;
}


template<typename _ReturnType>
__declspec(noinline)
task<_ReturnType> create_task(const task<_ReturnType>& _Task)
{
    task<_ReturnType> _CreatedTask(_Task);
    return _CreatedTask;
}


#line 6028 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"

namespace details
{
    
    template<typename _Type>
    struct _RunAllParam
    {
        _RunAllParam() : _M_completeCount(0), _M_numTasks(0)
        {
        }

        void _Resize(size_t _Len, bool _SkipVector = false)
        {
            _M_numTasks = _Len;
            if (!_SkipVector)
            {
                _M_vector._Result.resize(_Len);
            }
        }

        task_completion_event<_Unit_type>   _M_completed;
        _ResultHolder<::std::vector<_Type>> _M_vector;
        _ResultHolder<_Type>                _M_mergeVal;
        atomic_size_t                       _M_completeCount;
        size_t                              _M_numTasks;
    };

    template<typename _Type>
    struct _RunAllParam<::std::vector<_Type>>
    {
        _RunAllParam() : _M_completeCount(0), _M_numTasks(0)
        {
        }

        void _Resize(size_t _Len, bool _SkipVector = false)
        {
            _M_numTasks = _Len;

            if (!_SkipVector)
            {
                _M_vector.resize(_Len);
            }
        }

        task_completion_event<_Unit_type>                  _M_completed;
        ::std::vector<_ResultHolder<::std::vector<_Type>>> _M_vector;
        atomic_size_t                                      _M_completeCount;
        size_t                                             _M_numTasks;
    };

    
    template<>
    struct _RunAllParam<_Unit_type>
    {
        _RunAllParam() : _M_completeCount(0), _M_numTasks(0)
        {
        }

        void _Resize(size_t _Len)
        {
            _M_numTasks = _Len;
        }

        task_completion_event<_Unit_type> _M_completed;
        atomic_size_t _M_completeCount;
        size_t _M_numTasks;
    };

    inline void _JoinAllTokens_Add(const cancellation_token_source& _MergedSrc, _CancellationTokenState *_PJoinedTokenState)
    {
        if (_PJoinedTokenState != nullptr && _PJoinedTokenState != _CancellationTokenState::_None())
        {
            cancellation_token _T = cancellation_token::_FromImpl(_PJoinedTokenState);
            _T.register_callback( [=](){
                _MergedSrc.cancel();
                });
        }
    }

    template<typename _ElementType, typename _Function, typename _TaskType>
    void _WhenAllContinuationWrapper(_RunAllParam<_ElementType>* _PParam, _Function _Func, task<_TaskType>& _Task)
    {
        if (_Task._GetImpl()->_IsCompleted())
        {
            _Func();
            if (atomic_increment(_PParam->_M_completeCount) == _PParam->_M_numTasks)
            {
                
                _PParam->_M_completed.set(_Unit_type());
                
                delete _PParam;
            }
        }
        else
        {
            ((void)0);
            if (_Task._GetImpl()->_HasUserException())
            {
                
                if (!_PParam->_M_completed._Cancel(_Task._GetImpl()->_GetExceptionHolder()))
                {
                    atomic_exchange(_Task._GetImpl()->_GetExceptionHolder()->_M_exceptionObserved, 1l);
                }
            }
            else
            {
                _PParam->_M_completed._Cancel();
            }

            if (atomic_increment(_PParam->_M_completeCount) == _PParam->_M_numTasks)
            {
                delete _PParam;
            }
        }
    }

    template<typename _ElementType, typename _Iterator>
    struct _WhenAllImpl
    {
        static task<::std::vector<_ElementType>> _Perform(const task_options& _TaskOptions, _Iterator _Begin, _Iterator _End)
        {
            _CancellationTokenState *_PTokenState = _TaskOptions.has_cancellation_token() ? _TaskOptions.get_cancellation_token()._GetImplValue() : nullptr;

            auto _PParam = new _RunAllParam<_ElementType>();
            cancellation_token_source _MergedSource;

            
            task_options _Options(_TaskOptions);
            _Options.set_cancellation_token(_MergedSource.get_token());
            task<_Unit_type> _All_tasks_completed(_PParam->_M_completed, _Options);
            
            auto _ReturnTask = _All_tasks_completed._Then([=](_Unit_type) -> ::std::vector<_ElementType> {
                return _PParam->_M_vector.Get();
            }, nullptr);

            
            if (_PTokenState)
            {
                _JoinAllTokens_Add(_MergedSource, _PTokenState);
                _PParam->_Resize(static_cast<size_t>(::std::distance(_Begin, _End)));
            }
            else
            {
                size_t _TaskNum = 0;
                for (auto _PTask = _Begin; _PTask != _End; ++_PTask)
                {
                    _TaskNum++;
                    _JoinAllTokens_Add(_MergedSource, _PTask->_GetImpl()->_M_pTokenState);
                }
                _PParam->_Resize(_TaskNum);
            }

            
            if( _Begin == _End )
            {
                _PParam->_M_completed.set(_Unit_type());
                delete _PParam;
            }
            else
            {
                size_t _Index = 0;
                for (auto _PTask = _Begin; _PTask != _End; ++_PTask)
                {
                    if (_PTask->is_apartment_aware())
                    {
                        _ReturnTask._SetAsync();
                    }

                    _PTask->_Then([_PParam, _Index](task<_ElementType> _ResultTask) {

                        auto _Func = [_PParam, _Index, &_ResultTask](){
                            _PParam->_M_vector._Result[_Index] = _ResultTask._GetImpl()->_GetResult();
                        };

                        _WhenAllContinuationWrapper(_PParam, _Func, _ResultTask);
                    }, _CancellationTokenState::_None());

                    _Index++;
                }
            }

            return _ReturnTask;
        }
    };

    template<typename _ElementType, typename _Iterator>
    struct _WhenAllImpl<::std::vector<_ElementType>, _Iterator>
    {
        static task<::std::vector<_ElementType>> _Perform(const task_options& _TaskOptions, _Iterator _Begin, _Iterator _End)
        {
            _CancellationTokenState *_PTokenState = _TaskOptions.has_cancellation_token() ? _TaskOptions.get_cancellation_token()._GetImplValue() : nullptr;

            auto _PParam = new _RunAllParam<::std::vector<_ElementType>>();
            cancellation_token_source _MergedSource;

            
            task_options _Options(_TaskOptions);
            _Options.set_cancellation_token(_MergedSource.get_token());
            task<_Unit_type> _All_tasks_completed(_PParam->_M_completed, _Options);
            
            auto _ReturnTask = _All_tasks_completed._Then([=](_Unit_type) -> ::std::vector<_ElementType> {
                ((void)0);
                ::std::vector<_ElementType> _Result;
                for(size_t _I = 0; _I < _PParam->_M_numTasks; _I++)
                {
                    const ::std::vector<_ElementType>& _Vec = _PParam->_M_vector[_I].Get();
                    _Result.insert(_Result.end(), _Vec.begin(), _Vec.end());
                }
                return _Result;
            }, nullptr);

            
            if (_PTokenState)
            {
                _JoinAllTokens_Add(_MergedSource, _PTokenState);
                _PParam->_Resize(static_cast<size_t>(::std::distance(_Begin, _End)));
            }
            else
            {
                size_t _TaskNum = 0;
                for (auto _PTask = _Begin; _PTask != _End; ++_PTask)
                {
                    _TaskNum++;
                    _JoinAllTokens_Add(_MergedSource, _PTask->_GetImpl()->_M_pTokenState);
                }
                _PParam->_Resize(_TaskNum);
            }

            
            if( _Begin == _End )
            {
                _PParam->_M_completed.set(_Unit_type());
                delete _PParam;
            }
            else
            {
                size_t _Index = 0;
                for (auto _PTask = _Begin; _PTask != _End; ++_PTask)
                {
                    if (_PTask->is_apartment_aware())
                    {
                        _ReturnTask._SetAsync();
                    }

                    _PTask->_Then([_PParam, _Index](task<::std::vector<_ElementType>> _ResultTask) {
                        auto _Func = [_PParam, _Index, &_ResultTask]() {
                            _PParam->_M_vector[_Index].Set(_ResultTask._GetImpl()->_GetResult());
                        };

                        _WhenAllContinuationWrapper(_PParam, _Func, _ResultTask);
                    }, _CancellationTokenState::_None());

                    _Index++;
                }
            }

            return  _ReturnTask;
        }
    };

    template<typename _Iterator>
    struct _WhenAllImpl<void, _Iterator>
    {
        static task<void> _Perform(const task_options& _TaskOptions, _Iterator _Begin, _Iterator _End)
        {
            _CancellationTokenState *_PTokenState = _TaskOptions.has_cancellation_token() ? _TaskOptions.get_cancellation_token()._GetImplValue() : nullptr;

            auto _PParam = new _RunAllParam<_Unit_type>();
            cancellation_token_source _MergedSource;

            
            task_options _Options(_TaskOptions);
            _Options.set_cancellation_token(_MergedSource.get_token());
            task<_Unit_type> _All_tasks_completed(_PParam->_M_completed, _Options);
            
            auto _ReturnTask = _All_tasks_completed._Then([=](_Unit_type) {
            }, nullptr);

            
            if (_PTokenState)
            {
                _JoinAllTokens_Add(_MergedSource, _PTokenState);
                _PParam->_Resize(static_cast<size_t>(::std::distance(_Begin, _End)));
            }
            else
            {
                size_t _TaskNum = 0;
                for (auto _PTask = _Begin; _PTask != _End; ++_PTask)
                {
                    _TaskNum++;
                    _JoinAllTokens_Add(_MergedSource, _PTask->_GetImpl()->_M_pTokenState);
                }
                _PParam->_Resize(_TaskNum);
            }

            
            if( _Begin == _End )
            {
                _PParam->_M_completed.set(_Unit_type());
                delete _PParam;
            }
            else
            {
                for (auto _PTask = _Begin; _PTask != _End; ++_PTask)
                {
                    if (_PTask->is_apartment_aware())
                    {
                        _ReturnTask._SetAsync();
                    }

                    _PTask->_Then([_PParam](task<void> _ResultTask) {
                        auto _Func = [](){};
                        _WhenAllContinuationWrapper(_PParam, _Func, _ResultTask);
                    }, _CancellationTokenState::_None());
                }
            }

            return _ReturnTask;
        }
    };

    template<typename _ReturnType>
    task<::std::vector<_ReturnType>> _WhenAllVectorAndValue(const task<::std::vector<_ReturnType>>& _VectorTask, const task<_ReturnType>& _ValueTask,
                                                          bool _OutputVectorFirst)
    {
        auto _PParam = new _RunAllParam<_ReturnType>();
        cancellation_token_source _MergedSource;

        
        task<_Unit_type> _All_tasks_completed(_PParam->_M_completed, _MergedSource.get_token());
        
        auto _ReturnTask = _All_tasks_completed._Then([=](_Unit_type) -> ::std::vector<_ReturnType> {
            ((void)0);
            auto _Result = _PParam->_M_vector.Get(); 
            auto _mergeVal = _PParam->_M_mergeVal.Get();

            if (_OutputVectorFirst == true)
            {
                _Result.push_back(_mergeVal);
            }
            else
            {
                _Result.insert(_Result.begin(), _mergeVal);
            }
            return _Result;
        }, nullptr);

        
        _JoinAllTokens_Add(_MergedSource, _VectorTask._GetImpl()->_M_pTokenState);
        _JoinAllTokens_Add(_MergedSource, _ValueTask._GetImpl()->_M_pTokenState);

        
        _PParam->_Resize(2, true);

        if (_VectorTask.is_apartment_aware() || _ValueTask.is_apartment_aware())
        {
            _ReturnTask._SetAsync();
        }
        _VectorTask._Then([_PParam](task<::std::vector<_ReturnType>> _ResultTask) {
            auto _Func = [_PParam, &_ResultTask]() {
                auto _ResultLocal = _ResultTask._GetImpl()->_GetResult();
                _PParam->_M_vector.Set(_ResultLocal);
            };

            _WhenAllContinuationWrapper(_PParam, _Func, _ResultTask);
        }, _CancellationTokenState::_None());
        _ValueTask._Then([_PParam](task<_ReturnType> _ResultTask) {
            auto _Func = [_PParam, &_ResultTask]() {
                auto _ResultLocal = _ResultTask._GetImpl()->_GetResult();
                _PParam->_M_mergeVal.Set(_ResultLocal);
            };

            _WhenAllContinuationWrapper(_PParam, _Func, _ResultTask);
        }, _CancellationTokenState::_None());

        return _ReturnTask;
    }
} 


template <typename _Iterator>
auto when_all(_Iterator _Begin, _Iterator _End, const task_options& _TaskOptions = task_options())
    -> decltype (details::_WhenAllImpl<typename ::std::iterator_traits<_Iterator>::value_type::result_type, _Iterator>::_Perform(_TaskOptions, _Begin, _End))
{
    typedef typename ::std::iterator_traits<_Iterator>::value_type::result_type _ElementType;
    return details::_WhenAllImpl<_ElementType, _Iterator>::_Perform(_TaskOptions, _Begin, _End);
}


template<typename _ReturnType>
auto operator&&(const task<_ReturnType> & _Lhs, const task<_ReturnType> & _Rhs)
{
    task<_ReturnType> _PTasks[2] = {_Lhs, _Rhs};
    return when_all(_PTasks, _PTasks+2);
}


template<typename _ReturnType>
task<::std::vector<_ReturnType>> operator&&(const task<::std::vector<_ReturnType>> & _Lhs, const task<_ReturnType> & _Rhs)
{
    return details::_WhenAllVectorAndValue(_Lhs, _Rhs, true);
}


template<typename _ReturnType>
task<::std::vector<_ReturnType>> operator&&(const task<_ReturnType> & _Lhs, const task<::std::vector<_ReturnType>> & _Rhs)
{
    return details::_WhenAllVectorAndValue(_Rhs, _Lhs, false);
}


template<typename _ReturnType>
task<::std::vector<_ReturnType>> operator&&(const task<::std::vector<_ReturnType>> & _Lhs, const task<::std::vector<_ReturnType>> & _Rhs)
{
    task<::std::vector<_ReturnType>> _PTasks[2] = {_Lhs, _Rhs};
    return when_all(_PTasks, _PTasks+2);
}

namespace details
{
    
    template <typename _CompletionType>
    struct _RunAnyParam
    {
        _RunAnyParam() : _M_exceptionRelatedToken(nullptr), _M_completeCount(0), _M_numTasks(0), _M_fHasExplicitToken(false)
        {
        }
        ~_RunAnyParam()
        {
            if (_CancellationTokenState::_IsValid(_M_exceptionRelatedToken))
                _M_exceptionRelatedToken->_Release();
        }
        task_completion_event<_CompletionType>      _M_Completed;
        cancellation_token_source                   _M_cancellationSource;
        _CancellationTokenState *                   _M_exceptionRelatedToken;
        atomic_size_t                               _M_completeCount;
        size_t                                      _M_numTasks;
        bool                                        _M_fHasExplicitToken;
    };

    template<typename _CompletionType, typename _Function, typename _TaskType>
    void _WhenAnyContinuationWrapper(_RunAnyParam<_CompletionType> * _PParam, const _Function & _Func, task<_TaskType>& _Task)
    {
        bool _IsTokenCanceled = !_PParam->_M_fHasExplicitToken && _Task._GetImpl()->_M_pTokenState != _CancellationTokenState::_None() && _Task._GetImpl()->_M_pTokenState->_IsCanceled();
        if (_Task._GetImpl()->_IsCompleted() && !_IsTokenCanceled)
        {
            _Func();
            if (atomic_increment(_PParam->_M_completeCount) == _PParam->_M_numTasks)
            {
                _PParam->_M_Completed._ClearStoredException();
                delete _PParam;
            }
        }
        else
        {
            ((void)0);
            if (_Task._GetImpl()->_HasUserException())
            {
                if (!_IsTokenCanceled && _PParam->_M_Completed._StoreException(_Task._GetImpl()->_GetExceptionHolder()))
                {
                    
                    _PParam->_M_exceptionRelatedToken = _Task._GetImpl()->_M_pTokenState;
                    ((void)0);
                    
                    if (_PParam->_M_exceptionRelatedToken != _CancellationTokenState::_None())
                    {
                        _PParam->_M_exceptionRelatedToken->_Reference();
                    }
                }
                else
                {
                    
                    atomic_exchange(_Task._GetImpl()->_GetExceptionHolder()->_M_exceptionObserved, 1l);
                }
            }

            if (atomic_increment(_PParam->_M_completeCount) == _PParam->_M_numTasks)
            {
                
                if (!_PParam->_M_Completed._IsTriggered())
                {
                    
                    if (!_PParam->_M_fHasExplicitToken)
                    {
                        if (_PParam->_M_exceptionRelatedToken)
                        {
                            _JoinAllTokens_Add(_PParam->_M_cancellationSource, _PParam->_M_exceptionRelatedToken);
                        }
                        else
                        {
                            
                            
                            _JoinAllTokens_Add(_PParam->_M_cancellationSource, _Task._GetImpl()->_M_pTokenState);
                        }
                    }
                    
                    _PParam->_M_Completed._Cancel();
                }
                else
                    _PParam->_M_Completed._ClearStoredException();
                delete _PParam;
            }
        }
    }

    template<typename _ElementType, typename _Iterator>
    struct _WhenAnyImpl
    {
        static task<::std::pair<_ElementType, size_t>> _Perform(const task_options& _TaskOptions, _Iterator _Begin, _Iterator _End)
        {
            if( _Begin == _End )
            {
                throw invalid_operation("when_any(begin, end) cannot be called on an empty container.");
            }
            _CancellationTokenState *_PTokenState = _TaskOptions.has_cancellation_token() ? _TaskOptions.get_cancellation_token()._GetImplValue() : nullptr;
            auto _PParam = new _RunAnyParam<::std::pair<::std::pair<_ElementType, size_t>, _CancellationTokenState *>>();

            if (_PTokenState)
            {
                _JoinAllTokens_Add(_PParam->_M_cancellationSource, _PTokenState);
                _PParam->_M_fHasExplicitToken = true;
            }

            task_options _Options(_TaskOptions);
            _Options.set_cancellation_token(_PParam->_M_cancellationSource.get_token());
            task<::std::pair<::std::pair<_ElementType, size_t>, _CancellationTokenState *>> _Any_tasks_completed(_PParam->_M_Completed, _Options);

            
            auto _CancellationSource = _PParam->_M_cancellationSource;

            _PParam->_M_numTasks = static_cast<size_t>(::std::distance(_Begin, _End));
            size_t _Index = 0;
            for (auto _PTask = _Begin; _PTask != _End; ++_PTask)
            {
                if (_PTask->is_apartment_aware())
                {
                    _Any_tasks_completed._SetAsync();
                }

                _PTask->_Then([_PParam, _Index](task<_ElementType> _ResultTask) {
                    auto _Func = [&_ResultTask, _PParam, _Index]() {
                        _PParam->_M_Completed.set(::std::make_pair(::std::make_pair(_ResultTask._GetImpl()->_GetResult(), _Index),  _ResultTask._GetImpl()->_M_pTokenState));
                    };

                    _WhenAnyContinuationWrapper(_PParam, _Func, _ResultTask);
                }, _CancellationTokenState::_None());

                _Index++;
            }

            
            return _Any_tasks_completed._Then([=](::std::pair<::std::pair<_ElementType, size_t>, _CancellationTokenState *> _Result) -> ::std::pair<_ElementType, size_t> {
                ((void)0);
                if (!_PTokenState)
                {
                    _JoinAllTokens_Add(_CancellationSource, _Result.second);
                }
                return _Result.first;
            }, nullptr);
        }
    };

    template<typename _Iterator>
    struct _WhenAnyImpl<void, _Iterator>
    {
        static task<size_t> _Perform(const task_options& _TaskOptions, _Iterator _Begin, _Iterator _End)
        {
            if( _Begin == _End )
            {
                throw invalid_operation("when_any(begin, end) cannot be called on an empty container.");
            }

            _CancellationTokenState *_PTokenState = _TaskOptions.has_cancellation_token() ? _TaskOptions.get_cancellation_token()._GetImplValue() : nullptr;
            auto _PParam = new _RunAnyParam<::std::pair<size_t, _CancellationTokenState *>>();

            if (_PTokenState)
            {
                _JoinAllTokens_Add(_PParam->_M_cancellationSource, _PTokenState);
                _PParam->_M_fHasExplicitToken = true;
            }

            task_options _Options(_TaskOptions);
            _Options.set_cancellation_token(_PParam->_M_cancellationSource.get_token());
            task<::std::pair<size_t, _CancellationTokenState *>> _Any_tasks_completed(_PParam->_M_Completed, _Options);

            
            auto _CancellationSource = _PParam->_M_cancellationSource;

            _PParam->_M_numTasks = static_cast<size_t>(::std::distance(_Begin, _End));
            size_t _Index = 0;
            for (auto _PTask = _Begin; _PTask != _End; ++_PTask)
            {
                if (_PTask->is_apartment_aware())
                {
                    _Any_tasks_completed._SetAsync();
                }

                _PTask->_Then([_PParam, _Index](task<void> _ResultTask) {
                    auto _Func = [&_ResultTask, _PParam, _Index]() {
                        _PParam->_M_Completed.set(::std::make_pair(_Index, _ResultTask._GetImpl()->_M_pTokenState));
                    };
                    _WhenAnyContinuationWrapper(_PParam, _Func, _ResultTask);
                }, _CancellationTokenState::_None());

                _Index++;
            }

            
            return _Any_tasks_completed._Then([=](::std::pair<size_t, _CancellationTokenState *> _Result) -> size_t {
                ((void)0);
                if (!_PTokenState)
                {
                    _JoinAllTokens_Add(_CancellationSource, _Result.second);
                }
                return _Result.first;
            }, nullptr);
        }
    };
} 


template<typename _Iterator>
auto when_any(_Iterator _Begin, _Iterator _End, const task_options& _TaskOptions = task_options())
    -> decltype (details::_WhenAnyImpl<typename ::std::iterator_traits<_Iterator>::value_type::result_type, _Iterator>::_Perform(_TaskOptions, _Begin, _End))
{
    typedef typename ::std::iterator_traits<_Iterator>::value_type::result_type _ElementType;
    return details::_WhenAnyImpl<_ElementType, _Iterator>::_Perform(_TaskOptions, _Begin, _End);
}


template<typename _Iterator>
auto when_any(_Iterator _Begin, _Iterator _End, cancellation_token _CancellationToken)
    -> decltype (details::_WhenAnyImpl<typename ::std::iterator_traits<_Iterator>::value_type::result_type, _Iterator>::_Perform(_CancellationToken._GetImplValue(), _Begin, _End))
{
    typedef typename ::std::iterator_traits<_Iterator>::value_type::result_type _ElementType;
    return details::_WhenAnyImpl<_ElementType, _Iterator>::_Perform(_CancellationToken._GetImplValue(), _Begin, _End);
}


template<typename _ReturnType>
task<_ReturnType> operator||(const task<_ReturnType> & _Lhs, const task<_ReturnType> & _Rhs)
{
    auto _PParam = new details::_RunAnyParam<::std::pair<_ReturnType, size_t>>();

    task<::std::pair<_ReturnType, size_t>> _Any_tasks_completed(_PParam->_M_Completed, _PParam->_M_cancellationSource.get_token());
    
    
    auto _ReturnTask = _Any_tasks_completed._Then([=](::std::pair<_ReturnType, size_t> _Ret) -> _ReturnType {
        ((void)0);
        _JoinAllTokens_Add(_PParam->_M_cancellationSource, reinterpret_cast<details::_CancellationTokenState *>(_Ret.second));
        return _Ret.first;
    }, nullptr);

    if (_Lhs.is_apartment_aware() || _Rhs.is_apartment_aware())
    {
        _ReturnTask._SetAsync();
    }

    _PParam->_M_numTasks = 2;
    auto _Continuation = [_PParam](task<_ReturnType> _ResultTask) {
        auto _Func = [&_ResultTask, _PParam]() {
            _PParam->_M_Completed.set(::std::make_pair(_ResultTask._GetImpl()->_GetResult(), reinterpret_cast<size_t>(_ResultTask._GetImpl()->_M_pTokenState)));
        };
        _WhenAnyContinuationWrapper(_PParam, _Func, _ResultTask);
    };

    _Lhs._Then(_Continuation, details::_CancellationTokenState::_None());
    _Rhs._Then(_Continuation, details::_CancellationTokenState::_None());

    return _ReturnTask;
}


template<typename _ReturnType>
task<::std::vector<_ReturnType>> operator||(const task<::std::vector<_ReturnType>> & _Lhs, const task<_ReturnType> & _Rhs)
{
    auto _PParam = new details::_RunAnyParam<::std::pair<::std::vector<_ReturnType>, details::_CancellationTokenState *>>();

    task<::std::pair<::std::vector<_ReturnType>, details::_CancellationTokenState *>> _Any_tasks_completed(_PParam->_M_Completed, _PParam->_M_cancellationSource.get_token());

    
    auto _ReturnTask = _Any_tasks_completed._Then([=](::std::pair<::std::vector<_ReturnType>, details::_CancellationTokenState *> _Ret) -> ::std::vector<_ReturnType> {
        ((void)0);
        _JoinAllTokens_Add(_PParam->_M_cancellationSource, _Ret.second);
        return _Ret.first;
    }, nullptr);

    if (_Lhs.is_apartment_aware() || _Rhs.is_apartment_aware())
    {
        _ReturnTask._SetAsync();
    }

    _PParam->_M_numTasks = 2;
    _Lhs._Then([_PParam](task<::std::vector<_ReturnType>> _ResultTask) {
        auto _Func = [&_ResultTask, _PParam]() {
            auto _Result = _ResultTask._GetImpl()->_GetResult();
            _PParam->_M_Completed.set(::std::make_pair(_Result, _ResultTask._GetImpl()->_M_pTokenState));
        };
        _WhenAnyContinuationWrapper(_PParam, _Func, _ResultTask);
    }, details::_CancellationTokenState::_None());


    _Rhs._Then([_PParam](task<_ReturnType> _ResultTask)
    {
        auto _Func = [&_ResultTask, _PParam]() {
            auto _Result = _ResultTask._GetImpl()->_GetResult();

            ::std::vector<_ReturnType> _Vec;
            _Vec.push_back(_Result);
            _PParam->_M_Completed.set(::std::make_pair(_Vec, _ResultTask._GetImpl()->_M_pTokenState));
        };
        _WhenAnyContinuationWrapper(_PParam, _Func, _ResultTask);
    }, details::_CancellationTokenState::_None());

    return _ReturnTask;
}


template<typename _ReturnType>
task<::std::vector<_ReturnType>> operator||(const task<_ReturnType> & _Lhs, const task<::std::vector<_ReturnType>> & _Rhs)
{
    return _Rhs || _Lhs;
}


template<typename _Ty = task<void>, typename _Pair = ::std::pair<details::_Unit_type, details::_CancellationTokenState *>>
inline _Ty operator||(const task<void> & _Lhs_arg, const task<void> & _Rhs_arg)
{
    const _Ty& _Lhs = _Lhs_arg;
    const _Ty& _Rhs = _Rhs_arg;

    auto _PParam = new details::_RunAnyParam<_Pair>();

    task<_Pair> _Any_task_completed(_PParam->_M_Completed, _PParam->_M_cancellationSource.get_token());
    
    
    auto _ReturnTask = _Any_task_completed._Then([=](_Pair _Ret) {
        ((void)0);
        details::_JoinAllTokens_Add(_PParam->_M_cancellationSource, _Ret.second);
    }, nullptr);

    if (_Lhs.is_apartment_aware() || _Rhs.is_apartment_aware())
    {
        _ReturnTask._SetAsync();
    }

    _PParam->_M_numTasks = 2;
    auto _Continuation = [_PParam](_Ty _ResultTask) mutable {
        auto _Func = [&_ResultTask, _PParam]() {
            _PParam->_M_Completed.set(::std::make_pair(details::_Unit_type(), _ResultTask._GetImpl()->_M_pTokenState));
        };
        _WhenAnyContinuationWrapper(_PParam, _Func, _ResultTask);
    };

    _Lhs._Then(_Continuation, details::_CancellationTokenState::_None());
    _Rhs._Then(_Continuation, details::_CancellationTokenState::_None());

    return _ReturnTask;
}

template<typename _Ty>
task<_Ty> task_from_result(_Ty _Param, const task_options& _TaskOptions = task_options())
{
    task_completion_event<_Ty> _Tce;
    _Tce.set(_Param);
    return create_task(_Tce, _TaskOptions);
}

inline task<void> task_from_result(const task_options& _TaskOptions = task_options())
{
    task_completion_event<void> _Tce;
    _Tce.set();
    return create_task(_Tce, _TaskOptions);
}

template<typename _TaskType, typename _ExType>
task<_TaskType> task_from_exception(_ExType _Exception, const task_options& _TaskOptions = task_options())
{
    task_completion_event<_TaskType> _Tce;
    _Tce.set_exception(_Exception);
    return create_task(_Tce, _TaskOptions);
}

namespace details
{
    
    
    template<typename _Ty = task<bool>>
    inline
    _Ty do_while(::std::enable_if_t<true, ::std::function<_Ty()>> _Func)
    {
        _Ty _First = _Func();
        return _First.then([=](bool _Guard) -> _Ty {
            if (_Guard)
                return do_while(_Func);
            else
                return _First;
            });
    }

} 

} 


#pragma warning(pop)
#pragma pack(pop)

#line 7103 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ppltasks.h"
#line 26 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\future"


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {
template <class _Alloc>
struct _Allocator_deleter {
    _Alloc _Al;

    using pointer = typename allocator_traits<_Alloc>::pointer;
    void operator()(pointer _Ptr) noexcept { 
        _Destroy_in_place(*_Ptr);
        _Al.deallocate(_Ptr, 1);
    }
};

template <class _Alloc>
using _Unique_ptr_alloc = unique_ptr<typename _Alloc::value_type, _Allocator_deleter<_Alloc>>;

template <class _Alloc, class... _Args>
[[nodiscard]] _Unique_ptr_alloc<_Alloc> _Make_unique_alloc(_Alloc& _Al, _Args&&... _Vals) {
    
    _Alloc_construct_ptr<_Alloc> _Constructor{_Al};
    _Constructor._Allocate();
    _Construct_in_place(*_Constructor._Ptr, ::std:: forward<_Args>(_Vals)...);
    return _Unique_ptr_alloc<_Alloc>(_Constructor._Release(), _Allocator_deleter<_Alloc>{_Al});
}

struct _Nil {}; 

enum class future_errc { 
    broken_promise = 1,
    future_already_retrieved,
    promise_already_satisfied,
    no_state
};

enum class launch { 
    async    = 0x1,
    deferred = 0x2
};

[[nodiscard]] constexpr launch operator&(launch _Left, launch _Right) noexcept { using _IntTy = ::std:: underlying_type_t<launch>; return static_cast<launch>(static_cast<_IntTy>(_Left) & static_cast<_IntTy>(_Right)); } [[nodiscard]] constexpr launch operator|(launch _Left, launch _Right) noexcept { using _IntTy = ::std:: underlying_type_t<launch>; return static_cast<launch>(static_cast<_IntTy>(_Left) | static_cast<_IntTy>(_Right)); } [[nodiscard]] constexpr launch operator^(launch _Left, launch _Right) noexcept { using _IntTy = ::std:: underlying_type_t<launch>; return static_cast<launch>(static_cast<_IntTy>(_Left) ^ static_cast<_IntTy>(_Right)); } constexpr launch& operator&=(launch& _Left, launch _Right) noexcept { return _Left = _Left & _Right; } constexpr launch& operator|=(launch& _Left, launch _Right) noexcept { return _Left = _Left | _Right; } constexpr launch& operator^=(launch& _Left, launch _Right) noexcept { return _Left = _Left ^ _Right; } [[nodiscard]] constexpr launch operator~(launch _Left) noexcept { using _IntTy = ::std:: underlying_type_t<launch>; return static_cast<launch>(~static_cast<_IntTy>(_Left)); } [[nodiscard]] constexpr bool _Bitmask_includes( launch _Left, launch _Elements) noexcept { return (_Left & _Elements) != launch{}; } [[nodiscard]] constexpr bool _Bitmask_includes_all( launch _Left, launch _Elements) noexcept { return (_Left & _Elements) == _Elements; }

enum class future_status { 
    ready,
    timeout,
    deferred
};

[[noreturn]]  void __cdecl _Throw_future_error(const error_code& _Code);
[[noreturn]]  void __cdecl _Rethrow_future_exception(exception_ptr _Ptr);

template <>
struct is_error_code_enum<future_errc> : true_type {};

[[nodiscard]] const error_category& future_category() noexcept;

[[nodiscard]] inline error_code make_error_code(future_errc _Errno) noexcept {
    return error_code(static_cast<int>(_Errno), ::std:: future_category());
}

[[nodiscard]] inline error_condition make_error_condition(future_errc _Errno) noexcept {
    return error_condition(static_cast<int>(_Errno), ::std:: future_category());
}

inline const char* _Future_error_map(int _Errcode) noexcept { 
    switch (static_cast<future_errc>(_Errcode)) { 
    case future_errc::broken_promise:
        return "broken promise";

    case future_errc::future_already_retrieved:
        return "future already retrieved";

    case future_errc::promise_already_satisfied:
        return "promise already satisfied";

    case future_errc::no_state:
        return "no state";

    default:
        return nullptr;
    }
}

class future_error : public logic_error { 
public:
    explicit future_error(error_code _Errcode) 
        : logic_error(""), _Mycode(_Errcode) {}

    explicit future_error(future_errc _Errno) : logic_error(""), _Mycode(::std:: make_error_code(_Errno)) {}

    [[nodiscard]] const error_code& code() const noexcept {
        return _Mycode;
    }

    [[nodiscard]] const char*  what() const noexcept override { 
        return _Future_error_map(_Mycode.value());
    }


#line 139 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\future"

private:
    error_code _Mycode; 
};

class _Future_error_category2 : public error_category { 
public:
    constexpr _Future_error_category2() noexcept : error_category(_Future_addr) {}

    const char* name() const noexcept override {
        return "future";
    }

    string message(int _Errcode) const override {
        const char* _Name = _Future_error_map(_Errcode);
        if (_Name) {
            return _Name;
        }

        return _Syserror_map(_Errcode);
    }
};

[[nodiscard]] inline const error_category& future_category() noexcept {
    return _Immortalize_memcpy_image<_Future_error_category2>();
}

template <class _Ty>
class _Associated_state;

template <class _Ty>
struct __declspec(novtable) _Deleter_base { 
    virtual void _Delete(_Associated_state<_Ty>*) = 0;
    virtual ~_Deleter_base() noexcept {}
};

template <class _Ty, class _Derived, class _Alloc>
struct _State_deleter : _Deleter_base<_Ty> { 
    _State_deleter(const _Alloc& _Al) : _My_alloc(_Al) {}

    _State_deleter(const _State_deleter&) = delete;
    _State_deleter& operator=(const _State_deleter&) = delete;

    void _Delete(_Associated_state<_Ty>* _State) override;

    _Alloc _My_alloc;
};

template <class _Ty>
union _Result_holder {
    _Result_holder() {}
    ~_Result_holder() {}

    _Ty _Held_value;
};

template <class _Ty>
class _Associated_state { 
public:
    using _State_type = _Ty;
    using _Mydel      = _Deleter_base<_Ty>;

    
    _Associated_state(_Mydel* _Dp = nullptr)
        : _Refs(1), 
          _Exception(), _Retrieved(false), _Ready(false), _Ready_at_thread_exit(false), _Has_stored_result(false),
          _Running(false), _Deleter(_Dp) {}

    virtual ~_Associated_state() noexcept {
        if (_Already_has_stored_result() && !_Ready) { 
            _Cond._Unregister(_Mtx);
        }

        if constexpr (!is_default_constructible_v<_Ty>) {
            if (_Has_stored_result) {
                _Result._Held_value.~_Ty();
            }
        }
    }

    void _Retain() { 
        _InterlockedIncrement(reinterpret_cast<volatile long*>(&_Refs));
    }

    void _Release() { 
        if (_InterlockedDecrement(reinterpret_cast<volatile long*>(&_Refs)) == 0) {
            _Delete_this();
        }
    }

private:
    _Atomic_counter_t _Refs;

public:
    virtual void _Wait() { 
        unique_lock<mutex> _Lock(_Mtx);
        _Maybe_run_deferred_function(_Lock);
        while (!_Ready) {
            _Cond.wait(_Lock);
        }
    }

    struct _Test_ready { 
        _Test_ready(const _Associated_state* _St) : _State(_St) {}

        bool operator()() const { 
            return _State->_Ready != 0;
        }
        const _Associated_state* _State;
    };

    template <class _Rep, class _Per>
    future_status _Wait_for(const chrono::duration<_Rep, _Per>& _Rel_time) { 
        unique_lock<mutex> _Lock(_Mtx);
        if (_Has_deferred_function()) {
            return future_status::deferred;
        }

        if (_Cond.wait_for(_Lock, _Rel_time, _Test_ready(this))) {
            return future_status::ready;
        }

        return future_status::timeout;
    }

    template <class _Clock, class _Dur>
    future_status _Wait_until(const chrono::time_point<_Clock, _Dur>& _Abs_time) { 
        unique_lock<mutex> _Lock(_Mtx);
        if (_Has_deferred_function()) {
            return future_status::deferred;
        }

        if (_Cond.wait_until(_Lock, _Abs_time, _Test_ready(this))) {
            return future_status::ready;
        }

        return future_status::timeout;
    }

    virtual _Ty& _Get_value(bool _Get_only_once) {
        unique_lock<mutex> _Lock(_Mtx);
        if (_Get_only_once && _Retrieved) {
            _Throw_future_error(make_error_code(future_errc::future_already_retrieved));
        }

        if (_Exception) {
            _Rethrow_future_exception(_Exception);
        }

        
        _Retrieved = true;
        _Maybe_run_deferred_function(_Lock);
        while (!_Ready) {
            _Cond.wait(_Lock);
        }

        if (_Exception) {
            _Rethrow_future_exception(_Exception);
        }

        if constexpr (is_default_constructible_v<_Ty>) {
            return _Result;
        } else {
            return _Result._Held_value;
        }
    }

    template <class _Ty2>
    void _Emplace_result(_Ty2&& _Val) {
        
        if constexpr (is_default_constructible_v<_Ty>) {
            _Result = ::std:: forward<_Ty2>(_Val);
        } else {
            ::new (static_cast<void*>(::std:: addressof(_Result._Held_value))) _Ty(::std:: forward<_Ty2>(_Val));
            _Has_stored_result = true;
        }
    }

    void _Set_value(const _Ty& _Val, bool _At_thread_exit) { 
        unique_lock<mutex> _Lock(_Mtx);
        _Set_value_raw(_Val, &_Lock, _At_thread_exit);
    }

    void _Set_value_raw(const _Ty& _Val, unique_lock<mutex>* _Lock,
        bool _At_thread_exit) { 
        if (_Already_has_stored_result()) {
            _Throw_future_error(make_error_code(future_errc::promise_already_satisfied));
        }

        _Emplace_result(_Val);
        _Do_notify(_Lock, _At_thread_exit);
    }

    void _Set_value(_Ty&& _Val, bool _At_thread_exit) { 
        unique_lock<mutex> _Lock(_Mtx);
        _Set_value_raw(::std:: forward<_Ty>(_Val), &_Lock, _At_thread_exit);
    }

    void _Set_value_raw(_Ty&& _Val, unique_lock<mutex>* _Lock,
        bool _At_thread_exit) { 
        if (_Already_has_stored_result()) {
            _Throw_future_error(make_error_code(future_errc::promise_already_satisfied));
        }

        _Emplace_result(::std:: forward<_Ty>(_Val));
        _Do_notify(_Lock, _At_thread_exit);
    }

    void _Set_exception(exception_ptr _Exc, bool _At_thread_exit) { 
        unique_lock<mutex> _Lock(_Mtx);
        _Set_exception_raw(_Exc, &_Lock, _At_thread_exit);
    }

    void _Set_exception_raw(exception_ptr _Exc, unique_lock<mutex>* _Lock,
        bool _At_thread_exit) { 
        if (_Already_has_stored_result()) {
            _Throw_future_error(make_error_code(future_errc::promise_already_satisfied));
        }

        ;
#line 361 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\future"
        _Exception = _Exc;
        _Do_notify(_Lock, _At_thread_exit);
    }

    bool _Is_ready() const {
        return _Ready != 0;
    }

    bool _Is_ready_at_thread_exit() const {
        return _Ready_at_thread_exit;
    }

    bool _Already_has_stored_result() const { 
        if constexpr (is_default_constructible_v<_Ty>) {
            return _Has_stored_result;
        } else {
            return _Has_stored_result || _Exception;
        }
    }

    bool _Already_retrieved() const {
        return _Retrieved;
    }

    void _Abandon() { 
        unique_lock<mutex> _Lock(_Mtx);
        if (!_Already_has_stored_result()) { 
            future_error _Fut(make_error_code(future_errc::broken_promise));
            _Set_exception_raw(::std:: make_exception_ptr(_Fut), &_Lock, false);
        }
    }

protected:
    void _Make_ready_at_thread_exit() { 
        if (_Ready_at_thread_exit) {
            _Ready = true;
        }
    }

    void _Maybe_run_deferred_function(unique_lock<mutex>& _Lock) { 
        if (!_Running) { 
            _Running = true;
            _Run_deferred_function(_Lock);
        }
    }

public:
    conditional_t<is_default_constructible_v<_Ty>, _Ty, _Result_holder<_Ty>> _Result;
    exception_ptr _Exception;
    mutex _Mtx;
    condition_variable _Cond;
    bool _Retrieved;
    int _Ready;
    bool _Ready_at_thread_exit;
    bool _Has_stored_result;
    bool _Running;

private:
    virtual bool _Has_deferred_function() const noexcept { 
        return false;
    }

    virtual void _Run_deferred_function(unique_lock<mutex>&) {} 

    virtual void _Do_notify(unique_lock<mutex>* _Lock, bool _At_thread_exit) { 
        
        if constexpr (is_default_constructible_v<_Ty>) {
            _Has_stored_result = true;
        }

        if (_At_thread_exit) { 
            _Cond._Register(*_Lock, &_Ready);
        } else { 
            _Ready = true;
            _Cond.notify_all();
        }
    }

    void _Delete_this() { 
        if (_Deleter) {
            _Deleter->_Delete(this);
        } else {
            delete this;
        }
    }

    _Mydel* _Deleter;

public:
    _Associated_state(const _Associated_state&) = delete;
    _Associated_state& operator=(const _Associated_state&) = delete;
};

template <class _Ty, class _Derived, class _Alloc>
void _State_deleter<_Ty, _Derived, _Alloc>::_Delete(
    _Associated_state<_Ty>* _State) { 
    using _State_allocator = _Rebind_alloc_t<_Alloc, _Derived>;
    _State_allocator _St_alloc(_My_alloc);

    using _Deleter_allocator = _Rebind_alloc_t<_Alloc, _State_deleter>;
    _Deleter_allocator _Del_alloc(_My_alloc);

    _Derived* _Ptr = static_cast<_Derived*>(_State);

    _Delete_plain_internal(_St_alloc, _Ptr);
    _Delete_plain_internal(_Del_alloc, this);
}

template <class>
class _Packaged_state;

template <class _Ret, class... _ArgTypes>
class _Packaged_state<_Ret(_ArgTypes...)>
    : public _Associated_state<_Ret> { 
public:
    using _Mybase = _Associated_state<_Ret>;
    using _Mydel  = typename _Mybase::_Mydel;

    template <class _Fty2>
    _Packaged_state(const _Fty2& _Fnarg) : _Fn(_Fnarg) {}


#line 487 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\future"

    template <class _Fty2>
    _Packaged_state(_Fty2&& _Fnarg) : _Fn(::std:: forward<_Fty2>(_Fnarg)) {}


#line 496 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\future"

    void _Call_deferred(_ArgTypes... _Args) { 
        try {
        
        this->_Set_value(_Fn(::std:: forward<_ArgTypes>(_Args)...), true);
        } catch (...) {
        
        this->_Set_exception(::std:: current_exception(), true);
        }
    }

    void _Call_immediate(_ArgTypes... _Args) { 
        try {
        
        this->_Set_value(_Fn(::std:: forward<_ArgTypes>(_Args)...), false);
        } catch (...) {
        
        this->_Set_exception(::std:: current_exception(), false);
        }
    }

    const function<_Ret(_ArgTypes...)>& _Get_fn() {
        return _Fn;
    }

private:
    function<_Ret(_ArgTypes...)> _Fn;
};

template <class _Ret, class... _ArgTypes>
class _Packaged_state<_Ret&(_ArgTypes...)>
    : public _Associated_state<_Ret*> { 
public:
    using _Mybase = _Associated_state<_Ret*>;
    using _Mydel  = typename _Mybase::_Mydel;

    template <class _Fty2>
    _Packaged_state(const _Fty2& _Fnarg) : _Fn(_Fnarg) {}


#line 540 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\future"

    template <class _Fty2>
    _Packaged_state(_Fty2&& _Fnarg) : _Fn(::std:: forward<_Fty2>(_Fnarg)) {}


#line 549 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\future"

    void _Call_deferred(_ArgTypes... _Args) { 
        try {
        
        this->_Set_value(::std:: addressof(_Fn(::std:: forward<_ArgTypes>(_Args)...)), true);
        } catch (...) {
        
        this->_Set_exception(::std:: current_exception(), true);
        }
    }

    void _Call_immediate(_ArgTypes... _Args) { 
        try {
        
        this->_Set_value(::std:: addressof(_Fn(::std:: forward<_ArgTypes>(_Args)...)), false);
        } catch (...) {
        
        this->_Set_exception(::std:: current_exception(), false);
        }
    }

    const function<_Ret&(_ArgTypes...)>& _Get_fn() {
        return _Fn;
    }

private:
    function<_Ret&(_ArgTypes...)> _Fn;
};

template <class... _ArgTypes>
class _Packaged_state<void(_ArgTypes...)>
    : public _Associated_state<int> { 
public:
    using _Mybase = _Associated_state<int>;
    using _Mydel  = typename _Mybase::_Mydel;

    template <class _Fty2>
    _Packaged_state(const _Fty2& _Fnarg) : _Fn(_Fnarg) {}


#line 593 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\future"

    template <class _Fty2>
    _Packaged_state(_Fty2&& _Fnarg) : _Fn(::std:: forward<_Fty2>(_Fnarg)) {}


#line 602 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\future"

    void _Call_deferred(_ArgTypes... _Args) { 
        try {
        
        _Fn(::std:: forward<_ArgTypes>(_Args)...);
        this->_Set_value(1, true);
        } catch (...) {
        
        this->_Set_exception(::std:: current_exception(), true);
        }
    }

    void _Call_immediate(_ArgTypes... _Args) { 
        try {
        
        _Fn(::std:: forward<_ArgTypes>(_Args)...);
        this->_Set_value(1, false);
        } catch (...) {
        
        this->_Set_exception(::std:: current_exception(), false);
        }
    }

    const function<void(_ArgTypes...)>& _Get_fn() {
        return _Fn;
    }

private:
    function<void(_ArgTypes...)> _Fn;
};

template <class _Ty, class _Alloc>
_Associated_state<_Ty>* _Make_associated_state(const _Alloc& _Al) {
    
    using _Delty   = _State_deleter<_Ty, _Associated_state<_Ty>, _Alloc>;
    using _Aldelty = _Rebind_alloc_t<_Alloc, _Delty>;
    using _Alstate = _Rebind_alloc_t<_Alloc, _Associated_state<_Ty>>;

    _Aldelty _Del_alloc(_Al);
    _Alstate _State_alloc(_Al);
    auto _Del = _Make_unique_alloc(_Del_alloc, _Al);
    auto _Res = _Make_unique_alloc(_State_alloc, _Unfancy(_Del.get()));
    (void) _Del.release(); 
    return _Unfancy(_Res.release()); 
}


#line 664 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\future"

template <class _Rx>
class _Deferred_async_state : public _Packaged_state<_Rx()> {
    
public:
    template <class _Fty2>
    _Deferred_async_state(const _Fty2& _Fnarg) : _Packaged_state<_Rx()>(_Fnarg) {}

    template <class _Fty2>
    _Deferred_async_state(_Fty2&& _Fnarg) : _Packaged_state<_Rx()>(::std:: forward<_Fty2>(_Fnarg)) {}

private:
    bool _Has_deferred_function() const noexcept override {
        
        return !this->_Running;
    }

    void _Run_deferred_function(unique_lock<mutex>& _Lock) override { 
        _Lock.unlock();
        _Packaged_state<_Rx()>::_Call_immediate();
        _Lock.lock();
    }
};

template <class _Rx>
class _Task_async_state : public _Packaged_state<_Rx()> {
    
public:
    using _Mybase     = _Packaged_state<_Rx()>;
    using _State_type = typename _Mybase::_State_type;

    template <class _Fty2>
    _Task_async_state(_Fty2&& _Fnarg) : _Mybase(::std:: forward<_Fty2>(_Fnarg)) {
        _Task = ::Concurrency::create_task([this]() { 
            this->_Call_immediate();
        });

        this->_Running = true;
    }

    ~_Task_async_state() noexcept override {
        _Wait();
    }

    void _Wait() override { 
        _Task.wait();
    }

    _State_type& _Get_value(bool _Get_only_once) override {
        
        _Task.wait();
        return _Mybase::_Get_value(_Get_only_once);
    }

private:
    ::Concurrency::task<void> _Task;
};

template <class _Ty>
class _State_manager {
    
public:
    _State_manager() : _Assoc_state(nullptr) { 
        _Get_only_once = false;
    }

    _State_manager(_Associated_state<_Ty>* _New_state, bool _Get_once)
        : _Assoc_state(_New_state) { 
        _Get_only_once = _Get_once;
    }

    _State_manager(const _State_manager& _Other, bool _Get_once = false) : _Assoc_state(nullptr) {
        _Copy_from(_Other);
        _Get_only_once = _Get_once;
    }

    _State_manager(_State_manager&& _Other, bool _Get_once = false) : _Assoc_state(nullptr) {
        _Move_from(_Other);
        _Get_only_once = _Get_once;
    }

    ~_State_manager() noexcept {
        if (_Assoc_state) {
            _Assoc_state->_Release();
        }
    }

    _State_manager& operator=(const _State_manager& _Other) {
        _Copy_from(_Other);
        return *this;
    }

    _State_manager& operator=(_State_manager&& _Other) {
        _Move_from(_Other);
        return *this;
    }

    [[nodiscard]] bool valid() const noexcept {
        return _Assoc_state && !(_Get_only_once && _Assoc_state->_Already_retrieved());
    }

    void wait() const { 
        if (!valid()) {
            _Throw_future_error(make_error_code(future_errc::no_state));
        }

        _Assoc_state->_Wait();
    }

    template <class _Rep, class _Per>
    future_status wait_for(const chrono::duration<_Rep, _Per>& _Rel_time) const { 
        if (!valid()) {
            _Throw_future_error(make_error_code(future_errc::no_state));
        }

        return _Assoc_state->_Wait_for(_Rel_time);
    }

    template <class _Clock, class _Dur>
    future_status wait_until(const chrono::time_point<_Clock, _Dur>& _Abs_time) const { 

        static_assert(chrono::is_clock_v<_Clock>, "Clock type required");
#line 787 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\future"
        if (!valid()) {
            _Throw_future_error(make_error_code(future_errc::no_state));
        }

        return _Assoc_state->_Wait_until(_Abs_time);
    }

    _Ty& _Get_value() const {
        if (!valid()) {
            _Throw_future_error(make_error_code(future_errc::no_state));
        }

        return _Assoc_state->_Get_value(_Get_only_once);
    }

    void _Set_value(const _Ty& _Val, bool _Defer) { 
        if (!valid()) {
            _Throw_future_error(make_error_code(future_errc::no_state));
        }

        _Assoc_state->_Set_value(_Val, _Defer);
    }

    void _Set_value(_Ty&& _Val, bool _Defer) { 
        if (!valid()) {
            _Throw_future_error(make_error_code(future_errc::no_state));
        }

        _Assoc_state->_Set_value(::std:: forward<_Ty>(_Val), _Defer);
    }

    void _Abandon() { 
        if (_Assoc_state) {
            _Assoc_state->_Abandon();
        }
    }

    void _Set_exception(exception_ptr _Exc, bool _Defer) { 
        if (!valid()) {
            _Throw_future_error(make_error_code(future_errc::no_state));
        }

        _Assoc_state->_Set_exception(_Exc, _Defer);
    }

    void _Swap(_State_manager& _Other) { 
        ::std:: swap(_Assoc_state, _Other._Assoc_state);
    }

    _Associated_state<_Ty>* _Ptr() const {
        return _Assoc_state;
    }

    void _Copy_from(const _State_manager& _Other) { 
        if (this != ::std:: addressof(_Other)) {
            if (_Assoc_state) {
                _Assoc_state->_Release();
            }

            if (_Other._Assoc_state) { 
                _Other._Assoc_state->_Retain();
                _Assoc_state   = _Other._Assoc_state;
                _Get_only_once = _Other._Get_only_once;
            } else {
                _Assoc_state = nullptr;
            }
        }
    }

    void _Move_from(_State_manager& _Other) { 
        if (this != ::std:: addressof(_Other)) {
            if (_Assoc_state) {
                _Assoc_state->_Release();
            }

            _Assoc_state        = _Other._Assoc_state;
            _Other._Assoc_state = nullptr;
            _Get_only_once      = _Other._Get_only_once;
        }
    }

    bool _Is_ready() const {
        return _Assoc_state && _Assoc_state->_Is_ready();
    }

    bool _Is_ready_at_thread_exit() const {
        return _Assoc_state && _Assoc_state->_Is_ready_at_thread_exit();
    }

private:
    _Associated_state<_Ty>* _Assoc_state;
    bool _Get_only_once;
};

template <class _Ty>
class shared_future;

template <class _Ty>
class future : public _State_manager<_Ty> {
    
    using _Mybase = _State_manager<_Ty>;

public:
    static_assert(!is_array_v<_Ty> && is_object_v<_Ty> && is_destructible_v<_Ty>,
        "T in future<T> must meet the Cpp17Destructible requirements (N4878 [futures.unique.future]/4).");

    future() noexcept {}

    future(future&& _Other) noexcept : _Mybase(::std:: move(_Other), true) {}

    future& operator=(future&& _Right) noexcept {
        _Mybase::operator=(::std:: move(_Right));
        return *this;
    }

    future(const _Mybase& _State, _Nil) : _Mybase(_State, true) {}

    ~future() noexcept {}

    _Ty get() {
        
        future _Local{::std:: move(*this)};
        return ::std:: move(_Local._Get_value());
    }

    [[nodiscard]] shared_future<_Ty> share() noexcept {
        return shared_future<_Ty>(::std:: move(*this));
    }

    future(const future&) = delete;
    future& operator=(const future&) = delete;
};

template <class _Ty>
class future<_Ty&> : public _State_manager<_Ty*> {
    
    using _Mybase = _State_manager<_Ty*>;

public:
    future() noexcept {}

    future(future&& _Other) noexcept : _Mybase(::std:: move(_Other), true) {}

    future& operator=(future&& _Right) noexcept {
        _Mybase::operator=(::std:: move(_Right));
        return *this;
    }

    future(const _Mybase& _State, _Nil) : _Mybase(_State, true) {}

    ~future() noexcept {}

    _Ty& get() {
        
        future _Local{::std:: move(*this)};
        return *_Local._Get_value();
    }

    [[nodiscard]] shared_future<_Ty&> share() noexcept {
        return shared_future<_Ty&>(::std:: move(*this));
    }

    future(const future&) = delete;
    future& operator=(const future&) = delete;
};

template <>
class future<void> : public _State_manager<int> {
    
    using _Mybase = _State_manager<int>;

public:
    future() noexcept {}

    future(future&& _Other) noexcept : _Mybase(::std:: move(_Other), true) {}

    future& operator=(future&& _Right) noexcept {
        _Mybase::operator=(::std:: move(_Right));
        return *this;
    }

    future(const _Mybase& _State, _Nil) : _Mybase(_State, true) {}

    ~future() noexcept {}

    void get() {
        
        future _Local{::std:: move(*this)};
        _Local._Get_value();
    }

    [[nodiscard]] shared_future<void> share() noexcept;

    future(const future&) = delete;
    future& operator=(const future&) = delete;
};

template <class _Ty>
class shared_future : public _State_manager<_Ty> {
    
    using _Mybase = _State_manager<_Ty>;

public:
    static_assert(!is_array_v<_Ty> && is_object_v<_Ty> && is_destructible_v<_Ty>,
        "T in shared_future<T> must meet the Cpp17Destructible requirements (N4878 [futures.shared.future]/4).");

    shared_future() noexcept {}

    shared_future(const shared_future& _Other) noexcept : _Mybase(_Other) {}

    shared_future& operator=(const shared_future& _Right) noexcept {
        _Mybase::operator=(_Right);
        return *this;
    }

    shared_future(future<_Ty>&& _Other) noexcept : _Mybase(::std:: forward<_Mybase>(_Other)) {}

    shared_future(shared_future&& _Other) noexcept : _Mybase(::std:: move(_Other)) {}

    shared_future& operator=(shared_future&& _Right) noexcept {
        _Mybase::operator=(::std:: move(_Right));
        return *this;
    }

    ~shared_future() noexcept {}

    const _Ty& get() const {
        
        return this->_Get_value();
    }
};

template <class _Ty>
class shared_future<_Ty&> : public _State_manager<_Ty*> {
    
    using _Mybase = _State_manager<_Ty*>;

public:
    shared_future() noexcept {}

    shared_future(const shared_future& _Other) noexcept : _Mybase(_Other) {}

    shared_future& operator=(const shared_future& _Right) noexcept {
        _Mybase::operator=(_Right);
        return *this;
    }

    shared_future(future<_Ty&>&& _Other) noexcept : _Mybase(::std:: forward<_Mybase>(_Other)) {}

    shared_future(shared_future&& _Other) noexcept : _Mybase(::std:: move(_Other)) {}

    shared_future& operator=(shared_future&& _Right) noexcept {
        _Mybase::operator=(::std:: move(_Right));
        return *this;
    }

    ~shared_future() noexcept {}

    _Ty& get() const {
        
        return *this->_Get_value();
    }
};

template <>
class shared_future<void> : public _State_manager<int> {
    
    using _Mybase = _State_manager<int>;

public:
    shared_future() noexcept {}

    shared_future(const shared_future& _Other) noexcept : _Mybase(_Other) {}

    shared_future& operator=(const shared_future& _Right) noexcept {
        _Mybase::operator=(_Right);
        return *this;
    }

    shared_future(shared_future&& _Other) noexcept : _Mybase(::std:: move(_Other)) {}

    shared_future(future<void>&& _Other) noexcept : _Mybase(::std:: forward<_Mybase>(_Other)) {}

    shared_future& operator=(shared_future&& _Right) {
        _Mybase::operator=(::std:: move(_Right));
        return *this;
    }

    ~shared_future() noexcept {}

    void get() const { 
        this->_Get_value();
    }
};

[[nodiscard]] inline shared_future<void> future<void>::share() noexcept {
    return shared_future<void>(::std:: move(*this));
}

template <class _Ty>
class _Promise {
public:
    _Promise(_Associated_state<_Ty>* _State_ptr) : _State(_State_ptr, false), _Future_retrieved(false) {}

    _Promise(_Promise&& _Other) : _State(::std:: move(_Other._State)), _Future_retrieved(_Other._Future_retrieved) {}

    _Promise& operator=(_Promise&& _Other) {
        _State            = ::std:: move(_Other._State);
        _Future_retrieved = _Other._Future_retrieved;
        return *this;
    }

    ~_Promise() noexcept {}

    void _Swap(_Promise& _Other) {
        _State._Swap(_Other._State);
        ::std:: swap(_Future_retrieved, _Other._Future_retrieved);
    }

    const _State_manager<_Ty>& _Get_state() const {
        return _State;
    }
    _State_manager<_Ty>& _Get_state() {
        return _State;
    }

    _State_manager<_Ty>& _Get_state_for_set() {
        if (!_State.valid()) {
            _Throw_future_error(make_error_code(future_errc::no_state));
        }

        return _State;
    }

    _State_manager<_Ty>& _Get_state_for_future() {
        if (!_State.valid()) {
            _Throw_future_error(make_error_code(future_errc::no_state));
        }

        if (_Future_retrieved) {
            _Throw_future_error(make_error_code(future_errc::future_already_retrieved));
        }

        _Future_retrieved = true;
        return _State;
    }

    bool _Is_valid() const noexcept {
        return _State.valid();
    }

    bool _Is_ready() const {
        return _State._Is_ready();
    }

    bool _Is_ready_at_thread_exit() const {
        return _State._Is_ready_at_thread_exit();
    }

    _Promise(const _Promise&) = delete;
    _Promise& operator=(const _Promise&) = delete;

private:
    _State_manager<_Ty> _State;
    bool _Future_retrieved;
};

template <class _Ty>
class promise { 
public:
    static_assert(!is_array_v<_Ty> && is_object_v<_Ty> && is_destructible_v<_Ty>,
        "T in promise<T> must meet the Cpp17Destructible requirements (N4878 [futures.promise]/1).");

    promise() : _MyPromise(new _Associated_state<_Ty>) {}

    template <class _Alloc>
    promise(allocator_arg_t, const _Alloc& _Al) : _MyPromise(_Make_associated_state<_Ty>(_Al)) {}

    promise(promise&& _Other) noexcept : _MyPromise(::std:: move(_Other._MyPromise)) {}

    promise& operator=(promise&& _Other) noexcept {
        promise(::std:: move(_Other)).swap(*this);
        return *this;
    }

    ~promise() noexcept {
        if (_MyPromise._Is_valid() && !_MyPromise._Is_ready() && !_MyPromise._Is_ready_at_thread_exit()) {
            
            future_error _Fut(make_error_code(future_errc::broken_promise));
            _MyPromise._Get_state()._Set_exception(::std:: make_exception_ptr(_Fut), false);
        }
    }

    void swap(promise& _Other) noexcept {
        _MyPromise._Swap(_Other._MyPromise);
    }

    [[nodiscard]] future<_Ty> get_future() {
        return future<_Ty>(_MyPromise._Get_state_for_future(), _Nil{});
    }

    void set_value(const _Ty& _Val) {
        _MyPromise._Get_state_for_set()._Set_value(_Val, false);
    }

    void set_value_at_thread_exit(const _Ty& _Val) {
        _MyPromise._Get_state_for_set()._Set_value(_Val, true);
    }

    void set_value(_Ty&& _Val) {
        _MyPromise._Get_state_for_set()._Set_value(::std:: forward<_Ty>(_Val), false);
    }

    void set_value_at_thread_exit(_Ty&& _Val) {
        _MyPromise._Get_state_for_set()._Set_value(::std:: forward<_Ty>(_Val), true);
    }

    void set_exception(exception_ptr _Exc) {
        _MyPromise._Get_state_for_set()._Set_exception(_Exc, false);
    }

    void set_exception_at_thread_exit(exception_ptr _Exc) {
        _MyPromise._Get_state_for_set()._Set_exception(_Exc, true);
    }

    promise(const promise&) = delete;
    promise& operator=(const promise&) = delete;

private:
    _Promise<_Ty> _MyPromise;
};

template <class _Ty>
class promise<_Ty&> { 
public:
    promise() : _MyPromise(new _Associated_state<_Ty*>) {}

    template <class _Alloc>
    promise(allocator_arg_t, const _Alloc& _Al) : _MyPromise(_Make_associated_state<_Ty*>(_Al)) {}

    promise(promise&& _Other) noexcept : _MyPromise(::std:: move(_Other._MyPromise)) {}

    promise& operator=(promise&& _Other) noexcept {
        promise(::std:: move(_Other)).swap(*this);
        return *this;
    }

    ~promise() noexcept {
        if (_MyPromise._Is_valid() && !_MyPromise._Is_ready() && !_MyPromise._Is_ready_at_thread_exit()) {
            
            future_error _Fut(make_error_code(future_errc::broken_promise));
            _MyPromise._Get_state()._Set_exception(::std:: make_exception_ptr(_Fut), false);
        }
    }

    void swap(promise& _Other) noexcept {
        _MyPromise._Swap(_Other._MyPromise);
    }

    [[nodiscard]] future<_Ty&> get_future() {
        return future<_Ty&>(_MyPromise._Get_state_for_future(), _Nil{});
    }

    void set_value(_Ty& _Val) {
        _MyPromise._Get_state_for_set()._Set_value(::std:: addressof(_Val), false);
    }

    void set_value_at_thread_exit(_Ty& _Val) {
        _MyPromise._Get_state_for_set()._Set_value(::std:: addressof(_Val), true);
    }

    void set_exception(exception_ptr _Exc) {
        _MyPromise._Get_state_for_set()._Set_exception(_Exc, false);
    }

    void set_exception_at_thread_exit(exception_ptr _Exc) {
        _MyPromise._Get_state_for_set()._Set_exception(_Exc, true);
    }

    promise(const promise&) = delete;
    promise& operator=(const promise&) = delete;

private:
    _Promise<_Ty*> _MyPromise;
};

template <>
class promise<void> { 
public:
    promise() : _MyPromise(new _Associated_state<int>) {}

    template <class _Alloc>
    promise(allocator_arg_t, const _Alloc& _Al) : _MyPromise(_Make_associated_state<int>(_Al)) {}

    promise(promise&& _Other) noexcept : _MyPromise(::std:: move(_Other._MyPromise)) {}

    promise& operator=(promise&& _Other) noexcept {
        promise(::std:: move(_Other)).swap(*this);
        return *this;
    }

    ~promise() noexcept {
        if (_MyPromise._Is_valid() && !_MyPromise._Is_ready() && !_MyPromise._Is_ready_at_thread_exit()) {
            
            future_error _Fut(make_error_code(future_errc::broken_promise));
            _MyPromise._Get_state()._Set_exception(::std:: make_exception_ptr(_Fut), false);
        }
    }

    void swap(promise& _Other) noexcept {
        _MyPromise._Swap(_Other._MyPromise);
    }

    [[nodiscard]] future<void> get_future() {
        return future<void>(_MyPromise._Get_state_for_future(), _Nil{});
    }

    void set_value() {
        _MyPromise._Get_state_for_set()._Set_value(1, false);
    }

    void set_value_at_thread_exit() {
        _MyPromise._Get_state_for_set()._Set_value(1, true);
    }

    void set_exception(exception_ptr _Exc) {
        _MyPromise._Get_state_for_set()._Set_exception(_Exc, false);
    }

    void set_exception_at_thread_exit(exception_ptr _Exc) {
        _MyPromise._Get_state_for_set()._Set_exception(_Exc, true);
    }

    promise(const promise&) = delete;
    promise& operator=(const promise&) = delete;

private:
    _Promise<int> _MyPromise;
};

template <class _Ty, class _Alloc>
struct uses_allocator<promise<_Ty>, _Alloc> : true_type {};

template <class _Ty>
void swap(promise<_Ty>& _Left, promise<_Ty>& _Right) noexcept {
    _Left.swap(_Right);
}

template <class _Fret>
struct _P_arg_type { 
    using type = _Fret;
};

template <class _Fret>
struct _P_arg_type<_Fret&> { 
    using type = _Fret*;
};

template <>
struct _P_arg_type<void> { 
    using type = int;
};

template <class>
class packaged_task; 

template <class _Ret, class... _ArgTypes>
class packaged_task<_Ret(_ArgTypes...)> {
    
public:
    using _Ptype              = typename _P_arg_type<_Ret>::type;
    using _MyPromiseType      = _Promise<_Ptype>;
    using _MyStateManagerType = _State_manager<_Ptype>;
    using _MyStateType        = _Packaged_state<_Ret(_ArgTypes...)>;

    packaged_task() noexcept : _MyPromise(0) {}

    template <class _Fty2, enable_if_t<!is_same_v<_Remove_cvref_t<_Fty2>, packaged_task>, int> = 0>
    explicit packaged_task(_Fty2&& _Fnarg) : _MyPromise(new _MyStateType(::std:: forward<_Fty2>(_Fnarg))) {}

    packaged_task(packaged_task&& _Other) noexcept : _MyPromise(::std:: move(_Other._MyPromise)) {}

    packaged_task& operator=(packaged_task&& _Other) noexcept {
        _MyPromise = ::std:: move(_Other._MyPromise);
        return *this;
    }


#line 1379 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\future"

    ~packaged_task() noexcept {
        _MyPromise._Get_state()._Abandon();
    }

    void swap(packaged_task& _Other) noexcept {
        ::std:: swap(_MyPromise, _Other._MyPromise);
    }

    [[nodiscard]] bool valid() const noexcept {
        return _MyPromise._Is_valid();
    }

    [[nodiscard]] future<_Ret> get_future() {
        return future<_Ret>(_MyPromise._Get_state_for_future(), _Nil{});
    }

    void operator()(_ArgTypes... _Args) {
        if (_MyPromise._Is_ready()) {
            _Throw_future_error(make_error_code(future_errc::promise_already_satisfied));
        }

        _MyStateManagerType& _State = _MyPromise._Get_state_for_set();
        _MyStateType* _Ptr          = static_cast<_MyStateType*>(_State._Ptr());
        _Ptr->_Call_immediate(::std:: forward<_ArgTypes>(_Args)...);
    }

    void make_ready_at_thread_exit(_ArgTypes... _Args) {
        if (_MyPromise._Is_ready()) {
            _Throw_future_error(make_error_code(future_errc::promise_already_satisfied));
        }

        _MyStateManagerType& _State = _MyPromise._Get_state_for_set();
        if (_State._Ptr()->_Already_has_stored_result()) {
            _Throw_future_error(make_error_code(future_errc::promise_already_satisfied));
        }

        _MyStateType* _Ptr = static_cast<_MyStateType*>(_State._Ptr());
        _Ptr->_Call_deferred(::std:: forward<_ArgTypes>(_Args)...);
    }

    void reset() { 
        _MyStateManagerType& _State         = _MyPromise._Get_state_for_set();
        _MyStateType* _MyState              = static_cast<_MyStateType*>(_State._Ptr());
        function<_Ret(_ArgTypes...)> _Fnarg = _MyState->_Get_fn();
        _MyPromiseType _New_promise(new _MyStateType(_Fnarg));
        _MyPromise._Get_state()._Abandon();
        _MyPromise._Swap(_New_promise);
    }

    packaged_task(const packaged_task&) = delete;
    packaged_task& operator=(const packaged_task&) = delete;

private:
    _MyPromiseType _MyPromise;
};


template <class _Ret, class... _Types> packaged_task(_Ret(__cdecl*)(_Types...)) -> packaged_task<_Ret(_Types...)>;  template <class _Ret, class... _Types> packaged_task(_Ret(__fastcall*)(_Types...)) -> packaged_task<_Ret(_Types...)>; template <class _Ret, class... _Types> packaged_task(_Ret(__stdcall*)(_Types...)) -> packaged_task<_Ret(_Types...)>; template <class _Ret, class... _Types> packaged_task(_Ret(__vectorcall*)(_Types...)) -> packaged_task<_Ret(_Types...)>;


template <class _Fx>
packaged_task(_Fx) -> packaged_task<typename _Deduce_signature<_Fx>::type>;
#line 1447 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\future"


#line 1452 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\future"

template <class _Ty>
void swap(packaged_task<_Ty>& _Left, packaged_task<_Ty>& _Right) noexcept {
    _Left.swap(_Right);
}

template <class... _Types, size_t... _Indices>
auto _Invoke_stored_explicit(tuple<_Types...>&& _Tuple, index_sequence<_Indices...>) -> decltype(::std:: invoke(
    ::std:: get<_Indices>(::std:: move(_Tuple))...)) { 
    return ::std:: invoke(::std:: get<_Indices>(::std:: move(_Tuple))...);
}

template <class... _Types>
auto _Invoke_stored(tuple<_Types...>&& _Tuple)
    -> decltype(_Invoke_stored_explicit(::std:: move(_Tuple), index_sequence_for<_Types...>{})) { 
    return _Invoke_stored_explicit(::std:: move(_Tuple), index_sequence_for<_Types...>{});
}

template <class... _Types>
class _Fake_no_copy_callable_adapter {
    
    
    using _Storaget = tuple<decay_t<_Types>...>;

public:
    explicit _Fake_no_copy_callable_adapter(_Types&&... _Vals) : _Storage(::std:: forward<_Types>(_Vals)...) {
        
    }

    _Fake_no_copy_callable_adapter(const _Fake_no_copy_callable_adapter& _Other)
        : _Storage(::std:: move(_Other._Storage)) {
        ::std:: terminate(); 
    }

    _Fake_no_copy_callable_adapter(_Fake_no_copy_callable_adapter&& _Other) = default;
    _Fake_no_copy_callable_adapter& operator=(const _Fake_no_copy_callable_adapter&) = delete;
    _Fake_no_copy_callable_adapter& operator=(_Fake_no_copy_callable_adapter&&) = delete;

    auto operator()() -> decltype(_Invoke_stored(::std:: move(::std:: declval<_Storaget&>()))) {
        return _Invoke_stored(::std:: move(_Storage));
    }

private:
    mutable _Storaget _Storage;
};

template <class _Ret, class _Fty>
_Associated_state<typename _P_arg_type<_Ret>::type>* _Get_associated_state(
    launch _Psync, _Fty&& _Fnarg) { 
    switch (_Psync) { 
    case launch::deferred:
        return new _Deferred_async_state<_Ret>(::std:: forward<_Fty>(_Fnarg));
    case launch::async: 
    default:
        return new _Task_async_state<_Ret>(::std:: forward<_Fty>(_Fnarg));
    }
}

template <class _Fty, class... _ArgTypes>
[[nodiscard]] future<_Invoke_result_t<decay_t<_Fty>, decay_t<_ArgTypes>...>> async(
    launch _Policy, _Fty&& _Fnarg, _ArgTypes&&... _Args) {
    
    using _Ret   = _Invoke_result_t<decay_t<_Fty>, decay_t<_ArgTypes>...>;
    using _Ptype = typename _P_arg_type<_Ret>::type;
    _Promise<_Ptype> _Pr(
        _Get_associated_state<_Ret>(_Policy, _Fake_no_copy_callable_adapter<_Fty, _ArgTypes...>(
                                                 ::std:: forward<_Fty>(_Fnarg), ::std:: forward<_ArgTypes>(_Args)...)));

    return future<_Ret>(_Pr._Get_state_for_future(), _Nil{});
}

template <class _Fty, class... _ArgTypes>
[[nodiscard]] future<_Invoke_result_t<decay_t<_Fty>, decay_t<_ArgTypes>...>> async(_Fty&& _Fnarg, _ArgTypes&&... _Args) {
    
    return ::std:: async(launch::async | launch::deferred, ::std:: forward<_Fty>(_Fnarg), ::std:: forward<_ArgTypes>(_Args)...);
}


}


#pragma warning(pop)
#pragma pack(pop)
#line 1634 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\future"
#line 1635 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\future"
#line 102 "all-std.cxx"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\latch"


#pragma once


#line 19 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\latch"


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {

class latch {
public:
    [[nodiscard]] static constexpr ptrdiff_t(max)() noexcept {
        return (1ULL << (sizeof(ptrdiff_t) * 8 - 1)) - 1;
    }

    constexpr explicit latch(const ptrdiff_t _Expected) noexcept  : _Counter{_Expected} {
        do { if (_Expected >= 0) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
    }

    latch(const latch&) = delete;
    latch& operator=(const latch&) = delete;

    void count_down(const ptrdiff_t _Update = 1) noexcept  {
        do { if (_Update >= 0) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
        
        const ptrdiff_t _Current = _Counter.fetch_sub(_Update) - _Update;
        if (_Current == 0) {
            _Counter.notify_all();
        } else {
            do { if (_Current >= 0) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
        }
    }

    [[nodiscard]] bool try_wait() const noexcept {
        
        return _Counter.load() == 0;
    }

    void wait() const noexcept  {
        for (;;) {
            
            const ptrdiff_t _Current = _Counter.load();
            if (_Current == 0) {
                return;
            } else {
                do { if (_Current > 0) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 70 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\latch"
            }
            _Counter.wait(_Current, memory_order_relaxed);
        }
    }

    void arrive_and_wait(const ptrdiff_t _Update = 1) noexcept  {
        do { if (_Update >= 0) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
        
        const ptrdiff_t _Current = _Counter.fetch_sub(_Update) - _Update;
        if (_Current == 0) {
            _Counter.notify_all();
        } else {
            do { if (_Current > 0) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
            _Counter.wait(_Current, memory_order_relaxed);
            wait();
        }
    }

private:
    atomic<ptrdiff_t> _Counter;
};

}


#pragma warning(pop)
#pragma pack(pop)
#line 99 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\latch"

#line 101 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\latch"
#line 102 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\latch"
#line 103 "all-std.cxx"

#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\semaphore"


#pragma once


#line 19 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\semaphore"


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


namespace std {

template <class _Rep, class _Period>
[[nodiscard]] unsigned long long _Semaphore_deadline(const chrono::duration<_Rep, _Period>& _Rel_time) {
    return __std_atomic_wait_get_deadline(
        chrono::duration_cast<chrono::duration<unsigned long long, milli>>(_Rel_time).count());
}

template <class _Clock, class _Duration>
[[nodiscard]] unsigned long _Semaphore_remaining_timeout(const chrono::time_point<_Clock, _Duration>& _Abs_time) {
    const auto _Now = _Clock::now();
    if (_Now >= _Abs_time) {
        return 0;
    }

    const auto _Rel_time = chrono::ceil<chrono::milliseconds>(_Abs_time - _Now);
    static constexpr chrono::milliseconds _Ten_days{chrono::hours{24 * 10}};
    static_assert(_Ten_days.count() < 0xffffffffUL, "Bad sizing assumption");
    if (_Rel_time >= _Ten_days) {
        return static_cast<unsigned long>(_Ten_days.count());
    }

    return static_cast<unsigned long>(_Rel_time.count());
}

inline constexpr ptrdiff_t _Semaphore_max = (1ULL << (sizeof(ptrdiff_t) * 8 - 1)) - 1;

template <ptrdiff_t _Least_max_value = _Semaphore_max>
class counting_semaphore {
public:
    [[nodiscard]] static constexpr ptrdiff_t(max)() noexcept {
        return _Least_max_value;
    }

    constexpr explicit counting_semaphore(const ptrdiff_t _Desired) noexcept 
        : _Counter(_Desired) {
        do { if (_Desired >= 0 && _Desired <= _Least_max_value) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 69 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\semaphore"
    }

    counting_semaphore(const counting_semaphore&) = delete;
    counting_semaphore& operator=(const counting_semaphore&) = delete;

    void release(ptrdiff_t _Update = 1) noexcept  {
        if (_Update == 0) {
            return;
        }
        do { if (_Update > 0 && _Update <= _Least_max_value) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 80 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\semaphore"

        
        const ptrdiff_t _Prev = _Counter.fetch_add(static_cast<ptrdiff_t>(_Update));
        do { if (_Prev + _Update > 0 && _Prev + _Update <= _Least_max_value) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 96 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\semaphore"

        const ptrdiff_t _Waiting_upper_bound = _Waiting.load();

        if (_Waiting_upper_bound == 0) {
            
        } else if (_Waiting_upper_bound <= _Update) {
            
            _Counter.notify_all();
        } else {
            
            
            for (; _Update != 0; --_Update) {
                _Counter.notify_one();
            }
        }
    }

    void _Wait(const unsigned long _Remaining_timeout) noexcept {
        
        _Waiting.fetch_add(1);
        ptrdiff_t _Current = _Counter.load();
        if (_Current == 0) {
            __std_atomic_wait_direct(&_Counter, &_Current, sizeof(_Current), _Remaining_timeout);
        }
        _Waiting.fetch_sub(1, memory_order_relaxed);
    }

    void acquire() noexcept  {
        ptrdiff_t _Current = _Counter.load(memory_order_relaxed);
        for (;;) {
            while (_Current == 0) {
                _Wait(_Atomic_wait_no_timeout);
                _Current = _Counter.load(memory_order_relaxed);
            }
            do { if (_Current > 0 && _Current <= _Least_max_value) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 134 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\semaphore"

            
            if (_Counter.compare_exchange_weak(_Current, _Current - 1)) {
                return;
            }
        }
    }

    [[nodiscard]] bool try_acquire() noexcept {
        ptrdiff_t _Current = _Counter.load();
        if (_Current == 0) {
            return false;
        }
        do { if (_Current > 0 && _Current <= _Least_max_value) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 150 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\semaphore"

        return _Counter.compare_exchange_weak(_Current, _Current - 1);
    }

    template <class _Rep, class _Period>
    [[nodiscard]] bool try_acquire_for(const chrono::duration<_Rep, _Period>& _Rel_time) {
        auto _Deadline     = _Semaphore_deadline(_Rel_time);
        ptrdiff_t _Current = _Counter.load(memory_order_relaxed);
        for (;;) {
            while (_Current == 0) {
                const auto _Remaining_timeout = __std_atomic_wait_get_remaining_timeout(_Deadline);
                if (_Remaining_timeout == 0) {
                    return false;
                }
                _Wait(_Remaining_timeout);
                _Current = _Counter.load(memory_order_relaxed);
            }
            do { if (_Current > 0 && _Current <= _Least_max_value) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 170 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\semaphore"

            
            if (_Counter.compare_exchange_weak(_Current, _Current - 1)) {
                return true;
            }
        }
    }

    template <class _Clock, class _Duration>
    [[nodiscard]] bool try_acquire_until(const chrono::time_point<_Clock, _Duration>& _Abs_time) {
        static_assert(chrono::is_clock_v<_Clock>, "Clock type required");
        ptrdiff_t _Current = _Counter.load(memory_order_relaxed);
        for (;;) {
            while (_Current == 0) {
                const unsigned long _Remaining_timeout = _Semaphore_remaining_timeout(_Abs_time);
                if (_Remaining_timeout == 0) {
                    return false;
                }
                _Wait(_Remaining_timeout);
                _Current = _Counter.load(memory_order_relaxed);
            }
            do { if (_Current > 0 && _Current <= _Least_max_value) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 194 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\semaphore"

            
            if (_Counter.compare_exchange_weak(_Current, _Current - 1)) {
                return true;
            }
        }
    }

private:
    atomic<ptrdiff_t> _Counter;
    atomic<ptrdiff_t> _Waiting;
};

template <>
class counting_semaphore<1> {
public:
    [[nodiscard]] static constexpr ptrdiff_t(max)() noexcept {
        return 1;
    }

    constexpr explicit counting_semaphore(const ptrdiff_t _Desired) noexcept 
        : _Counter(static_cast<unsigned char>(_Desired)) {
        do { if ((_Desired & ~1) == 0) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 218 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\semaphore"
    }

    counting_semaphore(const counting_semaphore&) = delete;
    counting_semaphore& operator=(const counting_semaphore&) = delete;

    void release(const ptrdiff_t _Update = 1) noexcept  {
        if (_Update == 0) {
            return;
        }
        do { if (_Update == 1) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 229 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\semaphore"
        
        _Counter.store(1);
        _Counter.notify_one();
    }

    void acquire() noexcept  {
        for (;;) {
            
            
            unsigned char _Prev = _Counter.exchange(0);
            if (_Prev == 1) {
                break;
            }
            do { if (_Prev == 0) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 244 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\semaphore"
            _Counter.wait(0, memory_order_relaxed);
        }
    }

    [[nodiscard]] bool try_acquire() noexcept {
        
        unsigned char _Prev = _Counter.exchange(0);
        do { if ((_Prev & ~1) == 0) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 253 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\semaphore"
        return reinterpret_cast<const bool&>(_Prev);
    }

    template <class _Rep, class _Period>
    [[nodiscard]] bool try_acquire_for(const chrono::duration<_Rep, _Period>& _Rel_time) {
        auto _Deadline = _Semaphore_deadline(_Rel_time);
        for (;;) {
            
            
            unsigned char _Prev = _Counter.exchange(0);
            if (_Prev == 1) {
                return true;
            }
            do { if (_Prev == 0) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 268 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\semaphore"
            const auto _Remaining_timeout = __std_atomic_wait_get_remaining_timeout(_Deadline);
            if (_Remaining_timeout == 0) {
                return false;
            }
            __std_atomic_wait_direct(&_Counter, &_Prev, sizeof(_Prev), _Remaining_timeout);
        }
    }

    template <class _Clock, class _Duration>
    [[nodiscard]] bool try_acquire_until(const chrono::time_point<_Clock, _Duration>& _Abs_time) {
        static_assert(chrono::is_clock_v<_Clock>, "Clock type required");
        for (;;) {
            
            
            unsigned char _Prev = _Counter.exchange(0);
            if (_Prev == 1) {
                return true;
            }
            do { if (_Prev == 0) { } else { do { ; ::_invalid_parameter_noinfo_noreturn(); } while (false); } ; } while (false);
#line 288 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\semaphore"

            const unsigned long _Remaining_timeout = _Semaphore_remaining_timeout(_Abs_time);
            if (_Remaining_timeout == 0) {
                return false;
            }

            __std_atomic_wait_direct(&_Counter, &_Prev, sizeof(_Prev), _Remaining_timeout);
        }
    }

private:
    atomic<unsigned char> _Counter;
};

using binary_semaphore = counting_semaphore<1>;

}


#pragma warning(pop)
#pragma pack(pop)
#line 311 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\semaphore"

#line 313 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\semaphore"
#line 314 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\semaphore"
#line 105 "all-std.cxx"


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\assert.h"


#line 11 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\assert.h"


#pragma warning(push)
#pragma warning(disable: 4324  4514 4574 4710 4793 4820 4995 4996 28719 28726 28727 )


__pragma(pack(push, 8)) extern "C" {


     void __cdecl _wassert(
          wchar_t const* _Message,
          wchar_t const* _File,
            unsigned       _Line
        );

    
#line 42 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\assert.h"


} __pragma(pack(pop))

#pragma warning(pop) 
#line 109 "all-std.cxx"


#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\math.h"


#line 117 "all-std.cxx"


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stdatomic.h"


#pragma once


#line 13 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stdatomic.h"


#line 18 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stdatomic.h"


#line 29 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stdatomic.h"


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


template <class _Ty>
using _Std_atomic = ::std:: atomic<_Ty>;


using ::std:: memory_order;
using ::std:: memory_order_relaxed;
using ::std:: memory_order_consume;
using ::std:: memory_order_acquire;
using ::std:: memory_order_release;
using ::std:: memory_order_acq_rel;
using ::std:: memory_order_seq_cst;

using ::std:: atomic_flag;

using ::std:: atomic_bool;
using ::std:: atomic_char;
using ::std:: atomic_schar;
using ::std:: atomic_uchar;
using ::std:: atomic_short;
using ::std:: atomic_ushort;
using ::std:: atomic_int;
using ::std:: atomic_uint;
using ::std:: atomic_long;
using ::std:: atomic_ulong;
using ::std:: atomic_llong;
using ::std:: atomic_ullong;


using ::std:: atomic_char8_t;
#line 70 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stdatomic.h"

using ::std:: atomic_char16_t;
using ::std:: atomic_char32_t;
using ::std:: atomic_wchar_t;
using ::std:: atomic_int8_t;
using ::std:: atomic_uint8_t;
using ::std:: atomic_int16_t;
using ::std:: atomic_uint16_t;
using ::std:: atomic_int32_t;
using ::std:: atomic_uint32_t;
using ::std:: atomic_int64_t;
using ::std:: atomic_uint64_t;
using ::std:: atomic_int_least8_t;
using ::std:: atomic_uint_least8_t;
using ::std:: atomic_int_least16_t;
using ::std:: atomic_uint_least16_t;
using ::std:: atomic_int_least32_t;
using ::std:: atomic_uint_least32_t;
using ::std:: atomic_int_least64_t;
using ::std:: atomic_uint_least64_t;
using ::std:: atomic_int_fast8_t;
using ::std:: atomic_uint_fast8_t;
using ::std:: atomic_int_fast16_t;
using ::std:: atomic_uint_fast16_t;
using ::std:: atomic_int_fast32_t;
using ::std:: atomic_uint_fast32_t;
using ::std:: atomic_int_fast64_t;
using ::std:: atomic_uint_fast64_t;
using ::std:: atomic_intptr_t;
using ::std:: atomic_uintptr_t;
using ::std:: atomic_size_t;
using ::std:: atomic_ptrdiff_t;
using ::std:: atomic_intmax_t;
using ::std:: atomic_uintmax_t;

using ::std:: atomic_is_lock_free;
using ::std:: atomic_load;
using ::std:: atomic_load_explicit;
using ::std:: atomic_store;
using ::std:: atomic_store_explicit;
using ::std:: atomic_exchange;
using ::std:: atomic_exchange_explicit;
using ::std:: atomic_compare_exchange_strong;
using ::std:: atomic_compare_exchange_strong_explicit;
using ::std:: atomic_compare_exchange_weak;
using ::std:: atomic_compare_exchange_weak_explicit;
using ::std:: atomic_fetch_add;
using ::std:: atomic_fetch_add_explicit;
using ::std:: atomic_fetch_sub;
using ::std:: atomic_fetch_sub_explicit;
using ::std:: atomic_fetch_or;
using ::std:: atomic_fetch_or_explicit;
using ::std:: atomic_fetch_and;
using ::std:: atomic_fetch_and_explicit;
using ::std:: atomic_flag_test_and_set;
using ::std:: atomic_flag_test_and_set_explicit;
using ::std:: atomic_flag_clear;
using ::std:: atomic_flag_clear_explicit;

using ::std:: atomic_thread_fence;
using ::std:: atomic_signal_fence;


#pragma warning(pop)
#pragma pack(pop)
#line 137 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stdatomic.h"

#line 139 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stdatomic.h"
#line 140 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stdatomic.h"
#line 130 "all-std.cxx"
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\complex.h"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ccomplex"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


[[deprecated("warning STL4004: " "<ccomplex>, <cstdalign>, <cstdbool>, and <ctgmath> are deprecated in C++17. " "You can define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef int _Header_ccomplex;
using _Hdr_ccomplex = _Header_ccomplex;


#pragma warning(pop)
#pragma pack(pop)

#line 30 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ccomplex"
#line 31 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ccomplex"
#line 16 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\complex.h"


#line 580 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\complex.h"
#line 581 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\complex.h"
#line 131 "all-std.cxx"
#line 1 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\tgmath.h"


#pragma once


#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ctgmath"


#pragma once


#pragma pack(push, 8)
#pragma warning(push, 3)
#pragma warning(disable : 4180 4412 4455 4494 4514 4574 4582 4583 4587 4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 4988 5026 5027 5045 6294    )


[[deprecated("warning STL4004: " "<ccomplex>, <cstdalign>, <cstdbool>, and <ctgmath> are deprecated in C++17. " "You can define _SILENCE_CXX17_C_HEADER_DEPRECATION_WARNING " "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning.")]] typedef int _Header_ctgmath;
using _Hdr_ctgmath = _Header_ctgmath;


#pragma warning(pop)
#pragma pack(pop)

#line 31 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ctgmath"
#line 32 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\ctgmath"
#line 17 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\tgmath.h"


#line 35 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\tgmath.h"
#line 36 "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.19041.0\\ucrt\\tgmath.h"
#line 132 "all-std.cxx"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iso646.h"


#pragma once


#line 13 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iso646.h"


#line 27 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iso646.h"

#line 29 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iso646.h"
#line 30 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\iso646.h"
#line 133 "all-std.cxx"
#line 1 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stdbool.h"


#line 22 "C:\\Program Files\\Microsoft Visual Studio\\2022\\Community\\VC\\Tools\\MSVC\\14.32.31326\\include\\stdbool.h"
#line 134 "all-std.cxx"